Pyjnius: पायजनियस बनाम जेपी टाइप

खोज लेने के लिए धन्यवाद!

मुझे गलत याद हो सकता है क्योंकि वर्षों से मैंने jpype को नहीं देखा था, लेकिन हालांकि मैं साझा स्मृति के बजाय एक सर्वर (इसलिए आईपीसी) के माध्यम से JVM से बात करने के लिए एक अलग दृष्टिकोण का उपयोग कर रहा था (लेकिन आपका रीडमी इसके विपरीत संकेत देता है, और मुझे कोड पर एक त्वरित नज़र से संकेत नहीं मिलते हैं, इसलिए मैं शायद पूरी तरह से गलत हूं), और इस दृष्टिकोण ने इसे एंड्रॉइड पर अव्यवहारिक बना दिया, उदाहरण के लिए (जो कि पायजनियस विकसित करने का प्राथमिक कारण था, हालांकि कुछ लोग इसे डेस्कटॉप प्लेटफॉर्म पर इस्तेमाल करते हैं)। दूसरी तरफ, मुझे जेपी टाइप कोडबेस में एंड्रॉइड समर्थन पर ज्यादा संकेत नहीं दिख रहा है, जब तक कि native निर्देशिका इसके बारे में नहीं है, क्योंकि इसकी jni.h एओएसपी से ली गई प्रतीत होती है?

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

नमस्ते। मुझे जेपी टाइप नाम याद है, लेकिन खोज के समय हम क्या उपयोग कर सकते हैं, मुझे याद नहीं है कि 8 साल पहले इसका ईमानदारी से उपयोग क्यों नहीं किया गया था :) शुरुआत में एकमात्र लक्ष्य एंड्रॉइड के साथ संवाद करने में सक्षम होना था एपीआई, लेकिन एक मध्य आरपीसी सर्वर का उपयोग नहीं कर रहा था क्योंकि पी 4 ए प्रोजेक्ट उस समय कर रहा था।

मैंने लगभग 2 साल पहले सभी जावा ब्रिज कोड तक पहुंच बनाई थी। दुर्भाग्य से, PyJnius कोड स्पष्ट रूप से छूट गया क्योंकि यह मेरी खोज में कभी नहीं आया। मैं इस दौर में भी चूक जाता, सिवाय इसके कि मैं उस पृष्ठ की खोज कर रहा था जिसने पिछली बार अच्छी तकनीकी प्रेस विज्ञप्ति जारी की थी और दो परियोजनाओं पर चर्चा करने वाले एक ब्लॉग को ठोकर मार दी थी। मुझे यकीन नहीं है कि मैं दो साल के लिए उसी क्षेत्र में एक और सक्रिय परियोजना से कैसे चूक गया, लेकिन यह स्पष्ट रूप से मेरी गलती थी।

ऐसा लगता है कि आप जेपी टाइप को पीई4जे के साथ भ्रमित कर चुके हैं जो कि अन्य प्रमुख ब्रिज कोड है। वे सॉकेट का उपयोग करके लाभ और डाउनसाइड दोनों के साथ सब कुछ करते हैं। मैंने इसी तरह पाया कि परियोजना मेरी आवश्यकताओं को पूरा नहीं करती थी।

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

जहां तक ​​​​दृष्टिकोण है, JPype "startJVM ()" कमांड का उपयोग करके जेवीएम को पायथन से शादी करने के लिए विशेष रूप से जेएनआई का उपयोग करता है। हालांकि अगला संस्करण (2.0) भी इसके विपरीत करने की क्षमता प्रदान करेगा जिसमें जावा के भीतर से पायथन शुरू किया जा सकता है। यह एक परत दृष्टिकोण के माध्यम से करता है। एक पायथन परत है जिसमें सभी उच्च स्तरीय कक्षाएं होती हैं जो फ्रंट एंड के रूप में काम करती हैं, एक सीपीथॉन निजी मॉड्यूल जिसमें प्रवेश बिंदु होते हैं, एक सी ++ बैकर परत जो सभी प्रकार के रूपांतरणों और मिलान के साथ-साथ मूल मॉड्यूल के रूप में कार्य करती है। जावा पुस्तकालय के लिए, और एक जावा पुस्तकालय जो सभी उपयोगिता कार्यों (वस्तुओं के जीवनकाल धारण करना, स्लाइस और अपवादों के लिए बैकिंग क्लास बनाना, और जावाडोक निकालने वाले/प्रतिपादन)।

8 साल पहले JPype थोड़ा गड़बड़ था। यह रूबी और पायथन दोनों का समर्थन करने की कोशिश कर रहा था, इसलिए सी ++ परत काम करने के लिए रैपरों की एक उलझन थी और सामने का अंत पायथन में था इसलिए यह बहुत धीमा था। इसे रिटर्न प्रकारों पर भी विभाजित किया गया था क्योंकि सुन्न समर्थन को संकलित किया जा सकता था जिसके परिणामस्वरूप एक अलग ऑब्जेक्ट वापस किया जा सकता था। प्रॉक्सी के रूप में कार्य करने के लिए जेएक्सप्शन जैसे कई एडेप्टर वर्गों की आवश्यकता होती है जहां देशी पायथन और जावा ऑब्जेक्ट भिन्न होते हैं। लेकिन उन सभी मुद्दों को प्रोजेक्ट में शामिल होने के बाद से 3 वर्षों में हल किया गया है। JPype में दो प्राथमिक लक्ष्य (मेरे लिए) सिंटैक्स प्रदान करना है जो भौतिकविदों के लिए काफी सरल है जो जावा का उपयोग करने में सक्षम होने और वैज्ञानिक पायथन कोड के साथ उच्च स्तर के एकीकरण के लिए प्रोग्रामिंग से परिचित होंगे। हम ऐसा उन वस्तुओं को बनाकर करते हैं जो जावा द्वारा समर्थित हैं और "सभी तामझाम" CPython ऑब्जेक्ट रैपर हैं। जावा आदिम सरणी को परिवर्तित करने के बजाय, हम एक जावा आदिम सरणी को एक नया देशी पायथन प्रकार बनाते हैं जो सभी समान प्रविष्टि बिंदुओं को numpy के रूप में लागू करता है और ये सभी मेमोरी बफर ट्रांसफर द्वारा समर्थित हैं। इस प्रकार हमारे पास list(jarray) या np.array(jarray) कॉल करके तेजी से रूपांतरण होते हैं।

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

