🚼 🎞️ 👨🏿‍🤝‍👨🏾 अजगर में जिप मॉड्यूल बनाना 🖕🏾 👏🏽 🔷

प्रागितिहास

Acronis प्रौद्योगिकियों के विकास में एक निश्चित चरण में, हमारे उत्पादों के रूप में हमारी अपनी विधानसभा के एक पायथन 3 भाषा दुभाषिया को वितरित करने की संभावना का अध्ययन करने का निर्णय लिया गया था, इसे अपने स्वयं के मॉड्यूल के साथ विस्तारित किया गया जो इन उत्पादों के बुनियादी ढांचे तक पहुंच प्रदान करता है। यह पोस्ट इस दिशा में शोध के परिणामों में से एक है।

सबसे पहले, हम परिमित पुनर्वितरण मॉड्यूल का एक सीमित कॉम्पैक्ट सेट करना चाहते थे। हालाँकि, python.org के माध्यम से वितरित सार्वजनिक अजगर विधानसभा में यह नहीं है, अकेले मानक पुस्तकालय, जो स्वयं भाषा का एक अभिन्न अंग है, इसमें एक हजार से अधिक पाई-फाइलें शामिल हैं। इसीलिए, हमने तुरंत इंटरप्रेटर की ऐसी जिज्ञासु विशेषता की ओर ध्यान आकर्षित किया, जैसे ज़िप अभिलेखागार में स्थित मॉड्यूल को आयात करने की क्षमता, जब एक या कई मॉड्यूल से संबंधित अजगर पर स्रोत कोड का पूरा सेट एक ज़िप संग्रह में पैक किया जाता है और एक ज़िप फ़ाइल द्वारा वितरित किया जाता है।

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

शुरुआत

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

सरल डेमो मॉड्यूल जिसे हम ज़िप में पैक करेंगे वे शुरू में d: \ habr \ lib में स्थित हैं:

say_hello.py

def say_hello(): print("Hello python world.")

my_sysinfo / __ init__.py
```
 from .sysinfo import print_sysinfo 
```

my_sysinfo / sysinfo.py

 import sys import traceback def print_sysinfo(): print(80 * '-') print(sys.version) print(80 * '-') traceback.print_stack() print(80 * '-')

चूंकि, अन्य चीजों के बीच, मैं सिर्फ कुछ मॉड्यूल को एक ज़िप फ़ाइल में पैक करने की क्षमता प्रदर्शित करना चाहता था, यहां मैंने अलग-अलग प्रकार के दो मॉड्यूल बनाए, पहला say_hello मॉड्यूल में say_hello() फ़ंक्शन के साथ एक say_hello.py फ़ाइल शामिल है, दूसरा my_sysinfo मॉड्यूल थोड़ा और अधिक जटिल बना है - एक निर्देशिका के रूप में __init__.py फ़ाइल जिसमें आयात सूची में print_sysinfo फ़ंक्शन है। आगे देखते हुए, मैं तुरंत कहता हूँ कि यह फ़ंक्शन, जैसे कि sys.version जैसी अन्य सारांश जानकारी के sys.version विशेष रूप से जिप पेजिंग की विशेषताओं का खुलासा करने के लिए अपने स्वयं के कॉल स्टैक को प्रिंट करता है।

हम जाँचते हैं कि सब कुछ अनपैक्ड रूप में काम करता है:

 c:\Python33\python.exe

 Python 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:03:43) [MSC v.1600 32 bit (Intel)] on win32 Type "help", "copyright", "credits" or "license" for more information. >>> import sys >>> sys.path.insert(0,'d:\\habr\\lib') >>> import say_hello >>> say_hello.say_hello() Hello python world. >>> import my_sysinfo >>> my_sysinfo.print_sysinfo() -------------------------------------------------------------------------------- 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:03:43) [MSC v.1600 32 bit (Intel)] -------------------------------------------------------------------------------- File "<stdin>", line 1, in <module> File "d:\habr\lib\my_sysinfo\sysinfo.py", line 9, in print_sysinfo traceback.print_stack() --------------------------------------------------------------------------------

जिप पैकिंग

