Пример #1
1
		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
Пример #2
1
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()
Пример #3
1
 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()
Пример #4
1
    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())
Пример #5
0
    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()
Пример #6
0
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
Пример #7
0
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
Пример #9
0
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)
Пример #10
0
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
Пример #11
0
 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)
Пример #12
0
 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)
Пример #13
0
	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
Пример #14
0
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)
Пример #15
0
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])
Пример #16
0
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)
Пример #17
0
 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
Пример #20
0
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)
Пример #22
0
 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
Пример #23
0
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')
Пример #24
0
def test_newinstance():
    Parent = autoclass('org.jnius.Parent')
    Child = autoclass('org.jnius.Child')

    child = Child.newInstance()

    assert isinstance(child, Child)
    assert isinstance(child, Parent)
Пример #25
0
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})
Пример #26
0
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
Пример #27
0
 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?")
Пример #28
0
 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()
Пример #29
0
    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
Пример #30
0
def _get_class(qualified_name):
    from jnius import autoclass
    return autoclass(qualified_name)
Пример #31
0
################################################################################


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')
Пример #32
0
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()
Пример #33
0
* 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
Пример #34
0
 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:
Пример #36
0
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)
Пример #37
0
    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
Пример #38
0
# 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()
Пример #39
0
'''
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
Пример #40
0
    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
Пример #41
0
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
Пример #42
0
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(
Пример #43
0
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()
Пример #44
0
def android_ext_dir():
    import jnius
    env = jnius.autoclass('android.os.Environment')
    return env.getExternalStorageDirectory().getPath()
Пример #45
0
 def back_button_leave_app(self):
     if platform != 'android':
         return
     from jnius import autoclass
     activity = autoclass('org.kivy.android.PythonActivity')
     activity.moveTaskToBack(True)
Пример #46
0
def android_data_dir():
    import jnius
    PythonActivity = jnius.autoclass('org.kivy.android.PythonActivity')
    return PythonActivity.mActivity.getFilesDir().getPath() + '/data'
Пример #47
0
#!/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)
Пример #48
0
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)
Пример #49
0
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):
Пример #50
0
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])
Пример #51
0
    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.
Пример #52
0
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

Пример #53
0
    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
Пример #54
0
#!/usr/bin/env python

from jnius import autoclass

TestIO = autoclass('hdfsio.TestIO')
TestIO.writeHDFS()
Пример #55
0
def version():
    """
        Returns the version string from the underlying Terrier platform.
    """
    from jnius import autoclass
    return autoclass("org.terrier.Version").VERSION
Пример #56
0
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
Пример #57
0
    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
Пример #58
0
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')
Пример #59
-1
    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")
            )
Пример #60
-1
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()