दृष्टिकोण में मुख्य अंतर जो मैं देख सकता हूं वह यह है कि पायजनियस जाने और जाने वाले सरणी को परिवर्तित करता है। यह वैज्ञानिक कोडिंग के लिए बहुत निषेधात्मक प्रतीत होता है, जहां बड़े सरणियों को आगे पीछे करना (अक्सर जो कभी परिवर्तित नहीं होता है) पसंदीदा JPype शैली है। रूपांतरण की आवश्यकता का निर्णय तब मूल्य से गुजरने और संदर्भ से गुजरने जैसे विकल्पों को मजबूर करता है, लेकिन यह संभावित रूप से अधिक मुद्दों की ओर जाता है जैसे कि आपके पास एक बहु तर्क कॉल है, आप सभी तर्कों के लिए एक नीति चुन रहे हैं। यह बहुआयामी सरणियों से निपटना भी कठिन बना देगा। (मुझे लगता है कि obj.method(1, jnius.byref(list1), list2) जैसे उपयोग किए जाने वाले एडाप्टर क्लास ने इसे हासिल किया जा सकता है तो बेहतर नियंत्रण प्रदान किया होगा)। इसके अलावा, JPype ने कई समस्याओं को हल किया है जैसे GC लिंकेज, कॉलर सेंसिटिव मेथड्स, और इसी तरह। यदि और कुछ नहीं तो कृपया जेपी टाइप कोड देखें और देखें कि क्या कोई अच्छा विचार है जिसका आप उपयोग कर सकते हैं।

@Thrameos एक हालिया चीज़ जिसे हम मर्ज करना https://github.com/kivy/pyjnius/pull/515 ; मैंने इसे जेपी टाइप में नहीं देखा?

जेपी टाइप को 1.0.0 से शुरू होने वाले कार्यात्मक इंटरफेस से लैम्ब्डा के लिए समर्थन है। यह 30 दिनों में मार्च पुश 1.0 में 30 पुल का हिस्सा था।

JPype की ऊष्मायन अवधि लंबी है। मूल रूप से २००४ में शुरू हुआ और २००७ तक चला। इसके बाद इसे एक बड़ा बढ़ावा मिला क्योंकि उपयोगकर्ताओं के समूह ने इसे २०१५ के आसपास इसे पायथन ३ में पोर्ट करने के लिए पुनर्जीवित किया। फिर २०१७ में, इसे एक राष्ट्रीय प्रयोगशाला में उपयोग के लिए उठाया गया, जिसने इसे ०.६ से ले लिया। 3 से 0.7.2। उस अवधि के दौरान सभी प्रयास मुख्य प्रौद्योगिकी को सुधारने और सख्त करने पर केंद्रित थे जो इंटरफ़ेस प्रदान करता है। लेकिन यह अंततः मार्च में दूसरे कोर रीराइट के बाद पूरा हुआ ताकि हम अंत में 1.0.0 के लिए धक्का दे सकें। तब से हम अपने "30 पुल इन 30 नाइट्स" विश लिस्ट अभियान के दौरान वह सब कुछ जोड़ रहे हैं जो "गायब" था। सब कुछ का बैकलॉग जिसे मैं अभी लागू नहीं कर सका क्योंकि यह बहुत अधिक काम होगा अंत में मंजूरी दे दी गई थी (मुद्दे 50 से 20 तक गिर गए, उपयोगकर्ताओं से पूछें कि उन्हें क्या चाहिए, आदि)। तो ऐसी कई सुविधाएँ हो सकती हैं जो आपको पिछले संस्करणों में नहीं मिलीं जो अब उपलब्ध हैं। मैं एक हफ्ते से भी कम समय में अधिकांश फीचर अनुरोधों को बदल रहा हूं, जैसे कि मेरे पास जो कुछ बचा है वह बड़े 3 (रिवर्स ब्रिज, पायथन में कक्षाओं का विस्तार, दूसरा जेवीएम शुरू करने की क्षमता) है।

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

विस्तृत स्पष्टीकरण के लिए बहुत बहुत धन्यवाद, और वास्तव में, यदि कुछ भी, निश्चित रूप से ऐसे विचार हैं जिनका हम उपयोग कर सकते हैं, और यह कोड का अध्ययन करने के लायक होगा, पहले कोड को देखकर, जो मैंने देखा वह कोड गुणवत्ता और संरचना दोनों में काफी साफ लगता है परियोजना, इसलिए सभी कार्यों के लिए बधाई। आप Py4J के साथ मेरे मिश्रण के बारे में सही हैं, मुझे लगता है कि जब मैंने JPype को देखा, तो यह आपके द्वारा वर्णित गंदी स्थिति में रहा होगा, और इसका उपयोग करना इस बिंदु पर PyJNIus की तुलना में अधिक जटिल रहा होगा।

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

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

जेपी टाइप पायथन में इंटरफेस लागू कर सकता है। साधारण पायथन कक्षाओं में बस डेकोरेटर जोड़ें।

from java.util.function import Consumer

@jpype.JImplements(Consumer)
class MyConsumer:
   @jpype.JOverride
   def apply(self, obj):
       pass

@JImplements में एक स्ट्रिंग का उपयोग करें यदि JVM शुरू होने से पहले वर्ग को परिभाषित किया गया है, तो कई इंटरफेस को एक साथ लागू किया जा सकता है, लेकिन यह देखने के लिए कि क्या वे लागू किए गए हैं, सभी विधियों की जाँच की जाती है। मुख्य अंतर यह है कि जेपी टाइप प्रेषण विधियों का उपयोग करता है (सभी अधिभार एक ही विधि पर जाते हैं) बल्कि अतिभारित विधियों का उपयोग करते हैं। ऐसा इसलिए है क्योंकि हम जावा और पायथन दोनों से विधियों को कॉल करने में सक्षम होना पसंद करते हैं। मैं व्यक्तिगत अधिभार जोड़ सकता हूं यदि यह एक वांछित विशेषता है, लेकिन किसी ने इसका अनुरोध नहीं किया है।

(संपादित करें: इसका कारण यह है कि हमने पायथन इनहेरिटेंस का उपयोग नहीं किया था, जिस समय इसे जोड़ा गया था, हम अभी भी पायथन 2 का समर्थन कर रहे थे, जिसके कारण बहुत सारे मेटा क्लास के मुद्दे थे, क्लास एक्सटेंशन होने के बाद हम इसे और साफ कर देंगे। तो एनोटेशन जो घोषणा के समय एक बार मूल्यांकन क्लीनर थे।)