ज़िप में स्रोत py-files की पैकेजिंग में कोई रहस्य नहीं हैं। ऐसा करने के लिए, आप अपनी उंगलियों पर उपलब्ध किसी भी ज़िप अभिलेखागार का उपयोग कर सकते हैं, या मानक zipfile मॉड्यूल से कार्यक्षमता का उपयोग करके सीधे एक अजगर स्क्रिप्ट के साथ पैक कर सकते हैं। बाद में, मैं एक साधारण पैकेजिंग स्क्रिप्ट के लिए कोड दूंगा, जिसे मैंने mkpyzip.py नाम दिया है और d: \ habr \ Tools फ़ोल्डर में डाल दिया है।

हम उपरोक्त मॉड्यूल को ज़िप फ़ाइल में पैक करते हैं: इस स्क्रिप्ट के साथ \ habr \ output \ mybundle.zip:

 :\Python33\python.exe d:\habr\tools\mkpyzip.py --src d:\habr\lib\my_sysinfo d:\habr\lib\say_hello.py --out d:\habr\output\mybundle.zip ::: d:\habr\lib\my_sysinfo\__init__.py >>> mybundle.zip/my_sysinfo/__init__.py ::: d:\habr\lib\my_sysinfo\sysinfo.py >>> mybundle.zip/my_sysinfo/sysinfo.py ::: d:\habr\lib\say_hello.py >>> mybundle.zip/say_hello.py

अन्य बातों के अलावा, इस स्क्रिप्ट में एक विस्तृत निष्कर्ष जोड़ा गया है कि किस फ़ाइल और किस नाम के तहत ज़िप संग्रह में पैक किया गया है।

हम जाँचते हैं कि इस तरह के ज़िप संग्रह में पैक किए जाने पर सब कुछ काम करता है:

 c:\Python33\python.exe

 Python 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:03:43) [MSC v.1600 32 bit (Intel)] on win32 Type "help", "copyright", "credits" or "license" for more information. >>> import sys >>> sys.path.insert(0, 'd:\\habr\\output\\mybundle.zip') >>> import say_hello >>> say_hello.say_hello() Hello python world. >>> import my_sysinfo >>> my_sysinfo.print_sysinfo() -------------------------------------------------------------------------------- 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:03:43) [MSC v.1600 32 bit (Intel)] -------------------------------------------------------------------------------- File "<stdin>", line 1, in <module> File "d:\habr\output\mybundle.zip\my_sysinfo\sysinfo.py", line 9, in print_sysinfo traceback.print_stack() --------------------------------------------------------------------------------

यह आउटपोस्ट से देखा जा सकता है कि सब कुछ अपेक्षित रूप से काम करता है, एक ज़िप आर्काइव में पैक किया जा रहा है, विशेष रूप से, हमारे फ़ंक्शन my_sysinfo.print_sysinfo() से स्टैक का एक प्रिंटआउट दिखाता है कि बुलाया फ़ंक्शन का कोड हमारी ज़िप फ़ाइल के अंदर है - d: \ habr \ output \ mybundle .zip \ my_sysinfo \ sysinfo.py

ज़िप में पैक करते समय बाइटकोड जेनरेशन

और अब एक मॉड्यूल आयात करते समय, या जब यह आयात के समय में मान्य होता है, तो एक मॉड्यूल आयात करते समय, या बायटेकोड को लोड करने और निष्पादित करने के रूप में इंटरप्रेटर की ऐसी प्रसिद्ध विशेषता को याद करने का समय है। ज़िप में पैक किए गए मॉड्यूल के मामले में, चीजें कुछ अलग हैं। ज़िप मॉड्यूल के लिए, बाइट कोड को पहले ही ज़िप फ़ाइल में जेनरेट और पैक किया जाना चाहिए, अन्यथा इंटरप्रिटर ज़िप फ़ाइल से किसी भी मॉड्यूल को आयात करते समय प्रत्येक पुनरारंभ के बाद फिर से मेमोरी में एक बाइट कोड उत्पन्न करेगा। हमारी mkpyzip.py स्क्रिप्ट में, बाइटकोड जेनरेशन पहले से ही उपलब्ध है, बस - --mkpyc विकल्प जोड़ें और जिप फाइल को --mkpyc :

 c:\Python33\python.exe d:\habr\tools\mkpyzip.py --mkpyc --src d:\habr\lib\my_sysinfo d:\habr\lib\say_hello.py --out d:\habr\output\mybundle.zip ::: d:\habr\lib\my_sysinfo\__init__.py >>> mybundle.zip/my_sysinfo/__init__.py ::: mkpyc for: d:\habr\lib\my_sysinfo\__init__.py >>> mybundle.zip/my_sysinfo/__init__.pyc ::: d:\habr\lib\my_sysinfo\sysinfo.py >>> mybundle.zip/my_sysinfo/sysinfo.py ::: mkpyc for: d:\habr\lib\my_sysinfo\sysinfo.py >>> mybundle.zip/my_sysinfo/sysinfo.pyc ::: d:\habr\lib\say_hello.py >>> mybundle.zip/say_hello.py ::: mkpyc for: d:\habr\lib\say_hello.py >>> mybundle.zip/say_hello.pyc

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

