Example #1
0
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")
Example #2
0
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()
Example #3
0
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/*"]
Example #6
0
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")
Example #7
0
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()
Example #8
0
 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')
Example #9
0
 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
Example #10
0
    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")
Example #12
0
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
Example #13
0
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))
Example #14
0
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
Example #15
0
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
Example #16
0
        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)
Example #17
0
 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')
Example #18
0
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)
Example #19
0
    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
Example #20
0
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
Example #21
0
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
Example #22
0
 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')
Example #23
0
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)
Example #24
0
 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)
Example #25
0
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)
Example #26
0
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")
Example #28
0
    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)
Example #29
0
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)
Example #30
0
    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()
Example #31
0
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")
Example #33
0
####################################################
# 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"
####################################################
Example #34
0
# __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
Example #35
0
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
Example #36
0
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())
Example #37
0
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