हम कक्षाओं के लिए कस्टमाइज़र (डंडर?) लागू करने के लिए उसी प्रणाली का उपयोग करते हैं

@jpype.JImplementationFor("java.util.ArrayList")
class ArrayListImpl:
    def __getitem__(self, i):
        return self.get(i)
    @jpype.JOverride
    def addAll(self, list):
        # Decide if we need to convert or can call directly.
        ...

हम निहित कन्वर्टर्स को परिभाषित करने के लिए एनोटेशन का भी उपयोग करते हैं जैसे "सभी पायथन पथ ऑब्जेक्ट्स java.io.File में कनवर्ट करते हैं"

 @jpype.JConversion("java.io.File", instanceof=pathlib.PurePath)
 def _JFileConvert(jcls, obj):
       Paths = jpype.JClass("java.nio.file.Paths")
       return Paths.get(str(obj))

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

हम चीजों को साफ करने के लिए कुछ सिंटैक्स चीनी भी प्रदान करते हैं MyJavaClass@obj => MyJavaClass (जावा समकक्ष (MyJavaClass)obj ) या cls=JInt[:] => एक सरणी प्रकार बनाएं ( cls=int[].class ) या a=JDouble[10][5] => एक बहुआयामी सरणी बनाएं ( double[][] a = new double[10][5] )।

मैं जेपी टाइप से कक्षाओं के विस्तार के लिए प्रोटोटाइप पर काम कर रहा हूं। हमें वही समस्या है जो कुछ स्विंग कक्षाओं और अन्य एपीआई को विस्तारित कक्षाओं की आवश्यकता होती है। जिस समाधान को मैंने अब तक पकाया है, वह प्रत्येक ओवरराइड विधियों के लिए हैश मैप के साथ एक विस्तारित कक्षा बनाने के लिए है। यदि उस प्रवेश बिंदु के लिए हैशपैप में कुछ भी नहीं है तो इसे सुपर में भेज दें, अन्यथा यह प्रॉक्सी विधि हैंडलर को कॉल करता है। लेकिन मैं तय करता हूं कि रिवर्स ब्रिज पूरा होने के बाद इसे लागू करना सबसे आसान होगा ताकि जावा वास्तव में जावा प्रॉक्सी विधि से गुजरने के बजाय पायथन विधियों को संभाल सके। इसलिए मेरे पास प्रोटोटाइप काम करने से पहले अभी भी लगभग 6 महीने का समय है। आप यह देखने के लिए epypj शाखा (रिवर्स ब्रिज के लिए मेरा नाम) देख सकते हैं कि जावा से वापस पायथन पर कॉल करने के साथ-साथ मक्खी पर जावा कक्षाएं बनाने के लिए ASM का उपयोग करके एक इनवोकर उत्पन्न करने के लिए पैटर्न कैसे काम करता है।

कचरा संग्रहण के प्रबंधन के लिए, जेपी टाइप के कुछ टुकड़े हैं जो यह काम करते हैं। सबसे पहले JPypeReferenceQueue (देशी/जावा/org/jpype/ref/JPypeReferenceQueue) है जो एक जावा ऑब्जेक्ट के लिए एक पायथन ऑब्जेक्ट के जीवन को बांधता है। इसका उपयोग बफर और अन्य चीजें बनाने के लिए किया जाता है जहां जावा को एक अवधि के लिए पायथन अवधारणा तक पहुंचने की आवश्यकता होती है। दूसरा वैश्विक संदर्भों का उपयोग करना है ताकि पायथन जावा ऑब्जेक्ट को दायरे में रख सके। इसके लिए कचरा संग्रहकर्ता लिंक (देशी/आम/jp_gc.cpp) की आवश्यकता होती है जो किसी भी सिस्टम को GC ट्रिगर करने के लिए सुनता है और कुछ शर्तों (पूल का आकार, सापेक्ष वृद्धि) होने पर इसे दूसरे पर पिंग करता है। अंतिम प्रॉक्सी को कमजोर संदर्भों का उपयोग करने की आवश्यकता होती है क्योंकि वे अन्यथा लूप बनाते हैं (क्योंकि प्रॉक्सी जावा आधा का संदर्भ रखता है और जावा आधा अंक पायथन कार्यान्वयन पर वापस आता है)। आखिरकार मैं एक एजेंट का उपयोग करने का इरादा रखता हूं ताकि पायथन को जावा को पार करने की अनुमति मिल सके लेकिन वह सड़क से नीचे है।

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

पायजनियस में एक अनूठी विशेषता यह है कि कॉलर यह तय कर सकता है कि संरक्षित और निजी विधियों और क्षेत्रों को शामिल करना है या नहीं। मेरी प्राथमिकता केवल जनता के लिए है, लेकिन मैं इस तर्क को समझता हूं कि गैर-सार्वजनिक क्षेत्रों और विधियों को उपलब्ध कराना उपयोगी है।

मेरी परियोजना के लिए प्रदर्शन महत्वपूर्ण है। मैंने निम्न वर्ग के साथ कुछ परीक्षण किए:

package org.pkg;

public class MyClass {

  public MyClass() {
  }

  public int number = 42;

  public float add1(float x, float y) {
    return x + y;
  }

  public float add2(float x, float y) {
    return x + y;
  }

  public float add2(int x, int y) {
    return x + y;
  }
}

जेपी टाइप में:

In [1]: import jpype
   ...: import jpype.imports
   ...: jpype.startJVM()
   ...: from org.pkg import MyClass
   ...: myInstance = MyClass()
   ...:

In [2]: %timeit myInstance.number
640 ns ± 2.65 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [3]: %timeit myInstance.add1(10.3, 20.5)
2.13 µs ± 24.8 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [4]: %timeit myInstance.add2(10.3, 20.5)
2.19 µs ± 9.41 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

पायजनियस में:

In [1]: import jnius

In [2]: MyClass = jnius.autoclass('org.pkg.MyClass')

In [3]: myInstance = MyClass()

In [4]: %timeit myInstance.number
161 ns ± 0.104 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [5]: %timeit myInstance.add1(10.3, 20.5)
1.04 µs ± 8.16 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [6]: %timeit myInstance.add2(10.3, 20.5)
2.71 µs ± 11.2 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