mkpyzip.py

 import argparse import imp import io import marshal import os import os.path import zipfile def compile_file(filename, codename, out): def wr_long(f, x): f.write(bytes([x & 0xff, (x >> 8) & 0xff, (x >> 16) & 0xff, (x >> 24) & 0xff])) with io.open(filename, mode='rt', encoding='utf8') as f: source = f.read() ast = compile(source, codename, 'exec', optimize=1) st = os.fstat(f.fileno()) timestamp = int(st.st_mtime) size = st.st_size & 0xFFFFFFFF out.write(b'\0\0\0\0') wr_long(out, timestamp) wr_long(out, size) marshal.dump(ast, out) out.flush() out.seek(0, 0) out.write(imp.get_magic()) def compile_in_memory(source, codename): with io.BytesIO() as fc: compile_file(source, codename, fc) return fc.getvalue() def make_module_catalog(src): root_path = os.path.abspath(os.path.normpath(src)) root_arcname = os.path.basename(root_path) if not os.path.isdir(root_path): return [(root_path, root_arcname)] catalog = [] subdirs = [(root_path, root_arcname)] while subdirs: idx = len(subdirs) - 1 subdir_path, subdir_archname = subdirs[idx] del subdirs[idx] for item in sorted(os.listdir(subdir_path)): if item == '__pycache__' or item.endswith('.pyc'): continue item_path = os.path.join(subdir_path, item) item_arcname = '/'.join([subdir_archname, item]) if os.path.isdir(item_path): subdirs.append((item_path, item_arcname)) else: catalog.append((item_path, item_arcname)) return catalog def mk_pyzip(sources, outzip, mkpyc=False): zipfilename = os.path.abspath(os.path.normpath(outzip)) display_zipname = os.path.basename(zipfilename) with zipfile.ZipFile(zipfilename, "w", zipfile.ZIP_DEFLATED) as fzip: for src in sources: catalog = make_module_catalog(src) for entry in catalog: fname, arcname = entry[0], entry[1] fzip.write(fname, arcname) print("::: {} >>> {}/{}".format(fname, display_zipname, arcname)) if mkpyc and arcname.endswith('.py'): bytes = compile_in_memory(fname, arcname) pyc_name = ''.join([os.path.splitext(arcname)[0], '.pyc']) fzip.writestr(pyc_name, bytes) print("::: mkpyc for: {} >>> {}/{}".format(fname, display_zipname, pyc_name)) def main(): parser = argparse.ArgumentParser() parser.add_argument('--src', nargs='+', required=True) parser.add_argument('--out', required=True) parser.add_argument('--mkpyc', action='store_true') args = parser.parse_args() mk_pyzip(args.src, args.out, args.mkpyc) if __name__ == '__main__': main()

बाइटकोड वैधता

मैं यह भी सुनिश्चित करने के बारे में कुछ शब्द जोड़ूंगा कि हम जो बायटेकोड उत्पन्न करते हैं वह वैध है और इंटरप्रेटर इसे तब सामान्य रूप से उठाता है जब मॉड्यूल को आयात किए बिना नए बायोटेक को मेमोरी में पुन: स्थापित करने की कोशिश करता है।
ऐसा करने के लिए, __file__ say_hello मॉड्यूल पर __file__ विशेषता को प्रिंट करें।

 c:\Python33\python.exe

 Python 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:03:43) [MSC v.1600 32 bit (Intel)] on win32 Type "help", "copyright", "credits" or "license" for more information. >>> import sys >>> sys.path.insert(0,'d:\\habr\\output\\mybundle.zip') >>> import say_hello >>> say_hello.__file__ 'd:\\habr\\output\\mybundle.zip\\say_hello.pyc'

