def _check_connectivity( self ) : """ :return: """ if platform == 'android': try: Activity = autoclass( 'android.app.Activity' ) PythonActivity = autoclass( 'org.renpy.android.PythonActivity' ) activity = PythonActivity.mActivity ConnectivityManager = autoclass( 'android.net.ConnectivityManager') con_mgr = activity.getSystemService( Activity.CONNECTIVITY_SERVICE ) conn = con_mgr.getNetworkInfo( ConnectivityManager.TYPE_WIFI ).isConnectedOrConnecting() if conn : return True else: conn = con_mgr.getNetworkInfo( ConnectivityManager.TYPE_MOBILE ).isConnectedOrConnecting() if conn: return True else: return False except Exception as e : self._logger.error( 'check connectivity failed....' + e.message ) return False else : return True
def PCA(data_src="", number_of_componets=2): def createfolder(src): new_src = "./R" + src if os.path.exists(new_src): return else: os.makedirs(new_src) # generate new folders for each file def deleteComponents(data): for i in range(data.numAttributes() - 2, 0, -1): # delete attributes from the back, except of clasl label if i >= number_of_componets: data.deleteAttributeAt(i) return data data = loadWekaData(data_src) search = autoclass('weka.attributeSelection.Ranker')() evaluator = autoclass('weka.attributeSelection.PrincipalComponents')() evaluator.setOptions(['-R', '0.9', '-A', '1']) attsel = autoclass('weka.attributeSelection.AttributeSelection')() attsel.setSearch(search) attsel.setEvaluator(evaluator) attsel.SelectAttributes(data) reduced_data = attsel.reduceDimensionality(data) reduced_data = deleteComponents(reduced_data) createfolder(data_src[2:data_src.rfind("/")]) saver = autoclass('weka.core.converters.ArffSaver')() saver.setInstances(reduced_data) saver.setFile(autoclass("java.io.File")("./R" + data_src[2:])) saver.writeBatch()
def _Toast(self, msg, length_long=False): Toast = autoclass('android.widget.Toast') context = autoclass('org.renpy.android.PythonActivity').mActivity duration = Toast.LENGTH_LONG if length_long else Toast.LENGTH_SHORT String = autoclass('java.lang.String') c = cast('java.lang.CharSequence', String(msg)) t = Toast.makeText(context, c, duration) t.show()
def test_assignable(self): ArrayList = autoclass('java.util.ArrayList') Object = autoclass('java.lang.Object') a = ArrayList() # addAll accept Collection, Object must failed self.assertRaises(JavaException, a.addAll, Object()) # while adding another ArrayList must be ok. a.addAll(ArrayList())
def connect(self): # set client variables and java classes adapter = autoclass("android.bluetooth.BluetoothAdapter") UUID = autoclass("java.util.UUID") pairedDevices = adapter.getDefaultAdapter().getBondedDevices().toArray() # sendStream wird global gesetzt damit man sie von anderen klassen aufrufen kann global sendStream global socket # connecting # checkt ob checkState bereits True ist if self.checkState == False: for device in pairedDevices: system.out.println(device.getName()) if device.getName() == "LED-TABLE_v1.0": try: id = "94f39d29-7d6d-437d-973b-fba39e49d4aa" socket = device.createRfcommSocketToServiceRecord(UUID.fromString(id)) sendStream = socket.getOutputStream() system.out.println("try to connect") socket.connect() self.checkState = True system.out.println("connected") except: system.out.println("unsuccessful") self.checkState = False break else: if socket.isConnected(): system.out.println("already connected!") else: self.checkState = False connect()
def getAllAps(): ''' Returns all applications installed [{'packageName':packageName, 'sourceDir':sourceDirectory}, etc] ''' infos = [] pythonService = autoclass("org.renpy.android.PythonService") PackageManager= autoclass("android.content.pm.PackageManager") ApplicationInfo= autoclass("android.content.pm.ApplicationInfo") activity = cast("android.app.Service", pythonService.mService) pm = activity.getPackageManager() packages = pm.getInstalledApplications(PackageManager.GET_META_DATA) for appNb in range(packages.size()): appInfo = packages.get(appNb) packageName = appInfo.packageName sourceDir = appInfo.sourceDir dataDir = appInfo.dataDir processName = appInfo.processName publicSourceDir = appInfo.publicSourceDir sharedLibraryFiles = appInfo.sharedLibraryFiles packagePerms = pm.getPackageInfo(appInfo.packageName, PackageManager.GET_PERMISSIONS) requestedPermissions = packagePerms.requestedPermissions permissions = [] if requestedPermissions != None: for i in range(len(requestedPermissions)): permissions.append(requestedPermissions[i]) infos.append({"packageName":packageName, "sourceDir":sourceDir, "dataDir":dataDir, "processName":processName, "publicSourceDir":publicSourceDir, "sharedLibraryFiles":sharedLibraryFiles, "permissions":permissions, }) return infos
def to_java(value): if isinstance(value, Object): return value elif isinstance(value, (str, unicode)): String = autoclass('java.lang.String') return String(value) elif isinstance(value, int): Integer = autoclass('java.lang.Integer') return Integer(value) elif isinstance(value, float): Float = autoclass('java.lang.Float') return Float(value) # elif isinstance(value, long): # Long = autoclass('java.lang.Long') # return Long(value) elif isinstance(value, list): return value elif isinstance(value, dict): map = autoclass('java.util.HashMap')() for k, v in value.iteritems(): map.put(k, to_java(v)) return map elif value == None: return '' else: raise TypeError('type not supported %s', type(value))
def build(self): self.root = NotificationDemo(self) if platform == 'android': try: self.service = autoclass( 'org.test.npexample.ServiceMyservice') mActivity = autoclass( 'org.kivy.android.PythonActivity').mActivity argument = '' self.service.start(mActivity, argument) except: self.service = AndroidService( 'Sevice example', 'service is running') self.service.start('Hello From Service') else: Window.system_size = cm(7), cm(12) self.client.on_connect = self.on_connect self.client.on_disconnect = self.on_disconnect Clock.schedule_once(self.try_connecting, 0) Clock.schedule_interval(self.handle_msg, 0.1) # def skipp(*a): # self.root.ids.sm.current = 'main' # Clock.schedule_once(skipp, 0.5) return self.root
def parse_file(filename): """ Import TIKA classes and parse input filename """ import os os.environ['CLASSPATH'] = "/path/to/tika-app.jar" from jnius import autoclass from jnius import JavaException # Import the Java classes Tika = autoclass('org.apache.tika.Tika') Metadata = autoclass('org.apache.tika.metadata.Metadata') FileInputStream = autoclass('java.io.FileInputStream') tika = Tika() tika.setMaxStringLength(10*1024*1024); meta = Metadata() # Raise an exception and continue if parsing fails try: text = tika.parseToString(FileInputStream(filename), meta) return text except (JavaException,UnicodeDecodeError), e: print "ERROR: %s" % (e)
def getSimState(): ''' Returns a string indicating the state of the default SIM card Returns None if an error ''' try: status="?" mContext = autoclass('android.content.Context') pythonActivity = autoclass('org.renpy.android.PythonService') TelephonyManager = autoclass('android.telephony.TelephonyManager') telephonyManager = cast('android.telephony.TelephonyManager', pythonActivity.mService.getSystemService(mContext.TELEPHONY_SERVICE)) simState = telephonyManager.getSimState() if simState == TelephonyManager.SIM_STATE_UNKNOWN: status = "unknown" elif simState == TelephonyManager.SIM_STATE_ABSENT: status = "absent" elif simState == TelephonyManager.SIM_STATE_PIN_REQUIRED: status = "pin_required" elif simState == TelephonyManager.SIM_STATE_PUK_REQUIRED: status = "puk_required" elif simState == TelephonyManager.SIM_STATE_NETWORK_LOCKED: status = "network_locked" elif simState == TelephonyManager.SIM_STATE_READY: status = "ready" return status except Exception,e: return None
def build(self): global SPORT game = CrazyBotGame() if Hardware is not None: try: import android import android.activity # noqa # test for an intent passed to us PythonActivity = autoclass('org.renpy.android.PythonActivity') UsbManager = autoclass('android.hardware.usb.UsbManager') UsbSerialPort = autoclass('com.hoho.android.usbserial.driver.UsbSerialPort') Context = autoclass('android.content.Context') activity = PythonActivity.mActivity intent = activity.getIntent() # intent_data = intent.getData() device = cast('android.hardware.usb.UsbDevice', intent.getParcelableExtra(UsbManager.EXTRA_DEVICE)) print device Cp21xxSerialDriver = autoclass('com.hoho.android.usbserial.driver.Cp21xxSerialDriver') driver = Cp21xxSerialDriver(device) print driver manager = cast('android.hardware.usb.UsbManager', activity.getSystemService(Context.USB_SERVICE)) print manager port = cast('com.hoho.android.usbserial.driver.UsbSerialPort', driver.getPorts().get(0)) print port connection = cast('android.hardware.usb.UsbDeviceConnection', manager.openDevice(device)) print connection port.open(connection) port.setParameters(57600, 8, UsbSerialPort.STOPBITS_1, UsbSerialPort.PARITY_NONE) SPORT = port except Exception, e: print e game.device = "E " + str(e)
def get_os_version(self): if utils.platform is not "android": return utils.platform import jnius bv = jnius.autoclass('android.os.Build$VERSION') b = jnius.autoclass('android.os.Build') return "Android {} on {} {} ({})".format(bv.RELEASE, b.BRAND, b.DEVICE, b.DISPLAY)
def build(self): if platform == 'android': self.start_service() from jnius import autoclass self.Locale = autoclass('java.util.Locale') self.PythonActivity = autoclass('org.renpy.android.PythonActivity') self.TextToSpeech = autoclass('android.speech.tts.TextToSpeech') self.tts = self.TextToSpeech(self.PythonActivity.mActivity, None) self.locales = { 'CANADA':self.Locale.CANADA, 'FRANCE':self.Locale.FRANCE, 'GERMANY':self.Locale.GERMANY, 'ITALY':self.Locale.ITALY, 'JAPAN':self.Locale.JAPAN, 'KOREA':self.Locale.KOREA, 'CHINA':self.Locale.SIMPLIFIED_CHINESE, 'UK':self.Locale.UK, 'US':self.Locale.US } osc.init() oscid = osc.listen(ipAddr='127.0.0.1', port=activityport) osc.bind(oscid, self.some_api_callback, '/some_api') Clock.schedule_interval(lambda *x: osc.readQueue(oscid), 0) self.service_enabled = False self.toggle_service() self.load_settings() self.chosen_locale = self.config.get('example','optionsexample') self.tts_enabled = bool(int(self.config.get('example','boolexample'))) return
def ShareActivity(text, title=None): if not title: title = 'Share Via' if platform == 'android': try: from jnius import autoclass, cast AndroidString = autoclass('java.lang.String') Uri = autoclass('android.net.Uri') # start android intent stuff Intent = autoclass('android.content.Intent') shareIntent = Intent(Intent.ACTION_SEND) shareIntent.setType("text/plain") shareIntent.putExtra(Intent.EXTRA_TEXT, AndroidString(text)) PythonActivity = autoclass('org.renpy.android.PythonActivity') theActivity = PythonActivity.mActivity chooser_title = cast('java.lang.CharSequence', AndroidString(title)) theActivity.startActivity(Intent.createChooser(shareIntent, chooser_title)) except: print 'Failed sharing text -- %s' % text pass elif platform == 'ios': from pyobjus import autoclass, objc_str ObjcClass = autoclass('ShareViewControllerINDR') o_instance = ObjcClass.alloc().init() if not title: title = '' o_instance.aTitle = objc_str(title) o_instance.aApp = objc_str('link') o_instance.aURL = objc_str(text) o_instance.shareImagePost() else: print 'Sharing: %s -- %s' % (title, text)
def pdf_to_csv(): """ Iterates throught all the pdf stored in ./data/pdf/ folder and export its content to the file data.csv. The format of the csv file should have two columns: id and text """ bar = progressbar.ProgressBar() csv_data_file = _DATA_PATH + "data_tika.csv" Tika = autoclass('org.apache.tika.Tika') Metadata = autoclass('org.apache.tika.metadata.Metadata') FileInputStream = autoclass('java.io.FileInputStream') tika = Tika() meta = Metadata() with open(csv_data_file, "w", newline='') as csvfile: data_writer = csv.writer(csvfile) data_writer.writerow(["document_id","document_text"]) for fn in bar(os.listdir(_PDF_PATH)): filename = os.path.join(_PDF_PATH, fn) if filename.endswith(".pdf"): try: text = tika.parseToString(FileInputStream(filename), meta) except Exception as e: print("Error desconocido en el PDF: {0}".format(fn)) print("Error: {0}".format(e)) else: #TODO: Check if text is not empty text = limpiar_texto(text) data_writer.writerow([fn,text])
def get_scaled_icon(icon): """ icon : name of icon file (png) without extension this function assumes that a 'Drawable' was regiseted, (see original post) it should be possible to create a bitmap dynamically, using a bitmap factory. Bitmap bm = BitmapFactory.decodeResource(getResources(), R.drawable.image); """ Dimen = autoclass("android.R$dimen") Bitmap = autoclass("android.graphics.Bitmap") PythonService = autoclass('org.renpy.android.PythonService') service = PythonService.mService Drawable = autoclass("{}.R$drawable".format(service.getPackageName())) scaled_icon = getattr(Drawable, icon) scaled_icon = cast("android.graphics.drawable.BitmapDrawable", service.getResources().getDrawable(scaled_icon)) scaled_icon = scaled_icon.getBitmap() res = service.getResources() height = res.getDimension(Dimen.notification_large_icon_height) width = res.getDimension(Dimen.notification_large_icon_width) return Bitmap.createScaledBitmap(scaled_icon, width, height, False)
def context(self): from os import environ if 'PYTHON_SERVICE_ARGUMENT' in environ: PythonService = autoclass(JAVA_NAMESPACE + '.PythonService') return PythonService.mService PythonActivity = autoclass(JAVA_NAMESPACE + '.PythonActivity') return PythonActivity.mActivity
def main(argv=None): System = autoclass('java.lang.System') print "\nClass Path:", System.getProperty('java.class.path') AdbBackend = autoclass('com.android.chimpchat.adb.AdbBackend') adb = AdbBackend() print "\nAdbBackend Object: ", adb TIMEOUT = 5000 # (ms) ANY_DEVICE = '.*' #This could be the device serial number also. device = adb.waitForConnection(TIMEOUT, ANY_DEVICE) if not device: print "NO DEVICE FOUND" quit() # IChimpDevice http://code.google.com/p/aster/source/browse/src/com/android/chimpchat/adb/AdbChimpDevice.java # IDevice is a property of IChimpDevice - IDevice offers a lot more features. print "DEVICE: ", device mod = device.getProperty('build.model') print "Model:", mod # This returns a Java Collection, this object is not converted automatically into a python type collection = device.getPropertyList() # Pretty much any iterable in Java can be converted to an Array using 'toArray' - this results in a native python list props = collection.toArray() # this will be a list print "\nAnd here's our native Python List:" print type(props) print "\nAndroid Device Properties:" for p in props: print p.ljust(25), device.getProperty(p)
def get_activity_lib_dir(activity_name): from jnius import autoclass # Get the actual activity instance: activity_class = autoclass(activity_name) if activity_class is None: return None activity = None if hasattr(activity_class, "mActivity") and \ activity_class.mActivity is not None: activity = activity_class.mActivity elif hasattr(activity_class, "mService") and \ activity_class.mService is not None: activity = activity_class.mService if activity is None: return None # Extract the native lib dir from the activity instance: package_name = activity.getApplicationContext().getPackageName() manager = activity.getApplicationContext().getPackageManager() manager_class = autoclass("android.content.pm.PackageManager") native_lib_dir = manager.getApplicationInfo( package_name, manager_class.GET_SHARED_LIBRARY_FILES ).nativeLibraryDir return native_lib_dir
def speak(text, lang='US'): """ use the text to speach API to speak text out loud :-) """ Locale = autoclass('java.util.Locale') PythonActivity = autoclass('org.renpy.android.PythonService') TextToSpeech = autoclass('android.speech.tts.TextToSpeech') tts = TextToSpeech(PythonActivity.mService, None) time.sleep(0.1) #dirty but avoid implementing TextToSpeech.OnInitListener try: if lang is not None: if lang in ['CANADA', 'CANADA_FRENCH', 'CHINA', 'CHINESE', 'ENGLISH', 'FRANCE', 'FRENCH', 'GERMAN', 'GERMANY', 'ITALIAN', 'ITALY', 'JAPAN', 'JAPANESE', 'KOREA', 'KOREAN', 'PRC', 'PRIVATE_USE_EXTENSION', 'ROOT', 'SIMPLIFIED_CHINESE', 'TAIWAN', 'TRADITIONAL_CHINESE', 'UK', 'UNICODE_LOCALE_EXTENSION', 'US']: error_codes={-1:'LANG_MISSING_DATA', -2:'LANG_NOT_SUPPORTED'} ret=tts.setLanguage(getattr(Locale,lang)) if ret in error_codes: raise Exception("Error in setLanguage: %s for lang: %s"%(error_codes[ret],lang)) else: raise Exception("no such locale : %s"%lang) #ref. http://developer.android.com/reference/android/speech/tts/TextToSpeech.html ret=tts.speak(str(text), TextToSpeech.QUEUE_FLUSH, None) for i in range(0,10): time.sleep(0.1) while tts.isSpeaking(): time.sleep(0.1) if ret == TextToSpeech.LANG_MISSING_DATA: raise Exception("Error: LANG_MISSING_DATA") return ret finally: tts.shutdown()
def main(): args = parser.parse_args() if not args.alias: print("Don't know the alias names ?") cmd = ( "keytool -list " "-keystore '{}' " "-storepass '{}' " "-storetype '{}'" ).format( args.keystore, args.keystore_pass, args.store_type ) print(cmd) os.system(cmd) exit(0) if not args.secret_pass: args.secret_pass = args.keystore_pass KeyStore = jnius.autoclass("java.security.KeyStore") FileInputStream = jnius.autoclass("java.io.FileInputStream") File = jnius.autoclass("java.io.File") ks = KeyStore.getInstance(args.store_type.upper()) ks.load(FileInputStream(File(args.keystore)), args.keystore_pass) key = ks.getKey(args.alias, args.secret_pass) value = key.getEncoded().tostring() sys.stdout.write(value)
def context(self): from os import environ if 'PYTHON_SERVICE_ARGUMENT' in environ: PythonService = autoclass('org.renpy.android.PythonService') return PythonService.mService PythonActivity = autoclass('org.renpy.android.PythonActivity') return PythonActivity.mActivity
def choose_variants(): if "RENPY_VARIANT" in os.environ: renpy.config.variants = list(os.environ["RENPY_VARIANT"].split()) + [ None ] return renpy.config.variants = [ None ] if renpy.android: #@UndefinedVariable renpy.config.variants.insert(0, 'android') import android #@UnresolvedImport import math import pygame from jnius import autoclass # @UnresolvedImport # Are we running on an OUYA? try: OuyaFacade = autoclass("tv.ouya.console.api.OuyaFacade") of = OuyaFacade.getInstance() if of.isRunningOnOUYAHardware(): print "Running on an OUYA." renpy.config.variants.insert(0, "ouya") except: pass # Are we running on OUYA or Google TV or something similar? PythonActivity = autoclass('org.renpy.android.PythonActivity') mActivity = PythonActivity.mActivity package_manager = mActivity.getPackageManager() if package_manager.hasSystemFeature("android.hardware.type.television"): print "Running on a television." renpy.config.variants.insert(0, "tv") renpy.config.variants.insert(0, "small") return # Otherwise, a phone or tablet. renpy.config.variants.insert(0, 'touch') pygame.display.init() info = renpy.display.get_info() diag = math.hypot(info.current_w, info.current_h) / android.get_dpi() print "Screen diagonal is", diag, "inches." if diag >= 6: renpy.config.variants.insert(0, 'tablet') renpy.config.variants.insert(0, 'medium') else: renpy.config.variants.insert(0, 'phone') renpy.config.variants.insert(0, 'small') else: renpy.config.variants.insert(0, 'pc') renpy.config.variants.insert(0, 'large')
def test_newinstance(): Parent = autoclass('org.jnius.Parent') Child = autoclass('org.jnius.Child') child = Child.newInstance() assert isinstance(child, Child) assert isinstance(child, Parent)
def load_ontology(request): ontology_file = request.FILES['ontology'] owner = request.POST['new_owner'] ontology, created = Ontology.objects.get_or_create(owner=owner) # load the OWL ontology Manager = autoclass('org.semanticweb.owlapi.apibinding.OWLManager') mgr = Manager.createOWLOntologyManager() Stream = autoclass('java.io.ByteArrayInputStream') bst = Stream(ontology_file.read()) ist = cast('java.io.InputStream', bst) ont = mgr.loadOntologyFromOntologyDocument(ist); Reasoner = autoclass('org.semanticweb.HermiT.Reasoner') rnr = Reasoner(ont) # process the classes and relations in ontology classes = ont.getClassesInSignature() for c in classes.toArray(): entity_name = c.getIRI().getFragment() if entity_name == "Thing": continue entity, created = Entity.objects.get_or_create( name=entity_name, ontology=ontology) entity.classified = True entity.save() equivs = rnr.getEquivalentClasses(c).getEntities() for e in equivs.toArray(): other_name = e.getIRI().getFragment() if other_name == entity.name: continue other, created = Entity.objects.get_or_create( name=other_name, ontology=ontology) other.classified = True other.save() entity.add_equivalent(other,'U') subs = rnr.getSubClasses(c, True).getFlattened() for e in subs.toArray(): other_name = e.getIRI().getFragment() if other_name == entity.name or other_name == "Nothing": continue other, created = Entity.objects.get_or_create( name=other_name, ontology=ontology) other.classified = True other.save() entity.add_subclass(other, 'U') entities = [] all_entities = Entity.objects.filter(ontology=ontology) for entity in all_entities: if not entity.has_superclasses(): entities.append(entity) return render(request, 'ontology/ontology.html', {'entities': entities})
def isVPNConnected(): mContext = autoclass('android.content.Context') pythonActivity = autoclass('org.renpy.android.PythonService') connectivityManager = autoclass('android.net.ConnectivityManager') cManager = cast('android.net.ConnectivityManager', pythonActivity.mService.getSystemService(mContext.CONNECTIVITY_SERVICE)) try: networkInfo = cManager.getNetworkInfo(connectivityManager.TYPE_VPN) except Exception, e: return False
def vibrate(self, seconds): try: PythonActivity = jnius.autoclass('org.renpy.android.PythonActivity') Context = jnius.autoclass('android.content.Context') activity = PythonActivity.mActivity vibrator = activity.getSystemService(Context.VIBRATOR_SERVICE) vibrator.vibrate(seconds) except jnius.JavaException: print("(Explorerr): Vibration not avaiable, are you on computer?")
def toast(self, text="texto", short=True): Logger.debug("%s: texto %s, short %s" % ( APP, text.encode('ascii', 'ignore'), short)) Toast = autoclass('android.widget.Toast') Gravity = autoclass('android.view.Gravity') duration = Toast.LENGTH_SHORT if short else Toast.LENGTH_LONG t = Toast.makeText(activity, String(text), duration) t.setGravity(Gravity.BOTTOM, 0, 0) t.show()
def transform(self, topics): """ Performs the retrieval with multiple features Args: topics: String for a single query, list of queries, or a pandas.Dataframe with columns=['qid', 'query'] Returns: pandas.Dataframe with columns=['qid', 'docno', 'score', 'features'] """ results = [] queries = coerce_queries_dataframe(topics) docno_provided = "docno" in queries.columns docid_provided = "docid" in queries.columns scores_provided = "scores" in queries.columns if docno_provided or docid_provided: from . import check_version assert check_version(5.3) input_results = queries # query is optional, and functionally dependent on qid. # Hence as long as one row has the query for each qid, # the rest can be None queries = input_results[["qid", "query" ]].dropna(axis=0, subset=["query" ]).drop_duplicates() RequestContextMatching = autoclass( "org.terrier.python.RequestContextMatching") if queries["qid"].dtype == np.int64: queries['qid'] = queries['qid'].astype(str) for row in tqdm(queries.itertuples(), desc=self.name, total=queries.shape[0], unit="q") if self.verbose else queries.itertuples(): qid = str(row.qid) query = row.query srq = self.manager.newSearchRequest(qid, query) for control, value in self.controls.items(): srq.setControl(control, str(value)) # this is needed until terrier-core issue #106 lands if "applypipeline:off" in query: srq.setControl("applypipeline", "off") srq.setOriginalQuery(query.replace("applypipeline:off", "")) # transparently detect matchop queries if _matchop(query): srq.setControl("terrierql", "off") srq.setControl("parsecontrols", "off") srq.setControl("parseql", "off") srq.setControl("matchopql", "on") # this handles the case that a candidate set of documents has been set. if docno_provided or docid_provided: # we use RequestContextMatching to make a ResultSet from the # documents in the candidate set. matching_config_factory = RequestContextMatching.of(srq) input_query_results = input_results[input_results["qid"] == qid] if docid_provided: matching_config_factory.fromDocids( input_query_results["docid"].values.tolist()) elif docno_provided: matching_config_factory.fromDocnos( input_query_results["docno"].values.tolist()) if scores_provided: matching_config_factory.withScores( input_query_results["scores"].values.tolist()) matching_config_factory.build() srq.setControl( "matching", ",".join([ "FatFeaturedScoringMatching", "ScoringMatchingWithFat", srq.getControl("matching") ])) self.manager.runSearchRequest(srq) srq = cast('org.terrier.querying.Request', srq) fres = cast('org.terrier.learning.FeaturedResultSet', srq.getResultSet()) feat_names = fres.getFeatureNames() docids = fres.getDocids() scores = fres.getScores() metadata_list = [] for meta_column in self.metadata: metadata_list.append(fres.getMetaItems("docno")) feats_values = [] for feat in feat_names: feats_values.append(fres.getFeatureScores(feat)) rank = 0 for i in range(fres.getResultSize()): feats_array = [] for j in range(len(feats_values)): feats_array.append(feats_values[j][i]) feats_array = np.array(feats_array) meta = [] for meta_idx, meta_column in enumerate(self.metadata): meta.append(metadata_list[meta_idx][i]) results.append([qid, docids[i], rank] + meta + [scores[i], feats_array]) rank += 1 res_dt = pd.DataFrame( results, columns=["qid", "docid", "rank", "docno", "score", "features"]) return res_dt
def _get_class(qualified_name): from jnius import autoclass return autoclass(qualified_name)
################################################################################ import jnius_config import os import warnings import pydl4j pydl4j.validate_nd4j_jars() # -------------JVM starts here------------- from jnius import autoclass Nd4j = autoclass('org.nd4j.linalg.factory.Nd4j') INDArray = autoclass('org.nd4j.linalg.api.ndarray.INDArray') Transforms = autoclass('org.nd4j.linalg.ops.transforms.Transforms') NDArrayIndex = autoclass('org.nd4j.linalg.indexing.NDArrayIndex') DataBuffer = autoclass('org.nd4j.linalg.api.buffer.DataBuffer') System = autoclass('java.lang.System') Integer = autoclass('java.lang.Integer') Float = autoclass('java.lang.Float') Double = autoclass('java.lang.Double') Shape = autoclass('org.nd4j.linalg.api.shape.Shape') BinarySerde = autoclass('org.nd4j.serde.binary.BinarySerde') NativeOpsHolder = autoclass('org.nd4j.nativeblas.NativeOpsHolder') DoublePointer = autoclass('org.bytedeco.javacpp.DoublePointer') FloatPointer = autoclass('org.bytedeco.javacpp.FloatPointer') IntPointer = autoclass('org.bytedeco.javacpp.IntPointer') DataTypeUtil = autoclass('org.nd4j.linalg.api.buffer.util.DataTypeUtil')
import sys sys.path.append("../../pyLTM") import numpy as np from jnius import autoclass from jnius import cast from pyltm.io import BifParser, BifWriter from pyltm.learner import EMFramework from pyltm.data import ContinuousDatacase from pyltm.reasoner import NaturalCliqueTreePropagation, Evidence # import necessary classes PltmEast = autoclass("PltmEast") GltmEast = autoclass("GltmEast") def learn_latentTree(outpath, settingpath, datapath, initpath=None): if initpath is None: GltmEast.main(["-o", outpath, "-s", settingpath, "-c", "none", datapath]) else: GltmEast.main(["-o", outpath, "-s", settingpath, "-c", "none", "-i", initpath, datapath]) def learn_pouchlatentTree(outpath, settingpath, datapath, initpath=None): if initpath is None: PltmEast.main(["-o", outpath, "-s", settingpath, "-c", "none", datapath]) else: PltmEast.main(["-o", outpath, "-s", settingpath, "-c", "none", "-i", initpath, datapath]) class PouchLatentTree(): def __init__(self, model_file, varNames): bifparser = BifParser()
* W/fb4a:fb:OrcaServiceQueue(28514): com.facebook.orca.protocol.base.ApiException: The proxied app is not already installed. -> ?, doesn't seem dangerous. ''' from kivy.properties import StringProperty, BooleanProperty from kivy.event import EventDispatcher from kivy.clock import Clock from jnius import autoclass, PythonJavaClass, java_method, cast from android import activity from android.runnable import run_on_ui_thread context = autoclass('org.renpy.android.PythonActivity').mActivity Arrays = autoclass('java.util.Arrays') Session = autoclass('com.facebook.Session') SessionBuilder = autoclass('com.facebook.Session$Builder') SessionOpenRequest = autoclass('com.facebook.Session$OpenRequest') SessionNewPermissionsRequest = autoclass( 'com.facebook.Session$NewPermissionsRequest') Request = autoclass('com.facebook.Request') class _FacebookStatusCallback(PythonJavaClass): __javainterfaces__ = ['com.facebook.Session$StatusCallback'] __javacontext__ = 'app' def __init__(self, fb): self.fb = fb
def remove_android_splash(self, *args): from jnius import autoclass activity = autoclass('org.kivy.android.PythonActivity').mActivity activity.removeLoadingScreen()
from jnius import autoclass, detach from plyer.platforms.android import activity, SDK_INT from threading import Thread from time import sleep # try: # PythonActivity = autoclass('org.renpy.android.PythonActivity') # PythonService = autoclass('org.renpy.android.PythonService') Intent = autoclass('android.content.Intent') aString = autoclass('java.lang.String') aInt = autoclass('java.lang.Integer') Context = autoclass('android.content.Context') NotificationBuilder = autoclass('android.app.Notification$Builder') Drawable = autoclass("{}.R$drawable".format(activity.getPackageName())) Pend = autoclass('android.app.PendingIntent') NotificationManager = autoclass('android.app.NotificationManager') Vibrator = activity.getSystemService(Context.VIBRATOR_SERVICE) MediaPlayer = autoclass('android.media.MediaPlayer') AudioManager = autoclass('android.media.AudioManager') # this = PythonService.mService this = activity if SDK_INT > 22: Action_Builder = autoclass('android.app.Notification$Action$Builder') def return_intent(intentName): intent = Intent(intentName) return intent class AndroidNotification:
def run(cmd, args=[]): """ Allows to run a Terrier executable class, i.e. one that can be access from the `bin/terrier` commandline programme. """ from jnius import autoclass autoclass("org.terrier.applications.CLITool").main([cmd] + args)
class Test(MDApp): def build(self): return Builder.load_string(KV) def show_toast(self): toast("Hello World", True, 80, 200, 0) Test().run() """ all = ("toast", ) from android.runnable import run_on_ui_thread from jnius import autoclass activity = autoclass("org.kivy.android.PythonActivity").mActivity Toast = autoclass("android.widget.Toast") String = autoclass("java.lang.String") @run_on_ui_thread def toast(text, length_long=False, gravity=0, y=0, x=0): """ Displays a toast. :param length_long: the amount of time (in seconds) that the toast is visible on the screen. :param text: text to be displayed in the toast; :param short_duration: duration of the toast, if `True` the toast will last 2.3s but if it is `False` the toast will last 3.9s; :param gravity: refers to the toast position, if it is 80the toast will
# Same as before, with a kivy-based UI ''' Bluetooth/Pyjnius example ========================= This was used to send some bytes to an arduino via bluetooth. The app must have BLUETOOTH and BLUETOOTH_ADMIN permissions (well, i didn't tested without BLUETOOTH_ADMIN, maybe it works.) Connect your device to your phone, via the bluetooth menu. After the pairing is done, you'll be able to use it in the app. ''' from jnius import autoclass BluetoothAdapter = autoclass('android.bluetooth.BluetoothAdapter') BluetoothDevice = autoclass('android.bluetooth.BluetoothDevice') BluetoothSocket = autoclass('android.bluetooth.BluetoothSocket') UUID = autoclass('java.util.UUID') def get_socket_stream(name): paired_devices = BluetoothAdapter.getDefaultAdapter().getBondedDevices( ).toArray() socket = None for device in paired_devices: if device.getName() == name: socket = device.createRfcommSocketToServiceRecord( UUID.fromString("00001101-0000-1000-8000-00805F9B34FB")) recv_stream = socket.getInputStream() send_stream = socket.getOutputStream()
''' Clipboard Android ================= Android implementation of Clipboard provider, using Pyjnius. ''' __all__ = ('ClipboardAndroid', ) from kivy import Logger from kivy.core.clipboard import ClipboardBase from jnius import autoclass, cast from android.runnable import run_on_ui_thread from android import python_act AndroidString = autoclass('java.lang.String') PythonActivity = python_act Context = autoclass('android.content.Context') VER = autoclass('android.os.Build$VERSION') sdk = VER.SDK_INT class ClipboardAndroid(ClipboardBase): def __init__(self): super(ClipboardAndroid, self).__init__() self._clipboard = None self._data = dict() self._data['text/plain'] = None self._data['application/data'] = None PythonActivity._clipboard = None
def transform(self, queries): """ Performs the retrieval Args: queries: String for a single query, list of queries, or a pandas.Dataframe with columns=['qid', 'query']. For re-ranking, the DataFrame may also have a 'docid' and or 'docno' column. Returns: pandas.Dataframe with columns=['qid', 'docno', 'rank', 'score'] """ results = [] if not isinstance(queries, pd.DataFrame): warn( ".transform() should be passed a dataframe. Use .search() to execute a single query.", FutureWarning, 2) queries = coerce_queries_dataframe(queries) docno_provided = "docno" in queries.columns docid_provided = "docid" in queries.columns scores_provided = "score" in queries.columns if docno_provided or docid_provided: from . import check_version assert check_version(5.3) input_results = queries # query is optional, and functionally dependent on qid. # Hence as long as one row has the query for each qid, # the rest can be None queries = input_results[["qid", "query" ]].dropna(axis=0, subset=["query" ]).drop_duplicates() RequestContextMatching = autoclass( "org.terrier.python.RequestContextMatching") # make sure queries are a String if queries["qid"].dtype == np.int64: queries['qid'] = queries['qid'].astype(str) for row in tqdm(queries.itertuples(), desc=str(self), total=queries.shape[0], unit="q") if self.verbose else queries.itertuples(): rank = FIRST_RANK qid = str(row.qid) query = row.query srq = self.manager.newSearchRequest(qid, query) for control, value in self.controls.items(): srq.setControl(control, str(value)) # this is needed until terrier-core issue #106 lands if "applypipeline:off" in query: srq.setControl("applypipeline", "off") srq.setOriginalQuery(query.replace("applypipeline:off", "")) # transparently detect matchop queries if _matchop(query): srq.setControl("terrierql", "off") srq.setControl("parsecontrols", "off") srq.setControl("parseql", "off") srq.setControl("matchopql", "on") # this handles the case that a candidate set of documents has been set. num_expected = None if docno_provided or docid_provided: # we use RequestContextMatching to make a ResultSet from the # documents in the candidate set. matching_config_factory = RequestContextMatching.of(srq) input_query_results = input_results[input_results["qid"] == qid] num_expected = len(input_query_results) if docid_provided: matching_config_factory.fromDocids( input_query_results["docid"].values.tolist()) elif docno_provided: matching_config_factory.fromDocnos( input_query_results["docno"].values.tolist()) # batch retrieve is a scoring process that always overwrites the score; no need to provide scores as input #if scores_provided: # matching_config_factory.withScores(input_query_results["score"].values.tolist()) matching_config_factory.build() srq.setControl( "matching", "org.terrier.matching.ScoringMatching" + "," + srq.getControl("matching")) # now ask Terrier to run the request self.manager.runSearchRequest(srq) result = srq.getResults() # check we got all of the expected metadata (if the resultset has a size at all) if len(result) > 0 and len( set(self.metadata) & set(result.getMetaKeys())) != len( self.metadata): raise KeyError("Requested metadata: %s, obtained metadata %s" % (str(self.metadata), str(result.getMetaKeys()))) if num_expected is not None: assert (num_expected == len(result)) # prepare the dataframe for the results of the query for item in result: metadata_list = [] for meta_column in self.metadata: metadata_list.append(item.getMetadata(meta_column)) res = [qid, item.getDocid() ] + metadata_list + [rank, item.getScore()] rank += 1 results.append(res) res_dt = pd.DataFrame(results, columns=['qid', 'docid'] + self.metadata + ['rank', 'score']) # ensure to return the query res_dt = res_dt.merge(queries[["qid", "query"]], on=["qid"]) return res_dt
ij = imagej.init(fiji_path, headless=False) #ij = imagej.init('sc.fiji:fiji') # We import the latest Fiji version, to be reproducible. #ij = imagej.init('net.imagej:imagej+net.imagej:imagej-legacy', headless=False) import jnius from jnius import autoclass print("jnius version: {}".format(jnius.__version__) ) # Version 1.2.1 breaks everything so far, stick to 1.2.0 class IjGui: # Dummy object for storage def __init__(self): pass Font = autoclass("java.awt.Font") ij_gui = IjGui() ij_gui.Overlay = autoclass("ij.gui.Overlay") ij_gui.TextRoi = autoclass("ij.gui.TextRoi") ij_gui.Line = autoclass("ij.gui.Line") ij_gui.Arrow = autoclass("ij.gui.Arrow") ij_gui.Color = autoclass("java.awt.Color") ImagePlus = autoclass("ij.ImagePlus") IJ = autoclass("ij.IJ") ImageJFunctions = autoclass("net.imglib2.img.display.imagej.ImageJFunctions") def apply_overlay(in_i, tb, norm, verbose=False): """Export regions with arrows corresponding to the direction of the force and the motion in_i: input image on which we need to add an overlay
from kivy.properties import (BooleanProperty, StringProperty, ObjectProperty, OptionProperty, ListProperty) from kivy.clock import Clock from jnius import autoclass, cast, PythonJavaClass, java_method, JavaClass, MetaJavaClass, JavaMethod import logging from enum import Enum logger = logging.getLogger(__file__) logger.setLevel(logging.DEBUG) handler = logging.StreamHandler() handler.setLevel(logging.DEBUG) logger.addHandler(handler) CameraManager = autoclass("android.hardware.camera2.CameraManager") PythonActivity = autoclass("org.kivy.android.PythonActivity") Context = autoclass("android.content.Context") context = cast("android.content.Context", PythonActivity.mActivity) CameraDevice = autoclass("android.hardware.camera2.CameraDevice") CaptureRequest = autoclass("android.hardware.camera2.CaptureRequest") CameraCharacteristics = autoclass( "android.hardware.camera2.CameraCharacteristics") ArrayList = autoclass('java.util.ArrayList') JavaArray = autoclass('java.lang.reflect.Array') SurfaceTexture = autoclass('android.graphics.SurfaceTexture') Surface = autoclass('android.view.Surface') GL_TEXTURE_EXTERNAL_OES = autoclass(
import time from plyer import notification from jnius import autoclass PythonService = autoclass('org.kivy.android.PythonService') PythonService.mService.setAutoRestartService(True) print("in Service") import getDSB #getDSB.getContent() print("in Service") while True: time.sleep(60) getDSB.getContent()
def android_ext_dir(): import jnius env = jnius.autoclass('android.os.Environment') return env.getExternalStorageDirectory().getPath()
def back_button_leave_app(self): if platform != 'android': return from jnius import autoclass activity = autoclass('org.kivy.android.PythonActivity') activity.moveTaskToBack(True)
def android_data_dir(): import jnius PythonActivity = jnius.autoclass('org.kivy.android.PythonActivity') return PythonActivity.mActivity.getFilesDir().getPath() + '/data'
#!/usr/bin/env python from jnius import autoclass DisplayMetrics = autoclass('android.utils.DisplayMetrics') System = autoclass('android.provider.Settings$System') PythonActivity = autoclass('org.renpy.android.PythonActivity') class DisplayAccess(object): def __init__(self): self.metrics = DisplayMetrics() def get_dpi(self): return self.metrics.densityDpi def get_height(self): return self.metrics.heightPixels def get_width(self): return self.metrics.widthPixels @staticmethod def get_brightness(): return System.getInt(PythonActivity.mActivity.getContentResolver(), System.SCREEN_BRIGHTNESS)
in order to showcase how minie can be used with python. """ # Change CLASSPATH to point to the minie jar archive, import os os.environ['CLASSPATH'] = "../../../../../target/minie-0.0.1-SNAPSHOT.jar" # Uncomment to point to your java home (an example is given for arch linux) # if you don't have it as an environment variable already. # os.environ['JAVA_HOME'] = '/usr/lib/jvm/default' # Import java classes in python with pyjnius' autoclass (might take some time) from jnius import autoclass CoreNLPUtils = autoclass('de.uni_mannheim.utils.coreNLP.CoreNLPUtils') AnnotatedProposition = autoclass( 'de.uni_mannheim.minie.annotation.AnnotatedProposition') MinIE = autoclass('de.uni_mannheim.minie.MinIE') StanfordCoreNLP = autoclass('edu.stanford.nlp.pipeline.StanfordCoreNLP') String = autoclass('java.lang.String') # Dependency parsing pipeline initialization parser = CoreNLPUtils.StanfordDepNNParser() # Input sentence sentence = "The Joker believes that the hero Batman was not actually born in foggy Gotham City." # Generate the extractions (With SAFE mode (mode = 2)) # NOTE: sentence must be wrapped into String, else it won't work. minie = MinIE(String(sentence), parser, 2)
from kivy.config import Config from kivy.core.text.markup import MarkupLabel from kivy.uix.screenmanager import ScreenManager, Screen from kivy.factory import Factory from kivy.clock import Clock from kivymd.app import MDApp from kivymd.theming import ThemableBehavior from kivymd.uix.bottomsheet import MDListBottomSheet from kivymd.uix.banner import MDBanner from kivymd.uix.toolbar import MDToolbar from plyer import vibrator from android.runnable import run_on_ui_thread from jnius import autoclass Color = autoclass("android.graphics.Color") WindowManager = autoclass('android.view.WindowManager$LayoutParams') activity = autoclass('org.kivy.android.PythonActivity').mActivity class ContentNavigationDrawer(BoxLayout): screen_manager = ObjectProperty() nav_drawer = ObjectProperty() class Main_Screen(FloatLayout): def __init__(self, **kwargs): super(Main_Screen, self).__init__(**kwargs) class Custom(FloatLayout):
from jnius import autoclass from kivy import Logger, platform PythonActivity = None if platform == "android": PythonActivity = autoclass("org.kivy.android.PythonActivity").mActivity Context = autoclass('android.content.Context') ContextCompat = autoclass('android.support.v4.content.ContextCompat') def check_permission(permission, activity=None): if platform == "android": activity = PythonActivity if not activity: return False permission_status = ContextCompat.checkSelfPermission(activity, permission) Logger.info(permission_status) permission_granted = 0 == permission_status Logger.info("Permission Status: {}".format(permission_granted)) return permission_granted def ask_permission(permission): PythonActivity.requestPermissions([permission])
Added simple toaster notification. .. versionchanged:: 1.4.0 Fixed notifications not displaying big icons properly. Added option for custom big icon via `icon`. ''' from __future__ import unicode_literals from android import python_act from android.runnable import run_on_ui_thread from jnius import autoclass, cast from plyer.facades import Notification from plyer.platforms.android import activity, SDK_INT AndroidString = autoclass('java.lang.String') Context = autoclass('android.content.Context') NotificationBuilder = autoclass('android.app.Notification$Builder') NotificationManager = autoclass('android.app.NotificationManager') Drawable = autoclass("{}.R$drawable".format(activity.getPackageName())) PendingIntent = autoclass('android.app.PendingIntent') Intent = autoclass('android.content.Intent') Toast = autoclass('android.widget.Toast') BitmapFactory = autoclass('android.graphics.BitmapFactory') class AndroidNotification(Notification): # pylint: disable=too-few-public-methods ''' Implementation of Android notification API.
import re import humanize from dateutil.parser import parse import dropbox from kivy.lang import Builder import datetime from kivy.core.window import Window Window.softinput_mode = 'below_target' if platform in ('macosx', 'ios'): HomePath = os.path.expanduser('~/Documents/') elif platform in ('android', ): from jnius import autoclass Environment = autoclass('android.os.Environment') HomePath = Environment.getExternalStorageDirectory().getPath() # HomePath = user_data_dir else: HomePath = kivy_home_dir SettingsPath = os.path.join(HomePath, 'settings.json') class CircularButton( ButtonBehavior, Widget, ): def collide_point(self, x, y): return Vector(x, y).distance(self.center) <= self.width / 2
def transform(self, queries): """ Performs the retrieval with multiple features Args: queries: String for a single query, list of queries, or a pandas.Dataframe with columns=['qid', 'query']. For re-ranking, the DataFrame may also have a 'docid' and or 'docno' column. Returns: pandas.DataFrame with columns=['qid', 'docno', 'score', 'features'] """ results = [] if not isinstance(queries, pd.DataFrame): warn( ".transform() should be passed a dataframe. Use .search() to execute a single query.", FutureWarning, 2) queries = coerce_queries_dataframe(queries) docno_provided = "docno" in queries.columns docid_provided = "docid" in queries.columns scores_provided = "score" in queries.columns if docno_provided or docid_provided: #re-ranking mode from . import check_version assert check_version(5.3) input_results = queries # query is optional, and functionally dependent on qid. # Hence as long as one row has the query for each qid, # the rest can be None queries = input_results[["qid", "query" ]].dropna(axis=0, subset=["query" ]).drop_duplicates() RequestContextMatching = autoclass( "org.terrier.python.RequestContextMatching") if not scores_provided and self.wmodel is None: raise ValueError( "We're in re-ranking mode, but input does not have scores, and wmodel is None" ) else: assert not scores_provided if self.wmodel is None: raise ValueError( "We're in retrieval mode, but wmodel is None. FeaturesBatchRetrieve requires a wmodel be set for identifying the candidate set. " + " Hint: wmodel argument for FeaturesBatchRetrieve, e.g. FeaturesBatchRetrieve(index, features, wmodel=\"DPH\")" ) if queries["qid"].dtype == np.int64: queries['qid'] = queries['qid'].astype(str) newscores = [] for row in tqdm(queries.itertuples(), desc=str(self), total=queries.shape[0], unit="q") if self.verbose else queries.itertuples(): qid = str(row.qid) query = row.query srq = self.manager.newSearchRequest(qid, query) for control, value in self.controls.items(): srq.setControl(control, str(value)) # this is needed until terrier-core issue #106 lands if "applypipeline:off" in query: srq.setControl("applypipeline", "off") srq.setOriginalQuery(query.replace("applypipeline:off", "")) # transparently detect matchop queries if _matchop(query): srq.setControl("terrierql", "off") srq.setControl("parsecontrols", "off") srq.setControl("parseql", "off") srq.setControl("matchopql", "on") # this handles the case that a candidate set of documents has been set. if docno_provided or docid_provided: # we use RequestContextMatching to make a ResultSet from the # documents in the candidate set. matching_config_factory = RequestContextMatching.of(srq) input_query_results = input_results[input_results["qid"] == qid] if docid_provided: matching_config_factory.fromDocids( input_query_results["docid"].values.tolist()) elif docno_provided: matching_config_factory.fromDocnos( input_query_results["docno"].values.tolist()) if scores_provided: if self.wmodel is None: # we provide the scores, so dont use a weighting model, and pass the scores through Terrier matching_config_factory.withScores( input_query_results["score"].values.tolist()) srq.setControl("wmodel", "Null") else: srq.setControl("wmodel", self.wmodel) matching_config_factory.build() srq.setControl( "matching", ",".join([ "FatFeaturedScoringMatching", "ScoringMatchingWithFat", srq.getControl("matching") ])) self.manager.runSearchRequest(srq) srq = cast('org.terrier.querying.Request', srq) fres = cast('org.terrier.learning.FeaturedResultSet', srq.getResultSet()) feat_names = fres.getFeatureNames() docids = fres.getDocids() scores = fres.getScores() metadata_list = [ fres.getMetaItems(meta_column) for meta_column in self.metadata ] feats_values = [fres.getFeatureScores(feat) for feat in feat_names] rank = FIRST_RANK for i in range(fres.getResultSize()): doc_features = np.array( [feature[i] for feature in feats_values]) meta = [metadata_col[i] for metadata_col in metadata_list] results.append([qid, docids[i], rank, doc_features] + meta) newscores.append(scores[i]) rank += 1 res_dt = pd.DataFrame(results, columns=["qid", "docid", "rank", "features"] + self.metadata) # if scores_provided and self.wmodel is None: # # we take the scores from the input dataframe, as ScoringMatchingWithFat overwrites them # # prefer to join on docid # if docid_provided: # res_dt = res_dt.merge(topics[["qid", "docid", "score"]], on=["qid", "docid"], how='right') # else: # assert docno_provided # res_dt = res_dt.merge(topics[["qid", "docno", "score"]], on=["qid", "docno"], how='right') # elif self.wmodel is not None: # # we use new scores obtained from Terrier # # order should be same as the results column # res_dt["score"] = newscores res_dt["score"] = newscores return res_dt
#!/usr/bin/env python from jnius import autoclass TestIO = autoclass('hdfsio.TestIO') TestIO.writeHDFS()
def version(): """ Returns the version string from the underlying Terrier platform. """ from jnius import autoclass return autoclass("org.terrier.Version").VERSION
def init(version=None, mem=None, packages=[], jvm_opts=[], redirect_io=True, logging='WARN', home_dir=None, boot_packages=[], tqdm=None): """ Function necessary to be called before Terrier classes and methods can be used. Loads the Terrier .jar file and imports classes. Also finds the correct version of Terrier to download if no version is specified. Args: version(str): Which version of Terrier to download. Default is `None`. * If None, find the newest Terrier released version in MavenCentral and download it. * If `"snapshot"`, will download the latest build from `Jitpack <https://jitpack.io/>`_. mem(str): Maximum memory allocated for the Java virtual machine heap in MB. Corresponds to java `-Xmx` commandline argument. Default is 1/4 of physical memory. boot_packages(list(str)): Extra maven package coordinates files to load before starting Java. Default=`[]`. There is more information about loading packages in the `Terrier documentation <https://github.com/terrier-org/terrier-core/blob/5.x/doc/terrier_develop.md>`_ packages(list(str)): Extra maven package coordinates files to load, using the Terrier classloader. Default=`[]`. See also `boot_packages` above. jvm_opts(list(str)): Extra options to pass to the JVM. Default=`[]`. For instance, you may enable Java assertions by setting `jvm_opts=['-ea']` redirect_io(boolean): If True, the Java `System.out` and `System.err` will be redirected to Pythons sys.out and sys.err. Default=True. logging(str): the logging level to use: * Can be one of `'INFO'`, `'DEBUG'`, `'TRACE'`, `'WARN'`, `'ERROR'`. The latter is the quietest. * Default is `'WARN'`. home_dir(str): the home directory to use. Default to PYTERRIER_HOME environment variable. tqdm: The `tqdm <https://tqdm.github.io/>`_ instance to use for progress bars within PyTerrier. Defaults to tqdm.tqdm. Available options are `'tqdm'`, `'auto'` or `'notebook'`. **Locating the Terrier .jar file:** PyTerrier is not tied to a specific version of Terrier and will automatically locate and download a recent Terrier .jar file. However, inevitably, some functionalities will require more recent Terrier versions. * If set, PyTerrier uses the `version` init kwarg to determine the .jar file to look for. * If the `version` init kwarg is not set, Terrier will query MavenCentral to determine the latest Terrier release. * If `version` is set to `"snapshot"`, the latest .jar file build derived from the `Terrier Github repository <https://github.com/terrier-org/terrier-core/>`_ will be downloaded from `Jitpack <https://jitpack.io/>`_. * Otherwise the local (`~/.mvn`) and MavenCentral repositories are searched for the jar file at the given version. In this way, the default setting is to download the latest release of Terrier from MavenCentral. The user is also able to use a locally installed copy in their private Maven repository, or track the latest build of Terrier from Jitpack. """ set_tqdm(tqdm) global ApplicationSetup global properties global firstInit global file_path global HOME_DIR # we keep a local directory if home_dir is not None: HOME_DIR = home_dir elif "PYTERRIER_HOME" in os.environ: HOME_DIR = os.environ["PYTERRIER_HOME"] else: from os.path import expanduser userhome = expanduser("~") HOME_DIR = os.path.join(userhome, ".pyterrier") if not os.path.exists(HOME_DIR): os.mkdir(HOME_DIR) # get the initial classpath for the JVM classpathTrJars = setup_terrier(HOME_DIR, version, boot_packages=boot_packages) # Import pyjnius and other classes import jnius_config for jar in classpathTrJars: jnius_config.add_classpath(jar) if jvm_opts is not None: for opt in jvm_opts: jnius_config.add_options(opt) if mem is not None: jnius_config.add_options('-Xmx' + str(mem) + 'm') from jnius import autoclass, cast # we only accept Java version 11 and newer; so anything starting 1. or 9. is too old java_version = autoclass("java.lang.System").getProperty("java.version") if java_version.startswith("1.") or java_version.startswith("9."): raise RuntimeError( "Pyterrier requires Java 11 or newer, we only found Java version %s;" + " install a more recent Java, or change os.environ['JAVA_HOME'] to point to the proper Java installation", java_version) tr_version = autoclass('org.terrier.Version') version_string = tr_version.VERSION if "BUILD_DATE" in dir(tr_version): version_string += " (built by %s on %s)" % (tr_version.BUILD_USER, tr_version.BUILD_DATE) print("PyTerrier %s has loaded Terrier %s" % (__version__, version_string)) properties = autoclass('java.util.Properties')() ApplicationSetup = autoclass('org.terrier.utility.ApplicationSetup') from .batchretrieve import BatchRetrieve, FeaturesBatchRetrieve from .utils import Utils from .datasets import get_dataset, list_datasets from .index import Indexer, FilesIndexer, TRECCollectionIndexer, DFIndexer, DFIndexUtils, IterDictIndexer, FlatJSONDocumentIterator, IndexingType from .pipelines import LTR_pipeline, XGBoostLTR_pipeline, Experiment # Make imports global globals()["autoclass"] = autoclass globals()["cast"] = cast globals()["ApplicationSetup"] = ApplicationSetup for sub_module_name in [ 'anserini', 'apply', 'cache', 'index', 'io', 'model', 'new', 'ltr', 'pipelines', 'rewrite', 'text', 'transformer' ]: globals()[sub_module_name] = importlib.import_module( '.' + sub_module_name, package='pyterrier') # append the python helpers if packages is None: packages = [] # Import other java packages if packages != []: pkgs_string = ",".join(packages) properties.put("terrier.mvn.coords", pkgs_string) ApplicationSetup.bootstrapInitialisation(properties) if redirect_io: # this ensures that the python stdout/stderr and the Java are matched redirect_stdouterr() _logging(logging) setup_jnius() globals()["get_dataset"] = get_dataset globals()["list_datasets"] = list_datasets globals()["Experiment"] = Experiment globals()["BatchRetrieve"] = BatchRetrieve globals()["Indexer"] = Indexer globals()["FeaturesBatchRetrieve"] = FeaturesBatchRetrieve globals()["TRECCollectionIndexer"] = TRECCollectionIndexer globals()["FilesIndexer"] = FilesIndexer globals()["DFIndexer"] = DFIndexer globals()["DFIndexUtils"] = DFIndexUtils globals()["IterDictIndexer"] = IterDictIndexer globals()["FlatJSONDocumentIterator"] = FlatJSONDocumentIterator globals()["Utils"] = Utils globals()["LTR_pipeline"] = LTR_pipeline globals()["XGBoostLTR_pipeline"] = XGBoostLTR_pipeline globals()["IndexFactory"] = autoclass( "org.terrier.structures.IndexFactory") globals()["IndexRef"] = autoclass("org.terrier.querying.IndexRef") globals()["IndexingType"] = IndexingType firstInit = True
def transform(self, topics_and_res): from . import DFIndexer, autoclass, IndexFactory from .index import IndexingType documents = topics_and_res[["docno", self.body_attr ]].drop_duplicates(subset="docno") indexref = DFIndexer(None, type=IndexingType.MEMORY, verbose=self.verbose).index( documents[self.body_attr], documents["docno"]) docno2docid = { docno: id for id, docno in enumerate(documents["docno"]) } index_docs = IndexFactory.of(indexref) docno2docid = {} for i in range( 0, index_docs.getCollectionStatistics().getNumberOfDocuments()): docno2docid[index_docs.getMetaIndex().getItem("docno", i)] = i assert len(docno2docid) == index_docs.getCollectionStatistics( ).getNumberOfDocuments( ), "docno2docid size (%d) doesnt match index (%d)" % ( len(docno2docid), index_docs.getCollectionStatistics().getNumberOfDocuments()) # if a background index is set, we create an "IndexWithBackground" using both that and our new index if self.background_indexref is None: index = index_docs else: index_background = IndexFactory.of(self.background_indexref) index = autoclass("org.terrier.python.IndexWithBackground")( index_docs, index_background) topics = topics_and_res[["qid", "query" ]].dropna(axis=0, subset=["query"]).drop_duplicates() if self.takes == "queries": # we have provided the documents, so we dont need a docno or docid column that will confuse # BR and think it is re-ranking. In fact, we only need qid and query input = topics elif self.takes == "docs": # we have to pass the documents, but its desirable to have the docids mapped to the new index already # build a mapping, as the metaindex may not have reverse lookups enabled input = topics_and_res.copy() # add the docid to the dataframe input["docid"] = input.apply(lambda row: docno2docid[row["docno"]], axis=1) # and then just instantiate BR using the our new index # we take all other arguments as arguments for BR inner = self.innerclass(index, **(self.kwargs)) inner.verbose = self.verbose inner_res = inner.transform(input) if self.returns == "docs": # as this is a new index, docids are not meaningful externally, so lets drop them inner_res.drop(columns=['docid'], inplace=True) if len(inner_res) < len(topics_and_res): inner_res = topics_and_res[["qid", "docno" ]].merge(inner_res, on=["qid", "docno"], how="left") inner_res["score"] = inner_res["score"].fillna(value=0) elif self.returns == "queries": if len(inner_res) < len(topics): inner_res = topics.merge(on=["qid"], how="left") else: raise ValueError("returns attribute should be docs of queries") return inner_res
import os import jnius_config from app.config.config import DevelopmentConfig stanford_class_path = os.environ.get('STANFORD_CORENLP_PATH', DevelopmentConfig.STANFORD_CORENLP_PATH) jnius_config.set_classpath('.', str(stanford_class_path) + '/*') from jnius import autoclass System = autoclass('java.lang.System') String = autoclass('java.lang.String') List = autoclass('java.util.List') ArrayList = autoclass('java.util.ArrayList') HashMap = autoclass('java.util.HashMap') Properties = autoclass('java.util.Properties') CoreAnnotations = autoclass('edu.stanford.nlp.ling.CoreAnnotations') CoreLabel = autoclass('edu.stanford.nlp.ling.CoreLabel') Annotation = autoclass('edu.stanford.nlp.pipeline.Annotation') StanfordCoreNLP = autoclass('edu.stanford.nlp.pipeline.StanfordCoreNLP') CollapseUnaryTransformer = autoclass( 'edu.stanford.nlp.sentiment.CollapseUnaryTransformer') Tree = autoclass('edu.stanford.nlp.trees.Tree') TreeCoreAnnotations = autoclass('edu.stanford.nlp.trees.TreeCoreAnnotations') Trees = autoclass('edu.stanford.nlp.trees.Trees') CoreMap = autoclass('edu.stanford.nlp.util.CoreMap') StringUtils = autoclass('edu.stanford.nlp.util.StringUtils')
def scan_qr(self, on_complete): if platform != "android": return from jnius import autoclass from android import activity PythonActivity = autoclass("org.renpy.android.PythonActivity") Intent = autoclass("android.content.Intent") intent = Intent("com.google.zxing.client.android.SCAN") intent.putExtra("SCAN_MODE", "QR_CODE_MODE") def on_qr_result(requestCode, resultCode, intent): if requestCode == 0: if resultCode == -1: # RESULT_OK: contents = intent.getStringExtra("SCAN_RESULT") if intent.getStringExtra("SCAN_RESULT_FORMAT") == "QR_CODE": on_complete(contents) else: self.show_error("wrong format " + intent.getStringExtra("SCAN_RESULT_FORMAT")) activity.bind(on_activity_result=on_qr_result) try: PythonActivity.mActivity.startActivityForResult(intent, 0) except: self.show_error( _("Could not start Barcode Scanner.") + " " + _("Please install the Barcode Scanner app from ZXing") )
def isWiFiConnected(): mContext = autoclass('android.content.Context') pythonActivity = autoclass('org.renpy.android.PythonService') connectivityManager = autoclass('android.net.ConnectivityManager') cManager = cast('android.net.ConnectivityManager', pythonActivity.mService.getSystemService(mContext.CONNECTIVITY_SERVICE)) networkInfo = cManager.getNetworkInfo(connectivityManager.TYPE_WIFI) return networkInfo.isConnected()