अतिभारित विधि को छोड़कर, पायजनियस काफी तेज है। हमें नोट्स की तुलना इस बात पर करनी चाहिए कि यह कैसे तय किया जाए कि विधि के अतिभारित होने पर किस विधि को कॉल किया जाए। पायजनियस में यह स्कोरिंग तंत्र है जो बहुत अधिक ओवरहेड जोड़ता है। JPype उस निर्णय को बहुत तेजी से करता है।

अंत में, बेंचमार्क उद्देश्यों के लिए:

In [9]: def add(x, y):
   ...:     return x + y
   ...:

In [10]: %timeit add(10.3, 20.5)
82.9 ns ± 0.187 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

बेशक, कुछ µ के अंतर मामूली हैं, लेकिन अगर कोई बहुत जल्दी हजारों छोटी कॉल कर रहा है, तो यह जुड़ जाता है, जो मुझे करने की आवश्यकता है।

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

जेपी टाइप गति दुर्भाग्य से एक है-क्या-यह-संभावना है। जेपी टाइप बुरी चीजों से बचाव के लिए बहुत रक्षात्मक है जिसका अर्थ है कि बहुत सारे गैर-तुच्छ ओवरहेड हैं। इसका मतलब है कि उदाहरण के लिए जब भी कोई जावा कॉल किया जाता है तो यह सुनिश्चित करता है कि थ्रेड जुड़ा हुआ है, इसलिए यदि बाहरी थ्रेड जैसे आईडीई से कॉल किया जाता है तो हम segfault नहीं करते हैं। मेरे स्थानीय उपयोगकर्ता समूह सभी वैज्ञानिक हैं इसलिए प्रवेश बिंदु कुछ बहुत ही भयानक क्रॉस वायरिंग के खिलाफ बहुत सुरक्षित हैं। अगर कभी कुछ उन पर segfaults (चाहे वह कितना भी पागल हो), तो मैं असफल रहा। (जो जानबूझकर खराब वस्तुओं के निर्माण सहित 1500 परीक्षणों की व्याख्या करेगा।)

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

आपके गति उदाहरण के लिए, आप एक int फ़ील्ड का अनुरोध कर रहे हैं।

• PyJnius में यह ऑब्जेक्ट लुकअप के लिए एक डिस्क्रिप्टर बनाता है, फ़ील्ड तक पहुँचता है, एक नया पायथन लॉन्ग बनाता है और फिर उसे वापस करता है।
• जेपी टाइप में, यह ऑब्जेक्ट लुकअप के लिए एक डिस्क्रिप्टर बनाता है, फ़ील्ड तक पहुंचता है, एक नया पायथन लंबा बनाता है, फिर जावा इंट के लिए एक रैपर प्रकार बनाता है, पाइथन लंबी मेमोरी को जेआईएनटी में कॉपी करता है (क्योंकि पाइथन में व्युत्पन्न बनाने का कोई तरीका नहीं है पूर्णांक वर्ग सीधे), फिर जावा मान के साथ स्लॉट को बांधता है, और अंत में परिणामी JInt देता है।

तो यहां तक ​​​​कि किसी क्षेत्र तक पहुंचने पर स्पीड बेंचमार्किंग करने के रूप में तुच्छ कुछ भी वास्तव में इतना छोटा नहीं है।
अंतर यह है कि एक ने एक पायथन लंबा लौटाया और दूसरा एक वास्तविक जावा पूर्णांक (जो जावा रूपांतरण नियमों का पालन करता है) लौटाता है जिसे किसी अन्य अतिभारित विधि में पारित किया जा सकता है और ठीक से बांध सकता है। एक रैपर प्रकार को वापस करने का काम केवल एक पायथन प्रकार को वापस करने से कहीं अधिक है, इसलिए गति में एक बड़ा अंतर है।

मैंने कुछ भिन्न फ़ील्ड प्रकारों का परीक्षण करके इसे प्रदर्शित करने का प्रयास किया। दुर्भाग्य से, जब मैंने ऑब्जेक्ट फ़ील्ड का परीक्षण किया, तो जेनियस ने "हार्नेस.ऑब्जेक्टफिल्ड = हार्नेस" कोड पर segfaulted किया। मुझे यकीन नहीं है कि क्रॉस वायरिंग के उस विशेष टुकड़े ने एक समस्या क्यों पैदा की, लेकिन यह मेरे लिए असफल रहा। मुझे सकल अपराधियों को हटाने से परे जेपी टाइप के लिए गति में ज्यादा दिलचस्पी नहीं है, जिसने कॉलिंग के लिए 3-5 स्पीड अप और कुछ सरणी एक्सेस के लिए 300 गुना का कारक दिया। लेकिन शायद मुझे समीक्षा करनी चाहिए और देखना चाहिए कि किन क्षेत्रों में सुधार किया जा सकता है। हालांकि मुझे संदेह है कि मैं सुरक्षा को हटाए बिना या वापसी अनुबंध (जो मैं नहीं कर सकता) को हटाए बिना इसे PyJnius जैसी नंगी हड्डियों तक कम कर सकता हूं। अधिकतम 10-30% गति अभी भी संभव है,

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

मैंने सरणी सूची का उपयोग करके कुछ परीक्षण चलाए।

import jpype
import timeit
jpype.startJVM()
ArrayList = jpype.JClass("java.util.ArrayList")

def pack():
    ja = ArrayList()
    for i in range(1000):
        ja.add(i)

def iter(ja):
    u = 0
    for i in ja:
        u+=i

def access(ja):
    u = 0
    for i in range(len(ja)):
        u+=ja.get(i)

def access2(ja):
    u = 0
    for i in range(len(ja)):
        u+=ja[i]


ja = ArrayList()
for i in range(1000):
   ja.add(i)

print("Pack arraylist %e"%( timeit.timeit("pack()", globals=globals(), number=1000)/1e6))
print("Iterate arraylist %e"%(timeit.timeit("iter(ja)", globals=globals(), number=1000)/1e6))
# Get is a direct call
print("Access(get) arraylist %e"%(timeit.timeit("access(ja)", globals=globals(), number=1000)/1e6))
# [] is emulated
print("Access([]) arraylist %e"%(timeit.timeit("access2(ja)", globals=globals(), number=1000)/1e6))

जेपी टाइप

पैक ऐरेलिस्ट 2.768904e-06
पुनरावृति सरणीसूची 5.208071e-06
एक्सेस (प्राप्त करें) सरणीसूची 4.037985e-06
एक्सेस ([]) सरणी सूची 4.690264e-06

जीनियस