यह तथ्य कि __file__ हमारे द्वारा जेनरेट की गई pyc फाइल के लिए लोड किए गए मॉड्यूल बिंदुओं __file__ विशेषता __file__ , हमारे bytecode की वैधता का पर्याप्त प्रमाण है।

इसके साथ, मैं शायद एक स्पष्ट विवेक के साथ अजगर भाषा में ज़िप-पैकिंग के बारे में अपनी परिचयात्मक समीक्षा को समाप्त कर सकता हूं, अगर एक "लेकिन" नहीं ...

आश्चर्य

मेरे एक सहकर्मी ने एक बार ग्रहण उठाया और, जाने-माने ऐड-ऑन PyDev की मदद से , उस अजगर स्क्रिप्ट को डीबग करने की कोशिश की, जो उसने लिखी थी, जो कि इस्तेमाल की गई थी, जिसका इस्तेमाल अन्य चीजों के अलावा, अजगर ने केवल वर्णित तकनीक का उपयोग करते हुए ज़िप किया।

मुख्य अप्रिय आश्चर्य यह था कि प्यदेव ने ऐसे मॉड्यूल को शुरू करने से पूरी तरह से इनकार कर दिया। इस परेशानी में बहुत दिलचस्पी रखते हुए, हमने समस्या के स्रोत की खोज शुरू की। अब, पहले से ही पीछे देखते हुए, हम कह सकते हैं कि, PyDev में हमारे व्यक्तिगत विश्वास के अनुसार, जिप मॉड्यूल को डिबग करने के लिए बस पर्याप्त गुणवत्ता का समर्थन नहीं है।

फिर भी, अध्ययन के समय, PyDev के तहत डिबगिंग की बारीकियों को तुरंत समीक्षा से बाहर रखा गया, क्योंकि अजगर में निर्मित pdb डिबगर ने बहुत ही संदिग्ध प्रकार के कॉल स्टैक के बारे में जानकारी प्रदान की। इसके अलावा, जानकारी केवल उस मामले में संदिग्ध थी जब स्रोत py-files के साथ, बाइट-कोड वाली pyc- फाइलें भी ज़िप-संग्रह में थीं। केवल पाई फ़ाइलों के साथ ज़िप संग्रह के मामले में, स्वचालित रूप से उत्पन्न बाइट कोड स्पष्ट रूप से कुछ अलग था, और पीडीबी में डीबगिंग ने सही जानकारी दी, जिससे कोई शिकायत नहीं हुई। डिबगिंग के अपवाद के साथ, सब कुछ उम्मीद के मुताबिक काम किया। फिर भी, हमारे बाइटकोड के साथ कुछ गड़बड़ जरूर थी। और पीडीबी ने स्पष्ट रूप से हमें यह संकेत दिया।

अब जब हमें समस्या का स्रोत मिल गया है, तो मुझे ऐसा लग रहा है कि pdb के तहत अजगर कोड को डीबग करने के विवरण में जा रहा है। समस्या के कारण को स्पष्ट करने के लिए, आइए पहले लिखे my_sysinfo मॉड्यूल से print_sysinfo () फ़ंक्शन का उपयोग करके ज़िप किए गए बाइट कोड से कॉल स्टैक को फिर से प्रिंट करें।

 c:\Python33\python.exe

 Python 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:03:43) [MSC v.1600 32 bit (Intel)] on win32 Type "help", "copyright", "credits" or "license" for more information. >>> import sys >>> sys.path.insert(0,'d:\\habr\\output\\mybundle.zip') >>> import my_sysinfo >>> my_sysinfo.print_sysinfo() -------------------------------------------------------------------------------- 3.3.2 (v3.3.2:d047928ae3f6, May 16 2013, 00:03:43) [MSC v.1600 32 bit (Intel)] -------------------------------------------------------------------------------- File "<stdin>", line 1, in <module> File "my_sysinfo/sysinfo.py", line 9, in print_sysinfo traceback.print_stack() --------------------------------------------------------------------------------

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

