def main(): parser = argparse.ArgumentParser(description='carbon read from obs manifest') parser.add_argument('-c', '--carbon-sdk-path', type=str, default=DEFAULT_CARBONSDK_PATH, help='carbon sdk path') parser.add_argument('-ak', '--access_key', type=str, required=True, help='access_key of obs') parser.add_argument('-sk', '--secret_key', type=str, required=True, help='secret_key of obs') parser.add_argument('-endpoint', '--end_point', type=str, required=True, help='end_point of obs') args = parser.parse_args() jnius_config.set_classpath(args.carbon_sdk_path) jnius_config.add_options('-Xrs', '-Xmx6096m') print("Start") start = time.time() path = "s3a://manifest/carbon/manifestcarbon/obsbinary1557717977531.manifest" just_read_batch_obs(path, args.access_key, args.secret_key, args.end_point) just_unified_read_batch_obs(path, args.access_key, args.secret_key, args.end_point) end = time.time() print("all time: " + str(end - start)) print("Finish")
def run_macro(macro, *args, ij_path=None, plugins_dir=None): import jnius_config if not ij_path: logger.info("using built-in ImageJ distribution") cwd = os.path.dirname(__file__) ij_path = os.path.join(cwd, 'ImageJ', 'ij.jar') if not os.path.exists(ij_path): raise RuntimeError("unable to locate built-in ImageJ distribution") if not plugins_dir: ij_root = os.path.dirname(ij_path) plugins_dir = os.path.join(ij_root, 'plugins') jnius_config.set_options('-Dplugins.dir={}'.format(plugins_dir)) jnius_config.set_classpath(ij_path) # NOTE use jnius_config before import jnius import jnius String = jnius.autoclass('java.lang.String') macro = String(macro) # wrap input arguments if args: args = ','.join([str(arg) for arg in args]) else: args = '' args = String(args) # run it MacroRunner = jnius.autoclass('ij.macro.MacroRunner') macro = MacroRunner(macro, args) macro.run()
def main(): parser = argparse.ArgumentParser(description='Tensorflow hello world') parser.add_argument('-c', '--carbon-sdk-path', type=str, default=DEFAULT_CARBONSDK_PATH, help='carbon sdk path') parser.add_argument('-ak', '--access_key', type=str, required=True, help='access_key of obs') parser.add_argument('-sk', '--secret_key', type=str, required=True, help='secret_key of obs') parser.add_argument('-endpoint', '--end_point', type=str, required=True, help='end_point of obs') args = parser.parse_args() jnius_config.set_classpath(args.carbon_sdk_path) jnius_config.add_options('-Xrs', '-Xmx6096m') # jnius_config.add_options('-Xrs', '-Xmx6096m', '-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5555') print("Start") start = time.time() just_read_batch_obs(key=args.access_key, secret=args.secret_key, endpoint=args.end_point) just_unified_read_batch_obs(key=args.access_key, secret=args.secret_key, endpoint=args.end_point) shutil.rmtree('/tmp/download/') end = time.time() print("all time: " + str(end - start)) print("Finish")
def initialize(self): # we need to delay the initialization of Java in order for this class to # properly work with multiprocessing if not OpenNLPSentenceTokenizer._java_initialized: import jnius_config jnius_config.add_options("-Xrs") jnius_config.set_classpath( pkg_resources.resource_filename( __name__, "/resources/opennlp-tools-1.5.3.jar")) OpenNLPSentenceTokenizer._java_initialized = True from jnius import autoclass File = autoclass("java.io.File") SentenceModel = autoclass("opennlp.tools.sentdetect.SentenceModel") SentenceDetectorME = autoclass( "opennlp.tools.sentdetect.SentenceDetectorME") sentence_model_file = pkg_resources.resource_filename( __name__, "resources/en-sent.bin") sentence_model = SentenceModel(File(sentence_model_file)) self._tokenizer = SentenceDetectorME(sentence_model) self._initialized = True
def test_set_classpath(self): assert jnius_config.vm_running is False assert jnius_config.classpath is None jnius_config.set_classpath(".") assert jnius_config.classpath == ["."] jnius_config.set_classpath(".", "/usr/local/fem/plugins/*") assert jnius_config.classpath == [".", "/usr/local/fem/plugins/*"]
def main(): parser = argparse.ArgumentParser(description='Tensorflow hello world') parser.add_argument('-c', '--carbon-sdk-path', type=str, default=DEFAULT_CARBONSDK_PATH, help='carbon sdk path') args = parser.parse_args() jnius_config.set_classpath(args.carbon_sdk_path) jnius_config.add_options('-Xrs', '-Xmx6096m') # jnius_config.add_options('-Xrs', '-Xmx6096m', '-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5555') print("Start") start = time.time() key = "OF0FTHGASIHDTRYHBCWU" secret = "fWWjJwh89NFaMDPrFdhu68Umus4vftlIzcNuXvwV" endpoint = "http://obs.cn-north-5.myhuaweicloud.com" just_read_batch_obs(key, secret, endpoint, 'modelarts-carbon', 'imageNet_resize/imageNet_whole_resize_small1', '/tmp/download/') shutil.rmtree('/tmp/download/') end = time.time() print("all time: " + str(end - start)) print("Finish")
def loadLibrary(): ''' Loads Siddi Library :return: ''' siddhi_home = os.getenv("SIDDHISDK_HOME") # Test whether Java Library is already loaded if "siddhi_api_configured" in globals(): if globals()["siddhi_api_configured"] != 4: raise Exception( "Unable to use multiple versions of Siddhi Library") # Resume global variables if already loaded _resumeLibrary() return # Add Java library to class path of jvm import jnius_config # NOTE: The following code-line is required on Linux Kernel 4.4.0-81-generic and above to avoid segmentation fault # at initialization of pyjnius jnius_config.add_options('-Xss1280k') jnius_config.add_options('-Djava.library.path=' + PySiddhi.root_path + "/__PySiddhiProxy") # Determine library class path class_paths = ['.', os.path.join(siddhi_home, 'lib', '*')] # Add Extensions if not "extensions" in globals(): global extensions extensions = [] for extension in extensions: class_paths.append(extension) jnius_config.set_classpath(*(tuple(class_paths))) # Mark API configured global siddhi_api_configured siddhi_api_configured = 4 logging.info("Classpath Configured") # Load Pyjnius (Starts JVM) from jnius import autoclass, java_method, PythonJavaClass, JavaClass # Generate references and store in backup global t_siddhi_api_core, t_siddhi_api_core_inst, t_java_method, t_PythonJavaClass, t_JavaClass t_siddhi_api_core = autoclass( "io.siddhi.pythonapi.proxy.core.SiddhiAPICoreProxy") t_siddhi_api_core_inst = t_siddhi_api_core(sys.version_info[0], sys.version_info[1]) t_java_method = java_method t_PythonJavaClass = PythonJavaClass t_JavaClass = JavaClass # Resume references stored in backup _resumeLibrary()
def __init__(self, config): print(config['Flask']['anserini_jar']) jnius_config.set_classpath(config['Flask']['anserini_jar']) from jnius import autoclass self.JString = autoclass('java.lang.String') self.JSearcher = autoclass('io.anserini.search.SimpleSearcher') self.searcher = self.JSearcher(self.JString(config['Flask']['index'])) self.nlp = spacy.load('en_core_web_sm')
def __init__(self): """ Virtually private constructor. """ if PySats.__instance is not None: raise Exception("This class is a singleton!") else: import jnius_config jnius_config.set_classpath('.', os.path.join('lib', '*')) PySats.__instance = self
def __init__(self, location: str = JAR_LOCATION): if path.isfile(location) is False: download_kolmafia(location) jnius_config.set_classpath(location) from jnius import autoclass self.autoclass = autoclass
def main(): print("Start") start = time.time() # Training settings parser = argparse.ArgumentParser( description='Pycarbon Tensorflow External MNIST Example') default_dataset_url = 'file://{}'.format('../../data/') parser.add_argument( '--train_dataset-url', type=str, default=default_dataset_url + "mnistcarbonTrain.manifest", metavar='S', help='hdfs:// or file:/// URL to the MNIST pycarbon dataset' '(default: %s)' % default_dataset_url) parser.add_argument( '--test_dataset-url', type=str, default=default_dataset_url + "mnistcarbonTest.manifest", metavar='S', help='hdfs:// or file:/// URL to the MNIST pycarbon dataset' '(default: %s)' % default_dataset_url) parser.add_argument('--num-epochs', type=int, default=1, metavar='N', help='number of epochs to train (default: 1)') parser.add_argument('--batch-size', type=int, default=100, metavar='N', help='input batch size for training (default: 100)') parser.add_argument( '--evaluation-interval', type=int, default=10, metavar='N', help= 'how many batches to wait before evaluating the model accuracy (default: 10)' ) parser.add_argument('--carbon-sdk-path', type=str, default=DEFAULT_CARBONSDK_PATH, help='carbon sdk path') args = parser.parse_args() jnius_config.set_classpath(args.carbon_sdk_path) train_and_test(train_dataset_url=args.train_dataset_url, test_dataset_url=args.test_dataset_url, num_epochs=args.num_epochs, batch_size=args.batch_size, evaluation_interval=args.evaluation_interval) end = time.time() print("all time: " + str(end - start)) print("Finish")
def init_java(): global java_initialized if not java_initialized: import jnius_config jnius_config.set_classpath( pkg_resources.resource_filename( 'ntee.utils', '/resources/opennlp-tools-1.5.3.jar'), ) java_initialized = True
def SETUP(anserini_repo_dir): """Anserini must be built, and JAVA_HOME properly set, before calling this.""" import sys sys.stderr.write(f'Initializing jnius from {anserini_repo_dir}\n') jnius_config.set_classpath( os.path.join(anserini_repo_dir, "target/anserini-0.3.1-SNAPSHOT-fatjar.jar")) from jnius import autoclass for t in _J._types: setattr(_J, t.split('.')[-1], autoclass(t))
def _get_jnius(): import jnius_config jnius_config.add_options( '-ea', '-Xrs', '-Xmx256M', '-Dlogback.configurationFile=logback-tools.xml', ) jnius_config.set_classpath(*get_cassandra_classpath()) import jnius return jnius
def load_class(*options, cls: str = CLASS_PATH): import jnius_config for option in options: jnius_config.add_options(option) jnius_config.set_classpath(cls) from jnius import autoclass Vocabulary = autoclass('corenlp.rdrsegmenter.Vocabulary') WordSegmenter = autoclass('corenlp.rdrsegmenter.WordSegmenter') return Vocabulary, WordSegmenter
def setClasspath(self, *paths): """ Sets the classpath for the JVM to use. Replaces any existing classpath, overriding the CLASSPATH environment variable. :type paths: list """ super().setClasspath(*paths) try: jnius_config.set_classpath(*paths) except ValueError as e: raise JVMError(e)
def __init__(self, **kwargs): self.root = kwargs['root'] self.version = kwargs['version'] import jnius_config jnius_config.add_options('-Xmx2g') jnius_config.set_classpath('{0}/lib/btrbl-je-{1}.jar'.format(self.root, self.version), '{0}/lib/slf4j-api-1.7.5.jar'.format(self.root), '{0}/lib/slf4j-simple-1.7.5.jar'.format(self.root)) from jnius import autoclass self.BaseLinguisticsFactory = autoclass('com.basistech.rosette.bl.BaseLinguisticsFactory') self.Annotator = autoclass('com.basistech.rosette.dm.Annotator') self.BaseLinguisticsOption = autoclass('com.basistech.rosette.bl.BaseLinguisticsOption') self.EnumMap = autoclass('java.util.EnumMap') self.String = autoclass('java.lang.String')
def configure_classpath(anserini_root="."): """ Parameters ---------- anserini_root : str (Optional) path to root anserini directory. """ paths = glob.glob(os.path.join(anserini_root, 'anserini-*-fatjar.jar')) if not paths: raise Exception('No matching jar file found in {}'.format(os.path.abspath(anserini_root))) latest = max(paths, key=os.path.getctime) jnius_config.set_classpath(latest)
def __init__(self, anserini_path): paths = glob.glob( os.path.join(anserini_path, 'target', 'anserini-*-fatjar.jar')) if not paths: raise Exception( 'No matching jar file for Anserini found in target') latest = max(paths, key=os.path.getctime) jnius_config.set_classpath(latest) from jnius import autoclass self.JString = autoclass('java.lang.String') self.JSearcher = autoclass('io.anserini.search.SimpleSearcher') self.qidx = 1 self.didx = 1
def lucene_doc_extractor(path): import jnius_config if not os.path.exists('bin/anserini.jar'): sys.stderr.write('missing bin/anserini.jar') sys.exit(1) jnius_config.set_classpath("bin/anserini.jar") from jnius import autoclass index_utils = autoclass('io.anserini.index.IndexUtils')(path) def wrapped(docid): lucene_doc_id = index_utils.convertDocidToLuceneDocid(docid) if lucene_doc_id == -1: return None # not found return index_utils.getTransformedDocument(docid) return wrapped
def init_pyjnius(): if not jnius_config.vm_running: if "JAVA_HOME" not in os.environ: logger.info("'JAVA_HOME' environment variable missing, " "trying to get from settings.py") os.environ["JAVA_HOME"] = settings.JAVA_HOME logger.info("JAVA_HOME set to '{}'".format(os.environ["JAVA_HOME"])) BASE_DIR = os.path.dirname(os.path.abspath(__file__)) jnius_config.add_options('-Djava.awt.headless=true') jnius_config.add_options('-Xmx1536m') jnius_config.set_classpath( os.path.join(BASE_DIR, "simccs", "lib", "simccs-app-1.0-jar-with-dependencies.jar")) logger.info("Initialized jnius with classpath={}".format( jnius_config.get_classpath())) import jnius # noqa
def __init__(self, **kwargs): self.root = kwargs['root'] self.version = kwargs['version'] import jnius_config jnius_config.add_options('-Xmx2g') jnius_config.set_classpath( '{0}/lib/btrbl-je-{1}.jar'.format(self.root, self.version), '{0}/lib/slf4j-api-1.7.5.jar'.format(self.root), '{0}/lib/slf4j-simple-1.7.5.jar'.format(self.root)) from jnius import autoclass self.BaseLinguisticsFactory = autoclass( 'com.basistech.rosette.bl.BaseLinguisticsFactory') self.Annotator = autoclass('com.basistech.rosette.dm.Annotator') self.BaseLinguisticsOption = autoclass( 'com.basistech.rosette.bl.BaseLinguisticsOption') self.EnumMap = autoclass('java.util.EnumMap') self.String = autoclass('java.lang.String')
def configure_classpath(source_root): """Add the latest FlexNeuART jar to the path. This function is based on Pyserini code https://github.com/castorini/pyserini :param source_root: source root """ from jnius_config import set_classpath paths = glob.glob(os.path.join(source_root, 'FlexNeuART-*-fatjar.jar')) if not paths: raise Exception('No matching jar file found in {}'.format( os.path.abspath(source_root))) latest = max(paths, key=os.path.getctime) set_classpath(latest)
def initialize(self): if self._autoclass is not None: logger.debug('jnius already initialized') return with logger.duration('initializing jnius'): log_fifo, l4j12_file, l4j24_file = self._init_java_logger_interface( ) import jnius_config jnius_config.set_classpath(*self._jars, os.path.dirname(l4j12_file)) jnius_config.add_options(f'-Dlog4j.configuration={l4j12_file}') jnius_config.add_options(f'-Dlog4j.configurationFile={l4j24_file}') from jnius import autoclass self._autoclass = autoclass # self.PropertyConfigurator.configure(l4j12_file) for key, path in self._defs.items(): self._cache[key] = self._autoclass(path)
def install(*options, jar_path: str = CLASS_PATH): if not os.path.exists(MODEL_DIR): import urllib.request from io import BytesIO from zipfile import ZipFile url = 'https://github.com/NgHoangDat/python_vncorenlp/raw/master/python_vncorenlp/data/models.zip' response = urllib.request.urlopen(url) data = BytesIO(response.read()) with ZipFile(data) as f: f.extractall(DATA_DIR) import jnius_config for option in options: jnius_config.add_options(option) jnius_config.set_classpath(jar_path)
def get_tagger(): global _tagger if _tagger is None: import jnius_config import os os.environ['JAVA_HOME'] = configuration.java_home jnius_config.add_options('-Xrs', '-Xmx128M') jnius_config.set_classpath(os.path.abspath(os.path.join(os.path.dirname(__file__), '../lib/ark-tweet-nlp-0.3.2/ark-tweet-nlp-0.3.2.jar'))) from jnius import autoclass _Tagger = autoclass('cmu.arktweetnlp.Tagger') _tagger=_Tagger() _tagger.loadModel('/cmu/arktweetnlp/model.20120919') return _tagger
def main(): parser = argparse.ArgumentParser(description='Tensorflow hello world') parser.add_argument('-c', '--carbon-sdk-path', type=str, default=DEFAULT_CARBONSDK_PATH, help='carbon sdk path') args = parser.parse_args() jnius_config.set_classpath(args.carbon_sdk_path) jnius_config.add_options('-Xrs', '-Xmx6096m') # jnius_config.add_options('-Xrs', '-Xmx6096m', '-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5555') print("Start") start = time.time() just_read() # just_read_batch() end = time.time() print("all time: " + str(end - start)) print("Finish")
def __init__(self, archive_path, cuda_device, overrides, weights_file, lookup_path, wordnet_path, am_tools_path): jnius_config.set_classpath(".", am_tools_path) # Load model archive = load_archive(archive_path, cuda_device, overrides, weights_file) config = archive.config config.formalism = "DUMMY" prepare_environment(config) model = archive.model model.eval() dataset_reader = DatasetReader.from_params( config.pop('dataset_reader')) self.predictor = AMconllPredictor(dataset_reader, k=6, give_up=0, threads=1, model=model) self.formalism = AMRInterface(lookup_path, wordnet_path)
def main(): print("Running testsuite", "\n", file=sys.stderr) sys.modules["jnius_config"] = importlib.import_module("jt.jnius_config") import jnius_config jnius_config.set_classpath(os.path.join(test_dir, "java-classes")) sys.modules["jnius"] = importlib.import_module("jt.jnius") sys.modules["jnius.reflect"] = importlib.import_module("jt.jnius.reflect") sys.modules["jnius.signatures"] = importlib.import_module( "jt.jnius.signatures") try: tests = test_suite(sys.argv[1:] or None) result = unittest.TextTestRunner(verbosity=2).run(tests) finally: from jt.jnius._jvm import JVM from jt.jnius._platform import stop_jvm stop_jvm(JVM.jvm) sys.exit(0 if result.wasSuccessful() else 1)
def init(config): # Validate the JARs folder # Path is relative to the current working directory if not os.path.isdir('./java_libs/'): raise Exception("Java library path could not be located.") # Construct classpath for JVM import jnius_config jnius_config.add_options('-Xrs', '-Xmx4m') # JVM options in comma separated jnius_config.set_classpath( './java_libs/*') # Path for the Java library import jnius # Build Payment Method Token Recipient Builder = jnius.autoclass( 'com.google.crypto.tink.apps.paymentmethodtoken.PaymentMethodTokenRecipient$Builder' ) builder = Builder() builder.addSenderVerifyingKey(config['GoogleSigningKey']) builder.recipientId(config['RecipientId']) builder.protocolVersion(config['ProtocolVersion']) builder.addRecipientPrivateKey(config['RecipientPrivateKey']) Decryptor.paymentMethodTokenRecipient = builder.build()
def main(): parser = argparse.ArgumentParser( description='Support read carbon by manifest path in python code') parser.add_argument('-c', '--carbon-sdk-path', type=str, default=DEFAULT_CARBONSDK_PATH, help='carbon sdk path') args = parser.parse_args() jnius_config.set_classpath(args.carbon_sdk_path) jnius_config.add_options('-Xrs', '-Xmx6096m') print("Start") start = time.time() just_read_batch() just_unified_read_batch() end = time.time() print("all time: " + str(end - start)) print("Finish")
import torch import pytest import examples.mnist.pycarbon_dataset.pytorch_example_carbon as pytorch_example from examples.mnist.pycarbon_dataset.generate_pycarbon_mnist import mnist_data_to_pycarbon_dataset, download_mnist_data from examples.mnist.pycarbon_dataset.tests.conftest import SMALL_MOCK_IMAGE_COUNT from petastorm import TransformSpec from pycarbon.carbon_reader import make_carbon_reader import jnius_config jnius_config.set_classpath(pytest.config.getoption("--carbon-sdk-path")) if pytest.config.getoption("--pyspark-python") is not None and \ pytest.config.getoption("--pyspark-driver-python") is not None: os.environ['PYSPARK_PYTHON'] = pytest.config.getoption("--pyspark-python") os.environ['PYSPARK_DRIVER_PYTHON'] = pytest.config.getoption( "--pyspark-driver-python") elif 'PYSPARK_PYTHON' in os.environ.keys( ) and 'PYSPARK_DRIVER_PYTHON' in os.environ.keys(): pass else: raise ValueError( "please set PYSPARK_PYTHON and PYSPARK_DRIVER_PYTHON variables, " "using cmd line --pyspark-python=PYSPARK_PYTHON_PATH --pyspark-driver-python=PYSPARK_DRIVER_PYTHON_PATH, " "or set PYSPARK_PYTHON and PYSPARK_DRIVER_PYTHON in system env")
#################################################### # This is used by annotations to stream to a running instance # of LogStreamManager # # Needs the packages in requirements.txt # either install the packages manually or do the following: # * [highly recommended] setup a virtual environment via virtualenv # * then run # pip install -r requirements.txt # # You also need to compile Wrapper.java with the following line # from the sample directory (crappy solution) # javac -cp ../../../build/classes/main:jars/gson.jar:jars/jgroups.jar:. Wrapper.java #################################################### w = None try: import jnius_config import system print system.path jnius_config.set_classpath('.','jars/gson.jar','jars/jgroups.jar','../../../build/classes/main') from jnius import autoclass Wrapper = autoclass('Wrapper') w = Wrapper() except ImportError as e: print "Missing Requirements for using wrapper.py:" print "\t%s" % e print "Not using LogStreamManager" ####################################################
# __author__ = 'WeiFu' from __future__ import print_function, division import jnius_config jnius_config.add_options('-Xrs', '-Xmx4096') jnius_config.set_classpath('.', '/Users/WeiFu/Github/HDP_Jython/jar/weka.jar','/Users/WeiFu/Github/HDP_Jython/jar/commons-math3-3.5/commons-math3-3.5.jar') import pdb import random from os import listdir from os.path import isfile, join from jnius import autoclass # # # # # # # import weka.core.Instances # import java.io.BufferedReader # import java.io.FileReader # import weka.attributeSelection.Ranker as Ranker # import weka.attributeSelection.ReliefFAttributeEval as ReliefFAttributeEval # import weka.attributeSelection.AttributeSelection as attributeSelection # import weka.classifiers.functions.Logistic as Logistic # import weka.classifiers.Evaluation as Evaluation # import weka.core.converters.ArffSaver as Saver # import weka.filters.unsupervised.attribute.Remove as Remove # import weka.filters.unsupervised.instance.Randomize as Randomize # import weka.filters.unsupervised.instance.RemoveFolds as RemoveFolds # import weka.core.jvm as jvm
if WIN32: path = os.getenv('Path', '') path = path.split(os.pathsep) path.insert(0, os.path.join(os.environ['JAVA_HOME'], 'bin', 'client')) os.environ['Path'] = os.pathsep.join(path) classpath = [] resources = expandPath('@resources/lib/') for name in os.listdir(resources): path = os.path.join(resources, name) if os.path.isfile(path): classpath.append(path) jnius_config.add_options('-ea', '-Xmx512m') jnius_config.set_classpath(*classpath) ############################################# # END JAVA VIRTUAL MACHINE SETUP ################################# from argparse import ArgumentParser from unittest import TestCase from unittest.util import safe_repr from PyQt5 import QtCore from PyQt5 import QtTest from eddy import APPNAME, ORGANIZATION, WORKSPACE from eddy.core.application import Eddy from eddy.ui import fonts_rc
import jnius_config jnius_config.set_classpath('./tuxguitar-lib-1.3.2.jar') from jnius import autoclass TGSongManager = autoclass('org.herac.tuxguitar.song.managers.TGSongManager') TGOutputStream = autoclass('org.herac.tuxguitar.io.tg.TGOutputStream') TGInputStream = autoclass('org.herac.tuxguitar.io.tg.TGInputStream') FileOutputStream = autoclass('java.io.FileOutputStream') FileInputStream = autoclass('java.io.FileInputStream') BufferedInputStream = autoclass('java.io.BufferedInputStream') BufferedOutputStream = autoclass('java.io.BufferedOutputStream') File = autoclass('java.io.File') song_man = TGSongManager() meas_man = song_man.getMeasureManager() track_man = song_man.getTrackManager() factory = song_man.getFactory() song = song_man.newSong() measure = track_man.getFirstMeasure(song.getTrack(0)) inp = TGInputStream() inp.init(song_man.getFactory(), BufferedInputStream(FileInputStream(File('Untitled.tg')))) song2 = inp.readSong() measure2 = track_man.getFirstMeasure(song2.getTrack(0)) beat2 = meas_man.getFirstBeat(measure2.getBeats()) print beat2.getVoice(0).getNote(0).getVelocity() beat = beat2.clone(song_man.getFactory())
from django.shortcuts import render,redirect from django.http import HttpResponse import jnius_config, os.path current_dir = os.path.join(os.path.dirname(__file__)) jnius_config.set_classpath(current_dir + '/java/*') from jnius import cast, autoclass, JavaException from .models import Ontology,Entity # Create your views here. def index(request): ontologies = Ontology.objects.all() return render(request, 'ontology/index.html', {'ontologies': ontologies}) def classify(request): ontology = None if 'entity_name' in request.POST: ontology = save_entity(request) elif 'new_owner' in request.POST and request.POST['new_owner'] != "": owner = request.POST['new_owner'] ontology, created = Ontology.objects.get_or_create(owner=owner) elif 'selected' in request.POST: owner = request.POST['selected'] ontology = Ontology.objects.get(owner=owner) else: return redirect('index') # import any new entities