पैक सरणीसूची 3.322248e-06
पुनरावृति सरणीसूची 4.099314e-06
एक्सेस (प्राप्त करें) सरणी सूची 5.653444e-06
एक्सेस ([]) सरणीसूची 7.762727e-06

यह कहने के अलावा एक बहुत ही सुसंगत कहानी नहीं है कि वे शायद बहुत अलग कार्यक्षमता प्रदान कर रहे हैं, सिवाय इसके कि वे बहुत अलग हैं। यदि आप जो कुछ कर रहे हैं, वह एक्सेस करने के तरीके हैं, तो वे काफी हद तक समान हैं। पासिंग सरणियाँ जो पूर्व-रूपांतरित हैं JPype 100 गुना तेज है, कन्वर्ट सूचियाँ और tuples JPype 2 गुना धीमा है (हम वेक्टर एक्सेस का उपयोग नहीं करते हैं या वर्तमान में टुपल्स के लिए विशेष बाईपास हैं)। तो लब्बोलुआब यह है कि आपकी कोडिंग शैली के आधार पर यह एक या दूसरे के साथ बहुत तेज़ हो सकता है। लेकिन फिर मेरे उपयोगकर्ता आमतौर पर गति के बजाय उपयोग में आसानी और बुलेट प्रूफ निर्माण के लिए जेपी टाइप का चयन करते हैं। (आह, मैं किससे मजाक कर रहा हूं! वे इंटरनेट से दूर होने की संभावना के समान ही ठोकर खा रहे हैं क्योंकि JPype Google पर पाया गया पहला लिंक था।)

जेपी टाइप कैसे बाध्यकारी विधि करता है, यह विवरण डेवलपर/उपयोगकर्ता मार्गदर्शिका में होना चाहिए। विधि बाध्यकारी जावा स्पेक में दिए गए नियमों के अनुसार प्रेषण के लिए विधियों की सूची को निर्धारित करके शुरू होती है ताकि अगर कुछ और कुछ छुपाता है तो यह सूची में सबसे पहले दिखाई देता है (कोड देशी/जावा/ओआरजी/जेपीईपी में पाया जा सकता है जैसा कि हम जब पहली बार प्रेषण बनाया जाता है तो छँटाई करने के लिए जावा उपयोगिता वर्ग का उपयोग करें)। इसके अलावा प्रत्येक विधि को वरीयता सूची दी जाती है कि कौन सी विधि दूसरे को छुपाती है। यह देखने के लिए कि क्या तर्क के लिए "जावा स्लॉट" है या नहीं, पहले प्रत्येक तर्क की जाँच करके संकल्प शुरू होता है। जावा स्लॉट मौजूदा वस्तुओं की ओर इशारा करते हैं जिन्हें किसी रूपांतरण की आवश्यकता नहीं है, इसलिए मैच से पहले इन्हें रास्ते से हटाने का मतलब है कि हम निहित नियमों के बजाय प्रत्यक्ष नियमों का उपयोग कर सकते हैं। यह तब 4 स्तरों (सटीक, निहित, स्पष्ट, कोई नहीं) के प्रकारों के आधार पर तर्क से मेल खाता है। यह स्पष्ट पर कम कटौती करता है और अगली विधि पर कूदने के लिए कोई नहीं। यदि यह कभी सटीक हो जाता है तो यह कॉल पर कूदने के लिए पूरी प्रक्रिया को छोटा कर देता है। यदि कोई मेल है तो यह उन विधियों को छुपाएगा जिनमें कम विशिष्ट बाध्यकारी हैं। यदि दो निहित मिलान पाए जाते हैं जो छिपे नहीं थे तो यह एक TypeError के लिए आगे बढ़ता है। एक बार जब सभी मैच समाप्त हो जाते हैं तो रूपांतरण दिनचर्या निष्पादित हो जाती है। यह तब पायथन ग्लोबल लॉक को मुक्त करता है और कॉल करता है और ग्लोबल लॉक को पुनः प्राप्त करता है। रिटर्न प्रकार को देखा जाता है और लौटाए गए प्रकार के आधार पर एक नया पायथन रैपर बनाया जाता है (यह कॉन्वेंट रिटर्न का उपयोग करता है इसलिए लौटाया गया प्रकार विधि से प्रकार के बजाय सबसे अधिक व्युत्पन्न होता है)। यह ज्यादातर ओवरलोड की संख्या के साथ रैखिक है, हालांकि विविध तर्कों के लिए कुछ जटिलताएं हैं, लेकिन पूर्व-निर्मित तालिकाओं का मतलब है कि यह फू (डबल, डबल) की कोशिश करने से पहले फू (लंबी, लंबी) की कोशिश करेगा और एक हिट (लंबा) , लंबा) जावा विधि समाधान नियमों के कारण मिलान होने वाले प्रत्येक से डबल, डबल को रोक देगा। अभी भी कुछ गति अप हैं जिन्हें मैं कार्यान्वित कर सकता हूं लेकिन इसके लिए अतिरिक्त कैशिंग टेबल की आवश्यकता होगी।

जब मैंने 2017 में प्रोजेक्ट शुरू किया तो मुझे शॉर्ट कट के साथ ऑर्डरिंग सिस्टम विरासत में मिला। मैंने अपने अधिकांश ओवरहेड को बाहर निकालने के लिए कैश और जावा स्लॉट को छिपाने की विधि को जोड़ा।

मैंने विधियों के लिए निष्पादन पथ को अनुकूलित किया। जेपी टाइप के लिए संशोधित संख्याएं हैं

पैक सरणीसूची 2.226081e-06
पुनरावृति सरणीसूची 4.082152e-06
एक्सेस (प्राप्त) सरणी सूची 2.962606e-06
एक्सेस ([]) सरणीसूची 3.644642e-06

मेरे स्थानीय उपयोगकर्ता समूह सभी वैज्ञानिक हैं इसलिए प्रवेश बिंदु कुछ बहुत ही भयानक क्रॉस वायरिंग के खिलाफ बहुत सुरक्षित हैं। अगर कभी कुछ उन पर segfaults (चाहे वह कितना भी पागल हो), तो मैं असफल रहा।