ज़िप फ़ाइल में बायोटेक के बिना, हमारे पास फॉर्म का एक आउटपुट था:
फ़ाइल "स्टडिन", लाइन 1, "मॉड्यूल" में
फ़ाइल " d: \ habr \ output \ mybundle.zip \ my_sysinfo \ sysinfo.py ", पंक्ति 9, Print_sysinfo में
ट्रेसबैक.प्रिंट_स्टैक ()

और बाइटकोड को जोड़ने के बाद, इसने फार्म लिया:
फ़ाइल "स्टडिन", लाइन 1, "मॉड्यूल" में
प्रिंट " my_sysinfo / sysinfo.py ", पंक्ति 9, Print_sysinfo में
ट्रेसबैक.प्रिंट_स्टैक ()

आउटपुट से यह स्पष्ट हो जाता है कि कॉल स्टैक में ज़िप आर्काइव के लिए बायटेकोड को जोड़ते समय, निरपेक्ष पथ से फ़ाइल का पथ एक रिश्तेदार पथ, इसके अलावा, ज़िप संग्रह की जड़ के सापेक्ष में बदल जाता है। यहाँ, एक चौकस पाठक को तुरंत इस बात पर आपत्ति हो सकती है कि हमने स्वयं इस mkpyzip.py उपयोगिता में compile बिलियन फ़ंक्शन compile लिए इस सापेक्ष पथ को सबमिट करके इस तरह का एक बायटेकोड उत्पन्न किया । लेकिन अगर हम इस बारे में थोड़ा गहराई से विचार करें, तो यह स्पष्ट हो जाता है कि इस मामले में पूरा रास्ता उचित नहीं है, क्योंकि हमारा अंतिम लक्ष्य एक मशीन पर जिप संग्रह इकट्ठा करना है और दूसरे पर इसका उपयोग करने में सक्षम होना है, संभवतः एक मशीन पर भी एक और ऑपरेटिंग सिस्टम।

उस समय हम में से कोई भी इंटरप्रेटर में लोडिंग जिप मॉड्यूल के कार्यान्वयन से निकटता से परिचित नहीं था, इसलिए इस प्रश्न का स्पष्ट उत्तर देना असंभव था, समस्या की जड़ क्या है: क्या हम अनजाने में बाइट कोड उत्पन्न करते हुए कुछ याद कर रहे हैं, फिर क्या अजगर में लोड मॉड्यूल लोडर गलत तरीके से लोड करते समय व्यवहार करता है।

अंत में, अजगर डेवलपर्स की सलाह लेने का फैसला खुद python-dev@python.org के माध्यम से किया गया था । उस समय उन्होंने हमें जो भी सलाह दी थी, वह केवल इस विषय पर एक बग था ताकि वर्णित समस्या का संदर्भ खो न जाए। हमने एक बग Bugs.python.org/issue18307 बनाया और प्रतीक्षा करने लगे। लगभग एक महीने तक प्रतीक्षा और अन्य समान रूप से दबाने वाली समस्याओं में उलझने के बाद, हमारा धैर्य चुपचाप समाप्त हो गया, और python33.dll डिबगर में आ गया।

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

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

निष्कर्ष

अजगर में मॉड्यूल, एक ज़िप संग्रह में पैक किया जा रहा है, साथ ही साथ अनपैक्ड रूप में भी काम करता है। केवल एक चीज जिसे आपको तैयार करने की आवश्यकता है, वह यह है कि पैकेजिंग के बाद उन दोनों को ग्रहण + PyDev और अन्य IDE के माध्यम से डीबग करने में कुछ कठिनाइयाँ हो सकती हैं, जिसमें डीबग करना भी PyDev पर आधारित है। फिर भी, कुछ स्थितियों में, बाइनरी उत्पादन मॉड्यूल के एक कॉम्पैक्ट सेट की क्षमता आईडीई में अजगर कोड को आसानी से डीबग करने की तुलना में अधिक महत्वपूर्ण हो सकती है।

पुनश्च हमने सेटप्टूल / अंडे का आविष्कार किया? नहीं।

अजगर में जिप मॉड्यूल पूरी तरह से स्वतंत्र और आत्मनिर्भर कार्यक्षमता हैं, जो भाषा दुभाषिया के मूल में अंतर्निहित हैं। setuptools / अंडे इसके लिए सबसे व्यापक रूप से ज्ञात उपयोग मामला है।

अजगर में जिप मॉड्यूल बनाना