हाँ, segfaults भयानक हैं और जब मैंने pyjnius का उपयोग करना शुरू किया तो मुझे उनमें से सैकड़ों मिल गए। मुझे लंबे समय से कोई नहीं मिला है, हालांकि शायद मैंने सुरक्षा मुद्दों पर काम किया और इसे अपने कोड में बनाया। अब सब कुछ मज़बूती से काम करता है। हालांकि मैं आपके उपयोग के मामले को समझता हूं। यदि आपके उपयोगकर्ता विभिन्न जावा पुस्तकालयों के साथ डेटा विश्लेषण करने के लिए सीधे जावा ऑब्जेक्ट्स के साथ काम कर रहे वैज्ञानिक हैं, तो एक सेगफॉल्ट उन्हें अपना सारा काम खो देगा। JPype वैज्ञानिक कार्य करने के लिए बेहतर डिज़ाइन किया गया लगता है जहाँ अंतिम उपयोगकर्ता सीधे Python के माध्यम से Java ऑब्जेक्ट्स के साथ काम कर रहे हैं। हालांकि, पायजनियस के लिए मुख्य उपयोग का मामला अलग है, जो एंड्रॉइड के साथ संचार कर रहा है। उस स्थिति में, सुरक्षा मुद्दे डेवलपर की समस्या हैं, इसलिए शायद सुरक्षा बनाम गति के बारे में अलग-अलग विकल्प बनाना उचित है।

मैं मानता हूं कि मैं "जब तक आप इस क्रम में इन चौकों पर कदम रखते हैं, तब तक यह सुरक्षित है" का बहुत बड़ा प्रशंसक नहीं हूं। जब मैंने JPype पर काम करना शुरू किया तो मुझे सभी प्रवेश बिंदुओं को बुलेट प्रूफ करने में लगभग एक साल का समय लगा ताकि मैं अपने स्थानीय समूह को कोड पास कर सकूं। और मैंने तब से दो अतिरिक्त वर्षों का API कवच जोड़ा है। कुछ दुर्लभ लोगों के अलावा जिनका JVM लोड करने में विफल रहता है (जिसे हल करना बहुत कठिन है) कुछ शेष मुद्दे हैं क्योंकि JPype को उत्पादन कोड मानकों तक लाया गया है।

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

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

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

पहला कदम, इस प्रकार, वितरण में jpype को संकलित करना है, जो कि p4a (https://github.com/kivy/python-for-android/) द्वारा किया जाता है जब आप इसे बताते हैं कि यह आपकी आवश्यकताओं का हिस्सा है, आमतौर पर ( लेकिन हमेशा नहीं) p4a को समझाने के लिए एक "नुस्खा" की आवश्यकता है कि पुस्तकालयों का निर्माण कैसे करें जो शुद्ध अजगर नहीं हैं, pyjnius के लिए एक यहां पाया जा सकता है https://github.com/kivy/python-for-android/blob/ एक उदाहरण के रूप में p4a.local_recipes सेटिंग का उपयोग buildozer.spec में एक निर्देशिका घोषित करने के लिए कर सकते हैं जिसमें आवश्यकताओं के लिए व्यंजनों को पाया जा सकता है, इसलिए आपको एंड्रॉइड के लिए पायथन-फॉर-फोर्क करने की आवश्यकता नहीं है अपने नुस्खा का इस्तेमाल किया है।

मैं बिल्डोजर का उपयोग करने की सलाह दूंगा, क्योंकि यह अधिक चीजों को स्वचालित करता है https://buildozer.readthedocs.io/en/latest/installation.html#targeting -android और आप चीजों को आजमाने के लिए अपने स्थानीय व्यंजनों को अभी भी सेट कर सकते हैं। पहले निर्माण में समय लगेगा, क्योंकि इसमें अजगर और हाथ के लिए कई निर्भरताएं बनाने की जरूरत है, और इसके लिए एंड्रॉइड एनडीके और एसडीके डाउनलोड करना होगा। आप शायद ऐप के लिए डिफ़ॉल्ट किवी बूटस्ट्रैप का उपयोग कर सकते हैं, और ऐप की तरह "हैलो वर्ल्ड" बना सकते हैं, जो कि jpype आयात करेगा और केवल लेबल में कुछ कोड का परिणाम प्रदर्शित करेगा, या प्रिंट का उपयोग करके लॉगकैट में भी, मैं नहीं करता याद रखें कि एंड्रॉइड एमुलेटर में किवी कितनी अच्छी तरह चलता है, मैंने कभी इसका इस्तेमाल नहीं किया, लेकिन मुझे लगता है कि कुछ उपयोगकर्ताओं ने किया, और त्वरण सेटअप के साथ इसे काम करना चाहिए, afaik, अन्यथा आप एसडीएल 2 रैपर, या वेबव्यू एक का उपयोग कर सकते हैं, और फ्लास्क का उपयोग कर सकते हैं या बोतल सर्वर चीजों को प्रदर्शित करने के लिए, मैं पहले किवी के साथ प्रयास करूंगा क्योंकि यह अब तक का सबसे अधिक परीक्षण किया गया है।

Android के निर्माण के लिए आपको एक linux या osx मशीन (VM ठीक है, और विंडोज़ 10 पर WSL ठीक है) की आवश्यकता होगी।

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

@inclement मैंने jpype-project/jpype#799 पर एंड्रॉइड पोर्ट के लिए एक पीआर स्थापित किया है। दुर्भाग्य से, मुझे सच में यकीन नहीं है कि यहाँ से कहाँ जाना है। ऐसा लगता है कि यह धीरे-धीरे चलाने की कोशिश कर रहा है जो वास्तव में सही निर्माण पथ नहीं है।

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

• [x] बिल्ड में सभी jpype/*.py फ़ाइलें शामिल करें (या उनके पूर्व संकलित संस्करण)।
• [x] Apache ant को Native/build.xml पर चलाएँ और परिणामी जार फ़ाइल को किसी ऐसी जगह पर रखें जहाँ इसे पहुँचा जा सके।
• [x] जार फ़ाइल (या समकक्ष) को बिल्ड में शामिल करें।
• [x] बिल्ड में शामिल करने के लिए _jpype नामक मॉड्यूल में देशी/सामान्य और देशी/पायथन से C++ कोड संकलित करें।
• [x] एक main.py फ़ाइल शामिल करें जो अभी एक इंटरेक्टिव शेल लॉन्च करती है ताकि हम इसे अभी के लिए मैन्युअल रूप से परीक्षण कर सकें।
• [] भविष्य में मुझे "एएसएम" या ऐसा कुछ शामिल करना होगा जो एंड्रॉइड के लिए काम करता है ताकि मैं गतिशील रूप से बनाई गई कक्षाओं को लोड कर सकूं।
• [x] C++ कोड को पैच करें ताकि यह JVM और कंपेनियन जार फ़ाइल को लोड करने के लिए एक कस्टम बूटस्ट्रैप का उपयोग करे और सभी मूल विधियों को हुक अप करे।
• [ ] jvmfinder को किसी ऐसी चीज़ से पैच करें जो android पर काम करती हो और "startJVM" को main की शुरुआत के बजाय स्वचालित रूप से कॉल किया जाता है।
• [] पैच org.jpype ताकि जार नेविगेशन सिस्टम (जो कि आयात कैसे काम करता है) एंड्रॉइड पर कार्य कर सकता है।

मैंने कुछ दस्तावेज़ों को देखा लेकिन वास्तव में कुछ भी नहीं खड़ा हुआ कि इसे कैसे पूरा किया जाए। मेरा प्रोजेक्ट लेआउट सामान्य से कुछ अलग है क्योंकि हम सब कुछ मुख्य मॉड्यूल के तहत नहीं रखते हैं (क्योंकि हम वास्तव में 3 मॉड्यूल का निर्माण कर रहे हैं जो सिस्टम बनाते हैं। jpype, _jpype, और org.jpype।) मुझे संभवतः एक कस्टम नुस्खा की आवश्यकता है इन सभी क्रियाओं को करने के साथ-साथ अवांछनीय पैटर्न को अक्षम करें जैसे कि रनिंग ग्रेडल (जब तक कि यह कुछ उपयोगी नहीं कर रहा है जो मैं नहीं बता सकता।)

ऐसा लगता है कि यह धीरे-धीरे चलाने की कोशिश कर रहा है जो वास्तव में सही निर्माण पथ नहीं है।

ग्रैडल एक एपीके पैकेजिंग के अंतिम चरण के रूप में उपयोग किया जाने वाला बिल्ड टूल है, यह शायद आपके jpype को शामिल करने से संबंधित नहीं है।

बिल्ड में सभी jpype/*.py फ़ाइलें शामिल करें (या उनके पूर्व संकलित संस्करण)।

सामान्य तौर पर, यदि jpype अनिवार्य रूप से एक सामान्य पायथन मॉड्यूल के रूप में प्रदर्शन करता है, तो आपका पहला नुस्खा प्रयास संभवतः अधिकांश भारी भारोत्तोलन करता है - CppCompiledComponentsPythonRecipe python setup.py build_ext और python setup.py install चलाने जैसा कुछ करता है एनडीके पर्यावरण का उपयोग करना। इसे ऐप के अंदर शामिल करने के लिए बनाए जा रहे पायथन पर्यावरण के भीतर jpype पायथन पैकेज स्थापित करना चाहिए।

बिल्ड में जार फ़ाइल (या समकक्ष) शामिल करें।

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

बिल्ड में शामिल करने के लिए _jpype नामक मॉड्यूल में देशी/सामान्य और देशी/पायथन से सी ++ कोड संकलित करें।

यदि इसे setup.py द्वारा नियंत्रित किया जाता है, तो यह पहले से ही काम कर रहा होगा, लेकिन इसमें कुछ बदलाव की आवश्यकता हो सकती है। यदि ऐसा नहीं है, तो आप अपने संकलन आदेशों को नुस्खा में शामिल कर सकते हैं (और उन्हें उपयुक्त env vars सेट करके Android वातावरण के लिए बना सकते हैं, जैसा कि आप अन्य व्यंजनों में self.get_env का उपयोग करके देखेंगे)।

सी ++ कोड को पैच करें ताकि यह जेवीएम और साथी जार फ़ाइल लोड करने के लिए एक कस्टम बूटस्ट्रैप का उपयोग करे और सभी मूल विधियों को जोड़ सके।

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

jvmfinder को किसी ऐसी चीज़ से पैच करें जो एंड्रॉइड पर काम करती है और "स्टार्टजेवीएम" को मुख्य की शुरुआत के बजाय स्वचालित रूप से कॉल किया जाता है।

मैं वास्तव में जेवीएम से परिचित नहीं हूं, लेकिन मुझे लगता है कि एंड्रॉइड चाहता है कि आप हमेशा मौजूदा जेवीएम तक पहुंचें और आप एक नया उदाहरण शुरू नहीं कर सकते। क्या यह मायने रखेगा (या यह सिर्फ गलत है?)?

Apache ant को देशी/build.xml पर चलाएँ और परिणामी जार फ़ाइल को किसी ऐसी जगह पर रखें जहाँ इसे पहुँचा जा सके।

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

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

मुझे लगता है कि पहले मुझे यह पता लगाने की जरूरत है कि मैं एक क्लीन कमांड कैसे चला सकता हूं ताकि मुझे एक बार चलने और लॉग दिखाने की प्रक्रिया मिल सके। (जब मैं खेल रहा था तब मैंने पहली बार इसे पीस मील चलाया था। इसलिए मेरे पास एक साफ लॉग नहीं है।) साथ ही हमें इस बातचीत को पीआर में ले जाना चाहिए ताकि हम विषय पर अधिक विषय पर रह सकें।

एफडब्ल्यूआईडब्ल्यू मैं अपने गैर-एंड्रॉइड प्रोजेक्ट के मूल को जेपी टाइप में पोर्ट करने में सक्षम था। दो छोटी कठिनाइयाँ या मतभेद थे:

1. classpath kwarg jpype.startJVM() ऐसा लगता है कि मैं कुछ भी करूँ इससे कोई फर्क नहीं पड़ता। हालांकि addClassPath() फ़ंक्शन ने काम किया। डेवलपर जो क्लासपाथ ऑर्डर की परवाह करते हैं, उन्हें jnius_config.add_classpath() उपयोग करने के तरीके की तुलना में कुछ समायोजन करने की आवश्यकता हो सकती है।

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

लेखन @JOverride कार्यान्वित तरीकों के लिए जिस तरह से जैसे कोड से अधिक आसान है @java_method('(Ljava/lang/String;[Ljava/lang/Object;)V') ।

एक बार जब मैंने उन दो मुद्दों से निपटा, तो सब कुछ मूल रूप से ठीक काम करता था। मेरे पास बाइट एरे पास करने वाले कुछ कोड हैं जिन्हें बदलना होगा लेकिन जेपी टाइप के लिए इसका अच्छा समर्थन है। इसके अलावा, JPype के निहित प्रकार के रूपांतरण बहुत सुविधाजनक हैं और बहुत सारे डेकोरेटर्स को बदल सकते हैं जिन्हें मुझे हर जगह छिड़कना था।

@Thrameos मैं यहाँ आपके दृढ़ संकल्प का सम्मान करता हूँ। जेपी टाइप को एंड्रॉइड पर काम करने के लिए शुभकामनाएँ।

टिप्पणियों के लिए धन्यवाद।

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

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

यहां एक उदाहरण दिया गया है जहां मैं विकास क्षेत्र के सापेक्ष एक पीई निर्देशिका से अपनी परीक्षण प्रणाली शुरू कर रहा हूं।

import jpype
import os

devel = os.path.dirname(__file__)
devel = os.path.join(devel, '..', '..')
devel = os.path.abspath(devel)  # Notice that I converted the path to absolute so that it doesn't matter where the
# PWD of Java will be when this script is called.   Otherwise, if I import this from a different location it will use the
# original PWD and Java will find nothing in the classpath.

classpath = [
    '%s/gov.llnl.math/dist/*' % devel,
    '%s/gov.llnl.rdak/dist/*' % devel,
    '%s/gov.llnl.rnak/dist/*' % devel,
    '%s/gov.llnl.rtk/dist/*' % devel,
    '%s/gov.llnl.rtk.gadras/dist/*' % devel,
    '%s/gov.llnl.rtk.response/dist/*' % devel,
    '%s/gov.llnl.utility/dist/*' % devel,
    ]

jpype.startJVM(classpath=classpath, convertStrings=False)

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

मैं तार की एक सूची लौटने के साथ इस मुद्दे को देख सकता हूँ। यह ट्रिगर होने वाले व्यवहार के रूप में रिटर्न के प्रकार पर निर्भर करेगा। यदि विधि को String[] लौटने के रूप में घोषित किया गया था, तो मैं लौटने पर प्रत्येक पायथन स्ट्रिंग को जावा में मजबूर करने की अपेक्षा करता हूं। यदि विधि को List<String> लौटाने के रूप में घोषित किया गया था, तो एक समस्या होगी क्योंकि जावा जेनरिक इसे बंद कर देता है, इसलिए यह List<Object> । जेपी टाइप सूची को कैसे देखता है, इस पर निर्भर करता है कि यह कनवर्ट करने का प्रयास कर सकता है या नहीं, लेकिन इसे परिभाषित व्यवहार होना चाहिए, इसलिए मैं इसकी जांच करूंगा। सुरक्षित समाधान एक सूची समझ है जो वापसी के लिए सभी वस्तुओं को परिवर्तित करने में सक्षम होना चाहिए।

सुनिश्चित नहीं है कि क्लासपाथ में क्या गलत हो सकता है, हालांकि अगर मुझे लगता है कि यह वह जगह होगी जहां से आप पाइथन शुरू कर रहे थे। कभी-कभी लोग JVM को एक मॉड्यूल से शुरू करते हैं

मैं यही कर रहा था!

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

हां, मुझे लगा कि यह ऐसी चीज है जिस पर आप तुरंत ध्यान देंगे और यह कि मैं पहला व्यक्ति नहीं था जिसे यह समस्या हुई थी। कोड नमूना के लिए धन्यवाद, यह सहायक है। परिणामस्वरूप मैंने अपने कोड में कुछ सुधार किए हैं।

सुरक्षित समाधान एक सूची समझ है जो वापसी के लिए सभी वस्तुओं को परिवर्तित करने में सक्षम होना चाहिए।

मैंने ठीक यही किया और यह अब सही ढंग से काम करता है। धन्यवाद!

कुछ साल पहले मैंने py4j और jnius के बीच तुलना की थी और पाया कि jnius बहुत तेज है।

जब भी मैंने jpype को स्थानों पर उल्लेखित देखा, तो मैंने हमेशा यह मान लिया कि यह - http://jpype.sourceforge.net/ का जिक्र कर रहा था और इससे दूर रहा क्योंकि यह अनियंत्रित लग रहा था (नई परियोजना को अजीब तरह से नहीं देखा)

इस धागे को पढ़ने पर, मैंने फिर से अपने बेंचमार्क की कोशिश की (गति के लिए मेरा प्राथमिक टेस्टकेस पीएमएमएल फाइलों को पढ़ना और स्कोर करना है) - और पाया कि jpype बहुत अच्छा प्रदर्शन कर रहा था।
कुछ परिणाम:
https://gist.github.com/AbdealiJK/1dd5b7677435ba22f9ab3e26016bb3e7

# jpype
# createjvm: 0.550s
# loadmodel: tot=1.466451 max=1.064521s avg=0.014665s
# fields   : tot=0.019881 max=0.009795s avg=0.000199s
# score    : tot=0.033356 max=0.023338s avg=0.000334s

# jnius
# createjvm: 0.249s
# loadmodel: tot=1.773011 max=1.385274s avg=0.017730s
# fields   : tot=0.039058 max=0.012234s avg=0.000391s
# score    : tot=0.067590 max=0.031904s avg=0.000676s

# py4j
# createjvm: 0.222s
# loadmodel: tot=0.616913 max=0.027464s avg=0.006169s
# fields   : tot=0.699152 max=0.026426s avg=0.006992s
# score    : tot=0.389583 max=0.017620s avg=0.003896s

निष्पक्ष होने के लिए, मार्च 2020 तक JPype का फ्रंट एंड एपीआई पायथन (CPython के विपरीत) में लिखा गया था। इसलिए यह दिखाने के लिए बहुत सारे पुराने बेंचमार्क हैं कि यह जो प्रदान करता है उसके लिए यह धीमा था। बस इतने सारे बैकएंड मुद्दे थे जिन्हें स्मृति प्रबंधन के साथ हल किया जाना था, रूबी, मल्टीथ्रेडिंग और इसी तरह का समर्थन करने के लिए पूरे मल्टीलेयर रैपर को हटा दिया गया था, और उस गति पर काम करने की आखिरी चीज थी।

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

मुझे JPype के साथ भी अच्छे परिणाम मिल रहे हैं। विशेष रूप से, मुझे numpy arrays के साथ एकीकरण से अच्छा मूल्य मिल रहा है। मैं नई सुविधाओं को जोड़ने में सक्षम हूं जो मैं पहले नहीं कर सकता था जिससे मुझे सार्थक तरीकों से प्रदर्शन में सुधार करने में सक्षम बनाया गया है।

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

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

इच्छुक पार्टियों के लिए प्रगति अद्यतन।

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

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