Example #1
0
def load_backends():
    backends = []
    configured_backends = getattr(settings, "NOTIFICATION_BACKENDS", default_backends)
    for medium_id, bits in enumerate(configured_backends):
        if len(bits) == 2:
            label, backend_path = bits
            spam_sensitivity = None
        elif len(bits) == 3:
            label, backend_path, spam_sensitivity = bits
        else:
            raise exceptions.ImproperlyConfigured(
                "NOTIFICATION_BACKENDS does not contain enough data."
            )
        dot = backend_path.rindex(".")
        backend_mod, backend_class = backend_path[:dot], backend_path[dot + 1:]
        try:
            # import the module and get the module from sys.modules
            __import__(backend_mod)
            mod = sys.modules[backend_mod]
        except ImportError as e:
            raise exceptions.ImproperlyConfigured(
                "Error importing notification backend {}: \"{}\"".format(backend_mod, e)
            )
        # add the backend label and an instantiated backend class to the
        # backends list.
        backend_instance = getattr(mod, backend_class)(medium_id, spam_sensitivity)
        backends.append(((medium_id, label), backend_instance))
    return dict(backends)
    def _import_transporter(self, transporter):
        """Imports transporter module and class, returns class.
        Input value can be:
        * a full/absolute module path, like
          "MyTransporterPackage.SomeTransporterClass"
        """
        transporter_class = None
        module = None
        alternatives = []
        default_prefix = 'cloud_sync_app.transporter.transporter_'
        if not transporter.startswith(default_prefix):
            alternatives.append('%s%s' % (default_prefix, transporter))
        for module_name in alternatives:
            try:
                module = __import__(module_name, globals(), locals(), ["TRANSPORTER_CLASS"], -1)
            except ImportError:
                import traceback
                traceback.print_exc()
                pass

        if not module:
            msg = "The transporter module '%s' could not be found." % transporter
            if len(alternatives) > 1:
                msg = '%s Tried (%s)' % (msg, ', '.join(alternatives))
            self.logger.error(msg)
        else:
            try:
                classname = module.TRANSPORTER_CLASS
                module = __import__(module_name, globals(), locals(), [classname])
                transporter_class = getattr(module, classname)
            except AttributeError:
                self.logger.error("The Transporter module '%s' was found, but its Transporter class '%s' could not be found." % (module_name, classname))
        return transporter_class
Example #3
0
File: run.py Project: dbrgn/jedi
def test_dir(completion_test_dir, thirdparty=False):
    global tests_fail
    for f_name in os.listdir(completion_test_dir):
        files_to_execute = [a for a in test_files.items() if a[0] in f_name]
        lines_to_execute = reduce(lambda x, y: x + y[1], files_to_execute, [])
        if f_name.endswith(".py") and (not test_files or files_to_execute):
            # for python2.5 certain tests are not being done, because it
            # only has these features partially.
            if is_py25 and f_name in ['generators.py', 'types.py']:
                continue

            if thirdparty:
                try:
                    # there is always an underline at the end.
                    # It looks like: completion/thirdparty/pylab_.py
                    __import__(f_name.replace('_.py', ''))
                except ImportError:
                    summary.append('Thirdparty-Library %s not found.' %
                                                                    f_name)
                    continue

            path = os.path.join(completion_test_dir, f_name)
            f = open(path)
            num_tests, fails = run_test(f.read(), f_name, lines_to_execute)
            global test_sum
            test_sum += num_tests

            s = 'run %s tests with %s fails (%s)' % (num_tests, fails, f_name)
            tests_fail += fails
            print(s)
            summary.append(s)
Example #4
0
    def init_func(self, creator_fd, raw_socket_fd, tun_fd, cs, caddr, debug=True):
        self.__debug = debug
        self.__caddr = caddr

        name = "freenet.lib.crypto.%s" % fns_config.configs["tcp_crypto_module"]["name"]
        __import__(name)

        crypto = sys.modules[name]

        args = fns_config.configs["tcp_crypto_module"]["args"]

        self.__encrypt = crypto.encrypt(*args)
        self.__decrypt = crypto.decrypt(*args)
        self.__creator_fd = creator_fd
        self.__traffic_send_fd = raw_socket_fd
        self.__vlan_ips = []
        self.__udp_natp_to_fd = {}
        self.__tun_fd = tun_fd

        self.set_socket(cs)

        self.register(self.fileno)
        self.add_evt_read(self.fileno)

        self.set_timeout(self.fileno, self.__TIMEOUT_NO_AUTH)
        self.print_access_log("connect")

        return self.fileno
Example #5
0
    def wrap(f):
        if modules:
            # attach import to function
            setattr(f, 'imports', modules)
            for alternatives in modules:
                # alternatives are comma seperated
                alternatives = alternatives.split(',')
                # we import the part of the import X.Y.Z -> Z
                mod_name = alternatives[0].split('.')[-1]
                for mod in alternatives:
                    mod = mod.strip().split('.')

                    try:
                        if len(mod) == 1:
                            module = __import__(mod[0])
                        else:
                            module = getattr(__import__('.'.join(mod[:-1]), \
                                            fromlist=[mod[-1]]), mod[-1])
                        f.func_globals[mod_name] = module
                        break # import only one
                    except ImportError:
                        pass
                else:
                    if forgive: # no break -> no import
                        warnings.warn('Failed to import %s' % alternatives)
                    else:
                        raise ImportError('Failed to import %s' % alternatives)
        return f
Example #6
0
    def cython_pyximport(self, line, cell):
        """Compile and import a Cython code cell using pyximport.

        The contents of the cell are written to a `.pyx` file in the current
        working directory, which is then imported using `pyximport`. This
        magic requires a module name to be passed::

            %%cython_pyximport modulename
            def f(x):
                return 2.0*x

        The compiled module is then imported and all of its symbols are
        injected into the user's namespace. For most purposes, we recommend
        the usage of the `%%cython` magic.
        """
        module_name = line.strip()
        if not module_name:
            raise ValueError('module name must be given')
        fname = module_name + '.pyx'
        with io.open(fname, 'w', encoding='utf-8') as f:
            f.write(cell)
        if 'pyximport' not in sys.modules:
            import pyximport
            pyximport.install(reload_support=True)
        if module_name in self._reloads:
            module = self._reloads[module_name]
            reload(module)
        else:
            __import__(module_name)
            module = sys.modules[module_name]
            self._reloads[module_name] = module
        self._import_all(module)
Example #7
0
def get_versions(module_list=None):
    if not module_list:
        return {}

    ext_module_list = set()
    for m in module_list:
        parts = m.split('.')
        ext_module_list.update('.'.join(parts[:idx])
                               for idx in range(1, len(parts) + 1))

    versions = {}
    for module_name in ext_module_list:
        if module_name not in _VERSION_CACHE:
            try:
                __import__(module_name)
            except ImportError:
                continue

            try:
                app = sys.modules[module_name]
            except KeyError:
                continue

            try:
                version = get_version_from_app(module_name, app)
            except Exception as e:
                logger.exception(e)
                version = None

            _VERSION_CACHE[module_name] = version
        else:
            version = _VERSION_CACHE[module_name]
        if version is not None:
            versions[module_name] = version
    return versions
Example #8
0
def import_object(import_str):
    """Returns an object including a module or module and class"""
    try:
        __import__(import_str)
        return sys.modules[import_str]
    except ImportError:
        return import_class(import_str)
Example #9
0
def load_module(module_name):
  """Imports a module given its name and returns a handle to it."""
  try:
    __import__(module_name)
  except ImportError:
    raise ImportError('No module named %s' % module_name)
  return sys.modules[module_name]
Example #10
0
def patch_thread(threading=True, _threading_local=True):
    """Replace the standard :mod:`thread` module to make it greenlet-based.
    If *threading* is true (the default), also patch ``threading.local``.
    If *_threading_local* is true (the default), also patch ``_threading_local.local``.
    """
    from gevent import thread as green_thread
    thread = __import__('thread')
    if thread.exit is not green_thread.exit:
        thread.get_ident = green_thread.get_ident
        thread.start_new_thread = green_thread.start_new_thread
        thread.LockType = green_thread.LockType
        thread.allocate_lock = green_thread.allocate_lock
        thread.exit = green_thread.exit
        if hasattr(green_thread, 'stack_size'):
            thread.stack_size = green_thread.stack_size
        from gevent.local import local
        thread._local = local
        if threading:
            if noisy and 'threading' in sys.modules:
                sys.stderr.write("gevent.monkey's warning: 'threading' is already imported\n\n")
            threading = __import__('threading')
            threading.local = local
        if _threading_local:
            _threading_local = __import__('_threading_local')
            _threading_local.local = local
Example #11
0
def module_exists(module_name):
    try:
        __import__(module_name)
    except ImportError:
        return False
    else:
        return True
Example #12
0
def init_app(app):
    # Load all core APIs
    import udata.core.spatial.api
    import udata.core.metrics.api
    import udata.core.user.api
    import udata.core.dataset.api
    import udata.core.issues.api
    import udata.core.discussions.api
    import udata.core.reuse.api
    import udata.core.organization.api
    import udata.core.followers.api
    import udata.core.jobs.api
    import udata.core.site.api
    import udata.core.tags.api
    import udata.core.topic.api
    import udata.core.post.api
    import udata.features.transfer.api

    # Load plugins API
    for plugin in app.config['PLUGINS']:
        name = 'udata.ext.{0}.api'.format(plugin)
        try:
            __import__(name)
        except ImportError:
            pass
        except Exception as e:
            log.error('Error importing %s: %s', name, e)

    # api.init_app(app)
    app.register_blueprint(apidoc)
    app.register_blueprint(apiv1)

    oauth2.init_app(app)
Example #13
0
def import_module(module_name):
    """
    Imports a module. A single point of truth for importing modules to
    be documented by `pdoc`. In particular, it makes sure that the top
    module in `module_name` can be imported by using only the paths in
    `pdoc.import_path`.

    If a module has already been imported, then its corresponding entry
    in `sys.modules` is returned. This means that modules that have
    changed on disk cannot be re-imported in the same process and have
    its documentation updated.
    """
    if import_path != sys.path:
        # Such a kludge. Only restrict imports if the `import_path` has
        # been changed. We don't want to always restrict imports, since
        # providing a path to `imp.find_module` stops it from searching
        # in special locations for built ins or frozen modules.
        #
        # The problem here is that this relies on the `sys.path` not being
        # independently changed since the initialization of this module.
        # If it is changed, then some packages may fail.
        #
        # Any other options available?

        # Raises an exception if the parent module cannot be imported.
        # This hopefully ensures that we only explicitly import modules
        # contained in `pdoc.import_path`.
        imp.find_module(module_name.split('.')[0], import_path)

    if module_name in sys.modules:
        return sys.modules[module_name]
    else:
        __import__(module_name)
        return sys.modules[module_name]
Example #14
0
    def load_plugins(cls, modules, config, debug=None):
        """Load plugins from `modules`.

        Returns a list of loaded and configured plugins.

        """
        plugins = cls()
        plugins.debug = debug

        for module in modules:
            plugins.current_module = module
            __import__(module)
            mod = sys.modules[module]

            coverage_init = getattr(mod, "coverage_init", None)
            if not coverage_init:
                raise CoverageException(
                    "Plugin module %r didn't define a coverage_init function" % module
                )

            options = config.get_plugin_options(module)
            coverage_init(plugins, options)

        plugins.current_module = None
        return plugins
Example #15
0
 def wrap(*args, **kwargs):
     __import__('time').sleep(seconds)
     try:
         result = target(*args, **kwargs)
     except:
         result = None
     return result
Example #16
0
def load_backend(backend_name=None):
    if not backend_name:
        backend_name = settings.HAYSTACK_SEARCH_ENGINE

    try:
        # Most of the time, the search backend will be one of the
        # backends that ships with haystack, so look there first.
        return __import__("haystack.backends.%s_backend" % backend_name, {}, {}, [""])
    except ImportError, e:
        # If the import failed, we might be looking for a search backend
        # distributed external to haystack. So we'll try that next.
        try:
            return __import__("%s_backend" % backend_name, {}, {}, [""])
        except ImportError, e_user:
            # The search backend wasn't found. Display a helpful error message
            # listing all possible (built-in) database backends.
            backend_dir = os.path.join(__path__[0], "backends")
            available_backends = [
                os.path.splitext(f)[0].split("_backend")[0]
                for f in os.listdir(backend_dir)
                if f != "base.py" and not f.startswith("_") and not f.startswith(".") and not f.endswith(".pyc")
            ]
            available_backends.sort()
            if backend_name not in available_backends:
                raise ImproperlyConfigured, "%r isn't an available search backend. Available options are: %s" % (
                    backend_name,
                    ", ".join(map(repr, available_backends)),
                )
            else:
                raise  # If there's some other error, this must be an error in Django itself.
Example #17
0
    def find_controller(self, controller):
        """Locates a controller by attempting to import it then grab
        the SomeController instance from the imported module.

        Override this to change how the controller object is found once
        the URL has been resolved.

        """
        # Check to see if we've cached the class instance for this name
        if controller in self.controller_classes:
            return self.controller_classes[controller]

        # Pull the controllers class name, import controller
        full_module_name = self.package_name + '.controllers.' \
            + controller.replace('/', '.')

        # Hide the traceback here if the import fails (bad syntax and such)
        __traceback_hide__ = 'before_and_this'

        __import__(full_module_name)
        if hasattr(sys.modules[full_module_name], '__controller__'):
            mycontroller = getattr(
                sys.modules[full_module_name],
                sys.modules[full_module_name].__controller__)
        else:
            module_name = controller.split('/')[-1]
            class_name = class_name_from_module_name(module_name) + \
                'Controller'
            if self.log_debug:
                log.debug("Found controller, module: '%s', class: '%s'",
                          full_module_name, class_name)
            mycontroller = getattr(sys.modules[full_module_name], class_name)
        self.controller_classes[controller] = mycontroller
        return mycontroller
Example #18
0
 def migrations_dir(self):
     """
     Returns the full path of the migrations directory.
     If it doesn't exist yet, returns where it would exist, based on the
     app's migrations module (defaults to app.migrations)
     """
     module_path = self.migrations_module()
     try:
         module = __import__(module_path, {}, {}, [''])
     except ImportError:
         # There's no migrations module made yet; guess!
         try:
             parent = __import__(".".join(module_path.split(".")[:-1]), {}, {}, [''])
         except ImportError:
             # The parent doesn't even exist, that's an issue.
             raise exceptions.InvalidMigrationModule(
                 application = self.application.__name__,
                 module = module_path,
             )
         else:
             # Good guess.
             return os.path.join(os.path.dirname(parent.__file__), module_path.split(".")[-1])
     else:
         # Get directory directly
         return os.path.dirname(module.__file__)
Example #19
0
File: imp.py Project: Shirk/SynFU
 def run(self):
     if self._show_help:
         # extra printout, --help-plugins disables _log()
         print('Installed jobs:')
     
     self._log('--- begin')
     self._log('--- loading plugins:')
     plugin_path = [os.path.join(os.path.dirname(os.path.abspath(__file__)),
                               'plugins'),
                    self._conf.plugin_dir]
     
     for p in plugin_path:
         if not os.path.exists(p):
             self._log('!!! skipping  "{0}" - no such file or directory'.format(p))
             continue
         
         sys.path.append(p)
         
         for (importer, name, ispkg) in pkgutil.walk_packages([p]):
             if name.startswith('ImpJob'):
                 try:
                     __import__(name)
                 except Exception, e:
                     self._log('!!! unable to import "{0}": {1}: {2}'.format(
                               name, e.__class__.__name__, e))
def load_plugins():
    with open(__config_file__, "r") as fh:
        for line in fh:
            line = line.strip()
            if line.startswith("#") or line == "":
                continue
            # just load the whole shit...
            try:
                __import__(pluginPath+"."+line,  globals(), locals(), [], -1)
            except NecessaryModuleNotFound as e:
                logger.critical("Failed loading plugin due to missing module: "+str(e))
            except ApiKeyNotFoundException as e:
                logger.critical("Failed loading plugin due to missing API key: "+str(e))
            except:
                logger.exception("Plugin loading failed")
            
    # as they are loaded in the order in the file we will have the same order in __subclasses__()... I hope

    for clazz in Plugin.__subclasses__():
        # look at all functions of a class lets filter them first
        methods = filter(lambda x: type(x) == FunctionType, clazz.__dict__.values())
        # now we check if the method is decorated by register
        for method in methods:
            if __criteria_key__ in method.__dict__:
                criterias = method.__dict__[__criteria_key__]
                for lang, regex in criterias.items():
                    if not lang in plugins:
                        plugins[lang] = []
                    # yeah... save the regex, the clazz and the method, shit just got loaded...
                    plugins[lang].append((regex, clazz, method))
Example #21
0
def app(root=None,
        redirect_to_fallback=True,
        fallback_url=None,
        password_file=None):
    import sys, os
    from pypiserver import core
    sys.modules.pop("pypiserver._app", None)
    __import__("pypiserver._app")
    _app = sys.modules["pypiserver._app"]

    import bottle

    if root is None:
        root = os.path.expanduser("~/packages")

    if fallback_url is None:
        fallback_url="http://pypi.python.org/simple"

    #os.listdir(root)
    _app.configure(root=root, redirect_to_fallback=redirect_to_fallback, fallback_url=fallback_url,
                   password_file=password_file)
    _app.app.module = _app

    bottle.debug(True)
    return _app.app
Example #22
0
def import_app(module):
    parts = module.split(":", 1)
    if len(parts) == 1:
        module, obj = module, "application"
    else:
        module, obj = parts[0], parts[1]

    try:
        __import__(module)
    except ImportError:
        if module.endswith(".py") and os.path.exists(module):
            raise ImportError("Failed to find application, did "
                "you mean '%s:%s'?" % (module.rsplit(".", 1)[0], obj))
        else:
            raise

    mod = sys.modules[module]

    try:
        app = eval(obj, mod.__dict__)
    except NameError:
        raise AppImportError("Failed to find application: %r" % module)

    if app is None:
        raise AppImportError("Failed to find application object: %r" % obj)

    return app
    def getargs(self,moduleName,className,method) :
        '''
          This will return the list of arguments in a method of python module of class.
          It accepts method list as an argument.
        '''
        print "Message : Argument list is being obtained for each method"
        methodArgsDict = {}
        if className == None:
            moduleList = moduleName.split(".")
            for index,name in enumerate(method) :
                Module = __import__(moduleList[len(moduleList) -1], globals(), locals(), [moduleList[len(moduleList) -2]], -1)
                try :
                    names = vars(Module)[name]
                except KeyError:
                    print "Message : method '" + name + "'does not exists,Continued with including it. "
                    return False
                argumentList = inspect.getargspec(names) #inspect.getargvalues(name)
                methodArgsDict[name] = argumentList[0]
        else :
            moduleList = moduleName.split(".")
            for index,name in enumerate(method) :
                Module = __import__(moduleList[len(moduleList) - 1], globals(), locals(), [className], -1)
                Class = getattr(Module, className)
                try :
                    names = vars(Class)[name]
                except KeyError :
                    print "Message : method '" + name + "'does not exists,Continued with include it."
                    return False

                argumentList = inspect.getargspec(names) #inspect.getargvalues(name)
                methodArgsDict[name] = argumentList[0]

        return methodArgsDict
Example #24
0
    def test_package_import__semantics(self):

        # Generate a couple of broken modules to try importing.

        # ...try loading the module when there's a SyntaxError
        self.rewrite_file('for')
        try: __import__(self.module_name)
        except SyntaxError: pass
        else: raise RuntimeError, 'Failed to induce SyntaxError'
        self.assertNotIn(self.module_name, sys.modules)
        self.assertFalse(hasattr(sys.modules[self.package_name], 'foo'))

        # ...make up a variable name that isn't bound in __builtins__
        var = 'a'
        while var in dir(__builtins__):
            var += random.choose(string.letters)

        # ...make a module that just contains that
        self.rewrite_file(var)

        try: __import__(self.module_name)
        except NameError: pass
        else: raise RuntimeError, 'Failed to induce NameError.'

        # ...now  change  the module  so  that  the NameError  doesn't
        # happen
        self.rewrite_file('%s = 1' % var)
        module = __import__(self.module_name).foo
        self.assertEqual(getattr(module, var), 1)
    def getmethods(self,modulePath,Class) :
        '''
         This will get the list of methods in given module or class.
         It accepts the module path and class name. If there is no
         class name then it has be mentioned as None.
        '''
        methodList = []
        moduleList = modulePath.split("/")
        newModule = ".".join([moduleList[len(moduleList) - 2],moduleList[len(moduleList) - 1]])
        print "Message : Method list is being obatined , Please wait ..."
        try :
            if Class :
                Module = __import__(moduleList[len(moduleList) - 1], globals(), locals(), [Class], -1)
                ClassList = [x.__name__ for x in Module.__dict__.values() if inspect.isclass(x)]
                self.ClassList = ClassList
                Class = vars(Module)[Class]
                methodList = [x.__name__ for x in Class.__dict__.values() if inspect.isfunction(x)]
            else :
                Module = __import__(moduleList[len(moduleList) - 1], globals(), locals(),[moduleList[len(moduleList) - 2]], -1)
                methodList = [x.__name__ for x in Module.__dict__.values() if inspect.isfunction(x)]
                ClassList = [x.__name__ for x in Module.__dict__.values() if inspect.isclass(x)]
                self.ClassList = ClassList
        except :
            print "Error : " +str(sys.exc_info()[1])


        self.method = methodList
        return self.method
Example #26
0
def import_backends():
    """
    Import files in the duplicity/backends directory where
    the filename ends in 'backend.py' and ignore the rest.

    @rtype: void
    @return: void
    """
    path = duplicity.backends.__path__[0]
    assert path.endswith("duplicity/backends"), duplicity.backends.__path__

    files = os.listdir(path)
    files.sort()
    for fn in files:
        if fn.endswith("backend.py"):
            fn = fn[:-3]
            imp = "duplicity.backends.%s" % (fn,)
            try:
                __import__(imp)
                res = "Succeeded"
            except Exception:
                res = "Failed: " + str(sys.exc_info()[1])
            log.Log(_("Import of %s %s") % (imp, res), log.INFO)
        else:
            continue
Example #27
0
def main(listener_fd, alive_r, preload, main_path=None, sys_path=None):
    '''Run forkserver.'''
    if preload:
        if '__main__' in preload and main_path is not None:
            process.current_process()._inheriting = True
            try:
                spawn.import_main_path(main_path)
            finally:
                del process.current_process()._inheriting
        for modname in preload:
            try:
                __import__(modname)
            except ImportError:
                pass

    util._close_stdin()

    # ignoring SIGCHLD means no need to reap zombie processes
    # letting SIGINT through avoids KeyboardInterrupt tracebacks
    handlers = {
        signal.SIGCHLD: signal.SIG_IGN,
        signal.SIGINT: signal.SIG_DFL,
        }
    old_handlers = {sig: signal.signal(sig, val)
                    for (sig, val) in handlers.items()}

    with socket.socket(socket.AF_UNIX, fileno=listener_fd) as listener, \
         selectors.DefaultSelector() as selector:
        _forkserver._forkserver_address = listener.getsockname()

        selector.register(listener, selectors.EVENT_READ)
        selector.register(alive_r, selectors.EVENT_READ)

        while True:
            try:
                while True:
                    rfds = [key.fileobj for (key, events) in selector.select()]
                    if rfds:
                        break

                if alive_r in rfds:
                    # EOF because no more client processes left
                    assert os.read(alive_r, 1) == b''
                    raise SystemExit

                assert listener in rfds
                with listener.accept()[0] as s:
                    code = 1
                    if os.fork() == 0:
                        try:
                            _serve_one(s, listener, alive_r, old_handlers)
                        except Exception:
                            sys.excepthook(*sys.exc_info())
                            sys.stderr.flush()
                        finally:
                            os._exit(code)

            except OSError as e:
                if e.errno != errno.ECONNABORTED:
                    raise
def check_config(dbdriver, dbtype, dbhost, dbuser, dbpasswd, testdb):
    global DBDRIVER, DBTYPE, DBHOST, DBUSER, DBPASSWD, TESTDB, DBSCHEMA, SQL_FILE
    DBDRIVER = dbdriver
    DBTYPE = dbtype
    DBHOST = dbhost
    DBUSER = dbuser
    DBPASSWD = dbpasswd
    TESTDB = testdb

    #Check the database driver is installed:
    try:
        __import__(DBDRIVER)
    except ImportError:
        message = "Install %s if you want to use %s with BioSQL " % (DBDRIVER, DBTYPE)
        raise MissingExternalDependencyError(message)

    try:
        if DBDRIVER in ["sqlite3"]:
            server = BioSeqDatabase.open_database(driver = DBDRIVER, db = TESTDB)
        else:
            server = BioSeqDatabase.open_database(driver = DBDRIVER,
                                                  user = DBUSER, passwd = DBPASSWD,
                                                  host = DBHOST)
            server.close()
            del server
    except Exception, e:
        message = "Connection failed, check settings if you plan to use BioSQL: %s" % str(e)
        raise MissingExternalDependencyError(message)
Example #29
0
File: err.py Project: rroemhild/err
def get_config(config_path):
    __import__('errbot.config-template')  # - is on purpose, it should not be imported normally ;)
    template = sys.modules['errbot.config-template']
    config_fullpath = config_path
    if not path.exists(config_fullpath):
        log.error(
            'I cannot find the file %s \n'
            '(You can change this path with the -c parameter see --help)' % config_path
        )
        log.info(
            'You can use the template %s as a base and copy it to %s. \nYou can then customize it.' % (
                path.dirname(template.__file__) + sep + 'config-template.py', config_path + sep)
        )
        exit(-1)

    # noinspection PyBroadException
    try:
        config = __import__(path.splitext(path.basename(config_fullpath))[0])

        diffs = [item for item in set(dir(template)) - set(dir(config)) if not item.startswith('_')]
        if diffs:
            log.error('You are missing configs defined from the template :')
            for diff in diffs:
                log.error('Missing config : %s' % diff)
            exit(-1)
    except Exception as _:
        log.exception('I could not import your config from %s, please check the error below...' % config_fullpath)
        exit(-1)
    log.info('Config check passed...')
    return config
Example #30
0
 def setup(self):
     try:
         __import__('multiprocessing')
     except ImportError:
         raise SkipTest('multiprocessing not supported')
     from celery.concurrency.prefork import TaskPool
     self.TaskPool = TaskPool
Example #31
0
 def test_module_docstring(self):
     """Test for existence of module docstring"""
     print("testing module docstring...")
     result = len(__import__('models.user').__doc__)
     self.assertTrue(result > 0, True)
Example #32
0
    def test(self):

        M1 = Migrations(__import__("fakeapp", {}, {}, ['']))

        self.assertEqual(M1, Migrations("fakeapp"))
        self.assertEqual(M1, Migrations(self.create_fake_app("fakeapp")))
Example #33
0
def build_op(build_type, json_str):
    """
    call op functions with function name and input args json_str

    Args:
        build_type : op function name
        json_str (str): op function input args

    Raises:
        Exception: If specific keyword is not found.
    """
    kernel_info = json.loads(json_str)
    check_kernel_info(kernel_info)

    # import module
    op_name = kernel_info['op_info']['name']

    try:
        custom_flag = False
        if 'impl_path' in kernel_info and kernel_info['impl_path'] is not None:
            impl_path = os.path.realpath(kernel_info['impl_path'])
            if os.path.isfile(impl_path):
                path, file_name = os.path.split(impl_path)
                op_name, _ = os.path.splitext(file_name)
                impl_path = path
                custom_flag = True
            else:
                impl_path = ""
        _initialize(impl_path)

        inputs_args = get_args(kernel_info['op_info'], 'inputs')
        outputs_args = get_args(kernel_info['op_info'], 'outputs')
        attrs_args = get_args(kernel_info['op_info'], 'attrs')
        kernel_name = kernel_info['op_info']['kernel_name']

        if custom_flag:
            op_module = __import__(op_name)
        else:
            op_module = __import__("impl." + op_name, globals(), locals(),
                                   [op_name], 0)
        # get function
        if build_type == op_pre_build:
            # set op parameter
            op_build_cfg_dis()
            set_current_op_func_name(op_name)
            set_current_op_name(kernel_name)
            init_op_pattern()
            set_op_params(*outputs_args, *attrs_args, kernel_name=kernel_name)
            set_op_build_type('prebuild')
            if custom_flag:
                py_fn_name = kernel_info['op_info']['name']
            else:
                py_fn_name = op_name
        elif build_type == op_build:
            if custom_flag:
                py_fn_name = kernel_info['op_info']['name']
            else:
                py_fn_name = op_name
        else:
            raise ValueError(
                "function {} is not supported by Tbe op {}.".format(
                    build_type, op_name))
        op_func = getattr(op_module, py_fn_name, None)
        if op_func is None:
            raise ValueError(
                "Op:{} function {} is not supported by Tbe.".format(
                    op_name, build_type))

        # pre build
        if build_type == op_pre_build:
            op_func(*inputs_args, *outputs_args, *attrs_args, kernel_name)
            # disable only pattern configuration
            op_build_cfg_en()
            return get_op_pattern()

        # call function
        if kernel_name[0:19] == "bounding_box_encode":
            return op_func(*inputs_args,
                           *outputs_args,
                           *attrs_args,
                           kernel_name_val=kernel_name)

        return op_func(*inputs_args,
                       *outputs_args,
                       *attrs_args,
                       kernel_name=kernel_name)

    except Exception as e:
        if build_type == op_pre_build:
            op_build_cfg_en()
        raise RuntimeError(e)
Example #34
0
    def test_openapi_arguments(self) -> None:
        """This end-to-end API documentation test compares the arguments
        defined in the actual code using @has_request_variables and
        REQ(), with the arguments declared in our API documentation
        for every API endpoint in Zulip.

        First, we import the fancy-Django version of zproject/urls.py
        by doing this, each has_request_variables wrapper around each
        imported view function gets called to generate the wrapped
        view function and thus filling the global arguments_map variable.
        Basically, we're exploiting code execution during import.

            Then we need to import some view modules not already imported in
        urls.py. We use this different syntax because of the linters complaining
        of an unused import (which is correct, but we do this for triggering the
        has_request_variables decorator).

            At the end, we perform a reverse mapping test that verifies that
        every url pattern defined in the openapi documentation actually exists
        in code.
        """

        from zproject import urls as urlconf

        # We loop through all the API patterns, looking in particular
        # for those using the rest_dispatch decorator; we then parse
        # its mapping of (HTTP_METHOD -> FUNCTION).
        for p in urlconf.v1_api_and_json_patterns + urlconf.v1_api_mobile_patterns:
            if p.lookup_str != 'zerver.lib.rest.rest_dispatch':
                # Endpoints not using rest_dispatch don't have extra data.
                methods_endpoints = dict(GET=p.lookup_str, )
            else:
                methods_endpoints = p.default_args

            # since the module was already imported and is now residing in
            # memory, we won't actually face any performance penalties here.
            for method, value in methods_endpoints.items():
                if isinstance(value, str):
                    function_name = value
                    tags: Set[str] = set()
                else:
                    function_name, tags = value

                if function_name == 'zerver.tornado.views.get_events':
                    # Work around the fact that the registered
                    # get_events view function isn't where we do
                    # @has_request_variables.
                    #
                    # TODO: Make this configurable via an optional argument
                    # to has_request_variables, e.g.
                    # @has_request_variables(view_func_name="zerver.tornado.views.get_events")
                    function_name = 'zerver.tornado.views.get_events_backend'

                lookup_parts = function_name.split('.')
                module = __import__('.'.join(lookup_parts[:-1]), {}, {}, [''])
                function = getattr(module, lookup_parts[-1])

                # Our accounting logic in the `has_request_variables()`
                # code means we have the list of all arguments
                # accepted by every view function in arguments_map.
                accepted_arguments = set(arguments_map[function_name])

                regex_pattern = p.pattern.regex.pattern
                url_pattern = self.convert_regex_to_url_pattern(regex_pattern)

                if "intentionally_undocumented" in tags:
                    self.ensure_no_documentation_if_intentionally_undocumented(
                        url_pattern, method)
                    continue

                if url_pattern in self.pending_endpoints:
                    # HACK: After all pending_endpoints have been resolved, we should remove
                    # this segment and the "msg" part of the `ensure_no_...` method.
                    msg = f"""
We found some OpenAPI documentation for {method} {url_pattern},
so maybe we shouldn't include it in pending_endpoints.
"""
                    self.ensure_no_documentation_if_intentionally_undocumented(
                        url_pattern, method, msg)
                    continue

                try:
                    # Don't include OpenAPI parameters that live in
                    # the path; these are not extracted by REQ.
                    openapi_parameters = get_openapi_parameters(
                        url_pattern, method, include_url_parameters=False)
                except Exception:  # nocoverage
                    raise AssertionError(
                        "Could not find OpenAPI docs for %s %s" %
                        (method, url_pattern))

                # We now have everything we need to understand the
                # function as defined in our urls.py:
                #
                # * method is the HTTP method, e.g. GET, POST, or PATCH
                #
                # * p.pattern.regex.pattern is the URL pattern; might require
                #   some processing to match with OpenAPI rules
                #
                # * accepted_arguments is the full set of arguments
                #   this method accepts (from the REQ declarations in
                #   code).
                #
                # * The documented parameters for the endpoint as recorded in our
                #   OpenAPI data in zerver/openapi/zulip.yaml.
                #
                # We now compare these to confirm that the documented
                # argument list matches what actually appears in the
                # codebase.

                openapi_parameter_names = {
                    parameter['name']
                    for parameter in openapi_parameters
                }

                if len(accepted_arguments -
                       openapi_parameter_names) > 0:  # nocoverage
                    print("Undocumented parameters for", url_pattern, method,
                          function_name)
                    print(" +", openapi_parameter_names)
                    print(" -", accepted_arguments)
                    assert (url_pattern in self.buggy_documentation_endpoints)
                elif len(openapi_parameter_names -
                         accepted_arguments) > 0:  # nocoverage
                    print("Documented invalid parameters for", url_pattern,
                          method, function_name)
                    print(" -", openapi_parameter_names)
                    print(" +", accepted_arguments)
                    assert (url_pattern in self.buggy_documentation_endpoints)
                else:
                    self.assertEqual(openapi_parameter_names,
                                     accepted_arguments)
                    self.check_argument_types(function, openapi_parameters)
                    self.checked_endpoints.add(url_pattern)

        self.check_for_non_existant_openapi_endpoints()
    # multiple revisions is given via stdin
    whitelist = modulewhitelist(sys.stdin)
    assert whitelist, "module whitelist is empty"

    # build up module whitelist check from file names given at runtime
    perfpypats[0].append(
        # this matching pattern assumes importing modules from
        # "mercurial" package in the current style below, for simplicity
        #
        #    from mercurial import (
        #        foo,
        #        bar,
        #        baz
        #    )
        ((r'from mercurial import [(][a-z0-9, \n#]*\n(?! *%s,|^[ #]*\n|[)])'
          % ',| *'.join(whitelist)),
         "import newer module separately in try clause for early Mercurial"
         ))

    # import contrib/check-code.py as checkcode
    assert 'RUNTESTDIR' in os.environ, "use check-perf-code.py in *.t script"
    contribpath = os.path.join(os.environ['RUNTESTDIR'], '..', 'contrib')
    sys.path.insert(0, contribpath)
    checkcode = __import__('check-code')

    # register perf.py specific entry with "checks" in check-code.py
    checkcode.checks.append(('perf.py', r'contrib/perf.py$', '',
                             checkcode.pyfilters, perfpypats))

    sys.exit(checkcode.main())
Example #36
0
A forward pass:

    >>> from numpy import ones
    >>> r = n.activate(ones(24))
    >>> len(r)
    12

The result should be symmetric (although the weights are random)
    
    >>> r[0]-r[-1] 
    0.0
        
Check its gradient:

    >>> from pybrain.tests import gradientCheck
    >>> gradientCheck(n)
    Perfect gradient
    True


"""

__author__ = 'Tom Schaul, [email protected]'

from pybrain.structure.networks import BidirectionalNetwork  #@UnusedImport
from pybrain.tests import runModuleTestSuite

if __name__ == "__main__":
    runModuleTestSuite(__import__('__main__'))
Example #37
0
#C* Copyright (c) Schrodinger, LLC.
#D* -------------------------------------------------------------------
#E* It is unlawful to modify or remove this copyright notice.
#F* -------------------------------------------------------------------
#G* Please see the accompanying LICENSE file for further information.
#H* -------------------------------------------------------------------
#I* Additional authors of this source file include:
#-*
#-*
#-*
#Z* -------------------------------------------------------------------

# abstract (external or internal) gui control interface

import pymol
cmd = __import__("sys").modules["pymol.cmd"]


def get_pmgapp():
    '''
    Returns the PMGApp instance.
    '''
    if pymol._ext_gui is None:
        pymol._ext_gui = createlegacypmgapp()
    return pymol._ext_gui


def get_qtwindow():
    '''
    Returns the PyMOLQtGUI/QMainWindow instance, or None if not available.
    '''
Example #38
0
def optional_import(
    module: str,
    version: str = "",
    version_checker: Callable[..., bool] = min_version,
    name: str = "",
    descriptor: str = OPTIONAL_IMPORT_MSG_FMT,
    version_args=None,
    allow_namespace_pkg: bool = False,
) -> Tuple[Any, bool]:
    """
    Imports an optional module specified by `module` string.
    Any importing related exceptions will be stored, and exceptions raise lazily
    when attempting to use the failed-to-import module.

    Args:
        module: name of the module to be imported.
        version: version string used by the version_checker.
        version_checker: a callable to check the module version, Defaults to monai.utils.min_version.
        name: a non-module attribute (such as method/class) to import from the imported module.
        descriptor: a format string for the final error message when using a not imported module.
        version_args: additional parameters to the version checker.
        allow_namespace_pkg: whether importing a namespace package is allowed. Defaults to False.

    Returns:
        The imported module and a boolean flag indicating whether the import is successful.

    Examples::

        >>> torch, flag = optional_import('torch', '1.1')
        >>> print(torch, flag)
        <module 'torch' from 'python/lib/python3.6/site-packages/torch/__init__.py'> True

        >>> the_module, flag = optional_import('unknown_module')
        >>> print(flag)
        False
        >>> the_module.method  # trying to access a module which is not imported
        OptionalImportError: import unknown_module (No module named 'unknown_module').

        >>> torch, flag = optional_import('torch', '42', exact_version)
        >>> torch.nn  # trying to access a module for which there isn't a proper version imported
        OptionalImportError: import torch (requires version '42' by 'exact_version').

        >>> conv, flag = optional_import('torch.nn.functional', '1.0', name='conv1d')
        >>> print(conv)
        <built-in method conv1d of type object at 0x11a49eac0>

        >>> conv, flag = optional_import('torch.nn.functional', '42', name='conv1d')
        >>> conv()  # trying to use a function from the not successfully imported module (due to unmatched version)
        OptionalImportError: from torch.nn.functional import conv1d (requires version '42' by 'min_version').
    """

    tb = None
    exception_str = ""
    if name:
        actual_cmd = f"from {module} import {name}"
    else:
        actual_cmd = f"import {module}"
    try:
        pkg = __import__(module)  # top level module
        the_module = import_module(module)
        if not allow_namespace_pkg:
            is_namespace = getattr(the_module, "__file__",
                                   None) is None and hasattr(
                                       the_module, "__path__")
            assert not is_namespace
        if name:  # user specified to load class/function/... from the module
            the_module = getattr(the_module, name)
    except Exception as import_exception:  # any exceptions during import
        tb = import_exception.__traceback__
        exception_str = f"{import_exception}"
    else:  # found the module
        if version_args and version_checker(pkg, f"{version}", version_args):
            return the_module, True
        if not version_args and version_checker(pkg, f"{version}"):
            return the_module, True

    # preparing lazy error message
    msg = descriptor.format(actual_cmd)
    if version and tb is None:  # a pure version issue
        msg += f" (requires '{module} {version}' by '{version_checker.__name__}')"
    if exception_str:
        msg += f" ({exception_str})"

    class _LazyRaise:
        def __init__(self, *_args, **_kwargs):
            _default_msg = (
                f"{msg}." +
                "\n\nFor details about installing the optional dependencies, please visit:"
                +
                "\n    https://docs.monai.io/en/latest/installation.html#installing-the-recommended-dependencies"
            )
            if tb is None:
                self._exception = OptionalImportError(_default_msg)
            else:
                self._exception = OptionalImportError(
                    _default_msg).with_traceback(tb)

        def __getattr__(self, name):
            """
            Raises:
                OptionalImportError: When you call this method.
            """
            raise self._exception

        def __call__(self, *_args, **_kwargs):
            """
            Raises:
                OptionalImportError: When you call this method.
            """
            raise self._exception

    return _LazyRaise(), False
Example #39
0
"""The :mod:`zmq` module wraps the :class:`Socket` and :class:`Context` found in :mod:`pyzmq <zmq>` to be non blocking
"""
__zmq__ = __import__('zmq')
from eventlet import sleep
from eventlet.hubs import trampoline, get_hub

__patched__ = ['Context', 'Socket']
globals().update(
    dict([(var, getattr(__zmq__, var)) for var in __zmq__.__all__
          if not (var.startswith('__') or var in __patched__)]))


def get_hub_name_from_instance(hub):
    """Get the string name the eventlet uses to refer to hub

    :param hub: An eventlet hub
    """
    return hub.__class__.__module__.rsplit('.', 1)[-1]


def Context(io_threads=1):
    """Factory function replacement for :class:`zmq.core.context.Context`

    This factory ensures the :class:`zeromq hub <eventlet.hubs.zeromq.Hub>`
    is the active hub, and defers creation (or retreival) of the ``Context``
    to the hub's :meth:`~eventlet.hubs.zeromq.Hub.get_context` method
    
    It's a factory function due to the fact that there can only be one :class:`_Context`
    instance per thread. This is due to the way :class:`zmq.core.poll.Poller`
    works
    """
Example #40
0
# -*- coding: utf-8 -*-
"""
Created on Wed Dec  4 17:56:50 2019

@author: Aditya Luthfi
"""

lib = __import__('1184090csv')

lib.bukaModeListCsv()
lib.bukaModeDictCsv()

lib.tulisCsv()

lib = __import__('1184090pandas')

lib.bukaModeListPandas()
lib.bukaModeDictPandas()

lib.tulisCsvPandas()
Example #41
0
import yfinance as yf
import pandas as pd
from datetime import datetime
args = __import__('sys').argv
symbol = args[1]
data = yf.Ticker(symbol)
history = data.history(period='1d', start='2010-1-1', end=datetime.today().strftime('%Y-%m-%d'))

with pd.option_context('display.max_rows', None, 'display.max_columns', None):
    print(history)
Example #42
0
#!/usr/bin/env python

try:
    __import__('scrypt')
    __import__('requests')
except:
    # Write more about how they might install it
    print(
        'The scrypt and requests modules are required, please install in your environment'
    )
    quit()

import json, scrypt, requests, getpass, random, string


def nonce_gen(length):
    return ''.join([
        str(random.SystemRandom().choice(string.ascii_lowercase +
                                         string.digits)) for i in range(length)
    ])


user = input('What is your username associated with Keybase: ')
js = json.loads(
    requests.get(
        'https://keybase.io/_/api/1.0/getsalt.json?email_or_username='******'status']['code'] is 0:
    print(
        'Bad username (be sure NOT to use your email, this method is depreciated)\nEnding process'
#!/usr/bin/env python3
"""
Tests for the optimum number of clusters by variance
"""
import numpy as np
kmeans = __import__('1-kmeans').kmeans
variance = __import__('2-variance').variance


def optimum_k(X, kmin=1, kmax=None, iterations=1000):
    """
    Tests for the optimum number of clusters by variance
    :param X: numpy.ndarray of shape (n, d) containing the data set
    :param kmin: positive integer containing the minimum number of clusters
    to check for (inclusive)
    :param kmax: positive integer containing the maximum number of clusters
    to check for (inclusive)
    :param iterations: positive integer containing the maximum number of
    iterations for K-means
    :return: results, d_vars, or None, None on failure
        results is a list containing the outputs of K-means for each cluster
        size
        d_vars is a list containing the difference in variance from the
        smallest cluster size for each cluster size
    """
    if type(X) is not np.ndarray or len(X.shape) != 2:
        return None, None
    if type(iterations) is not int or iterations <= 0:
        return None, None
    if type(kmin) is not int or kmin < 1:
        return None, None
Example #44
0
def _import_module(name):
    """Import module, returning the module after the last dot."""
    __import__(name)
    return sys.modules[name]
Example #45
0
def get_server_mixin(server_name):
    from . import __name__ as base
    x = __import__('{}.servers.{}'.format(base, server_name), fromlist=[''])
    return x.ServerMixin
Example #46
0
import time
import datetime
import threading
from math import sqrt
#import sys,os
#import serial
import logging

logger = logging.getLogger("hydrosys4."+__name__)



global ISRPI

try:
	__import__("smbus")
except ImportError:
	ISRPI=False
else:
	import Adafruit_DHT #humidity temperature sensor
	import Adafruit_BMP.BMP085 as BMP085 #pressure sensor
	#from Adafruit_MotorHAT import Adafruit_MotorHAT, Adafruit_DCMotor, Adafruit_StepperMotor
	from stepperDOUBLEmod import Adafruit_MotorHAT, Adafruit_DCMotor, Adafruit_StepperMotor
	import spidev
	import smbus
	import RPi.GPIO as GPIO
	GPIO.setmode(GPIO.BCM) 
	ISRPI=True


HWCONTROLLIST=["tempsensor","humidsensor","pressuresensor","analogdigital","lightsensor","pulse","pinstate","servo","stepper","stepperstatus","photo","mail+info+link","mail+info","returnzero","stoppulse","readinputpin"]
Example #47
0
    def onClick(self, id):
        # Valores por defecto
        if id == 10006:
            if self.custom_button is not None:
                if '.' in self.callback:
                    package, self.callback = self.callback.rsplit('.', 1)
                else:
                    package = 'channels.%s' % self.channel
                try:
                    cb_channel = __import__(package, None, None, [package])
                except ImportError:
                    logger.error('Imposible importar %s' % package)
                else:
                    self.return_value = getattr(
                        cb_channel, self.custom_button['function'])(self.item)
                    if self.custom_button["close"]:
                        self.close()

            else:
                for c in self.list_controls:
                    if c["type"] == "text":
                        c["control"].setText(c["default"])
                        self.values[c["id"]] = c["default"]
                    if c["type"] == "bool":
                        c["control"].setSelected(c["default"])
                        self.values[c["id"]] = c["default"]
                    if c["type"] == "list":
                        c["label"].setLabel(c["lvalues"][c["default"]])
                        self.values[c["id"]] = c["default"]

                self.evaluate_conditions()
                self.dispose_controls(self.index, force=True)
                self.check_default()
                self.check_ok()

        # Boton Cancelar y [X]
        if id == 10003 or id == 10005:
            self.close()

        # Boton Aceptar
        if id == 10004:
            if not self.callback:
                for v in self.values:
                    config.set_setting(v, self.values[v], self.channel)
                self.close()
            else:
                self.close()
                if '.' in self.callback:
                    package, self.callback = self.callback.rsplit('.', 1)
                else:
                    package = 'channels.%s' % self.channel
                cb_channel = None
                try:
                    cb_channel = __import__(package, None, None, [package])
                except ImportError:
                    logger.error('Imposible importar %s' % package)

                self.return_value = getattr(cb_channel,
                                            self.callback)(self.item,
                                                           self.values)

        # Controles de ajustes, si se cambia el valor de un ajuste, cambiamos el valor guardado en el diccionario de
        # valores
        # Obtenemos el control sobre el que se ha echo click
        control = self.getControl(id)

        # Lo buscamos en el listado de controles
        for cont in self.list_controls:

            # Si el control es un "downBtn" o "upBtn" son los botones del "list"
            # en este caso cambiamos el valor del list
            if cont["type"] == "list" and (cont["downBtn"] == control
                                           or cont["upBtn"] == control):

                # Para bajar una posicion
                if cont["downBtn"] == control:
                    index = cont["lvalues"].index(cont["label"].getLabel())
                    if index > 0:
                        cont["label"].setLabel(cont["lvalues"][index - 1])

                # Para subir una posicion
                elif cont["upBtn"] == control:
                    index = cont["lvalues"].index(cont["label"].getLabel())
                    if index < len(cont["lvalues"]) - 1:
                        cont["label"].setLabel(cont["lvalues"][index + 1])

                # Guardamos el nuevo valor en el diccionario de valores
                self.values[cont["id"]] = cont["lvalues"].index(
                    cont["label"].getLabel())

            # Si esl control es un "bool", guardamos el nuevo valor True/False
            if cont["type"] == "bool" and cont["control"] == control:
                self.values[cont["id"]] = bool(cont["control"].isSelected())

            # Si esl control es un "text", guardamos el nuevo valor
            if cont["type"] == "text" and cont["control"] == control:
                # Versiones antiguas requieren abrir el teclado manualmente
                if xbmcgui.ControlEdit == ControlEdit:
                    import xbmc
                    keyboard = xbmc.Keyboard(cont["control"].getText(),
                                             cont["control"].getLabel(),
                                             cont["control"].isPassword)
                    keyboard.setHiddenInput(cont["control"].isPassword)
                    keyboard.doModal()
                    if keyboard.isConfirmed():
                        cont["control"].setText(keyboard.getText())

                self.values[cont["id"]] = cont["control"].getText()

        self.evaluate_conditions()
        self.dispose_controls(self.index, force=True)
        self.check_default()
        self.check_ok()
Example #48
0
def test_lazy_import():
    class O(object):
        math = lazy_import('math')

    assert O.math is __import__('math')
Example #49
0
    Setup package
    ~~~~~~~~~~~~~~~~~~~~

    Setuptools/distutils commands to package installation.

    :license: Other/Proprietary, see LICENSE for details.
"""
# pylint: HOOK-IGNORED

import os
from setuptools import setup
from setuptools import find_packages
import subprocess

project_name = 'ANP Reader'
__version__ = __import__(project_name).__version__
__author__ = __import__(project_name).__author__
__author_email__ = __import__(project_name).__author_email__
__author_username__ = __import__(project_name).__author_username__
__description__ = __import__(project_name).__description__


def cmd_output(args, **kwds):
    kwds.setdefault("stdout", subprocess.PIPE)
    kwds.setdefault("stderr", subprocess.STDOUT)
    p = subprocess.Popen(args, **kwds)
    return p.communicate()[0]


def version_tuple(version):
    return tuple([int(num) for num in version.split('.')])
Example #50
0
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
'''

import components.scanner.flatevaluators.result as FlatEvltResult
import components.scanner.logicevaluators.result as LogicEvltResult

flatModuleList = [
    ('FileItem', 'files_hash'),
]

logicModuleList = []

flatEvaluatorList = {}
logicEvaluatorList = {}

for document, module in flatModuleList:
    flatEvaluatorList[document] = getattr(
        __import__('components.scanner.flatevaluators.%s' % module,
                   fromlist=['Evaluator']), 'Evaluator')

for document, module in logicModuleList:
    logicEvaluatorList[document] = getattr(
        __import__('components.scanner.logicevaluators.%s' % module,
                   fromlist=['Evaluator']), 'Evaluator')
Example #51
0
#!/usr/bin/env python3
"""
Tranformer Encoder Block
(https://www.tensorflow.org/tutorials/text/transformer#encoder_layer)
"""

import tensorflow as tf

MultiHeadAttention = __import__('6-multihead_attention').MultiHeadAttention


class EncoderBlock(tf.keras.layers.Layer):
    """
    class Encoder block
    """
    def __init__(self, dm, h, hidden, drop_rate=0.1):
        """
        dm - the dimensionality of the model
        h - the number of heads
        hidden - the number of hidden units in the fully connected layer
        drop_rate - the dropout rate
        Sets the following public instance attributes:
        mha - a MultiHeadAttention layer
        dense_hidden - the hidden dense layer with hidden units an
          relu activation
        dense_output - the output dense layer with dm units
        layernorm1 - the first layer norm layer, with epsilon=1e-6
        layernorm2 - the second layer norm layer, with epsilon=1e-6
        dropout1 - the first dropout layer
        dropout2 - the second dropout layer
        """
Example #52
0
def importobj(modpath, attrname):
    module = __import__(modpath, None, None, ['__doc__'])
    return getattr(module, attrname)
Example #53
0
def namespaced_import(name, namespace=None, environment_path=None):
    """A function to import compiled soy modules using the Soy namespace.

  This function attempts to first import the module directly. If it isn't found
  in the matching package as the Soy Namespace, it will walk the sys.path
  structure open any module with a matching name and test its SOY_NAMESPACE
  attribute. If it matches it will load that instead.

  Multiple files can share the same soy namespace. In that instance, all of
  these files will be loaded, combined, and loaded as one module.

  Note: If multiple files share the same namespace, they still require that the
  module name begins with the last part of the namespace (e.g.
  soy.examples.delegates will load delegates0.py, delegatesxyz.py, etc.).
  TODO(dcphillips): See if there's any way we can avoid this limitation without
  blowing up load times.

  Args:
    name: The name of the module to import.
    namespace: The namespace of the module to import.
    environment_path: A custom environment module path for interacting with the
      runtime environment.

  Returns:
    The Module object.
  """
    full_namespace = '%s.%s' % (namespace, name) if namespace else name
    try:
        # Try searching for the module directly
        return importlib.import_module(full_namespace)
    except ImportError:
        # If the module isn't found, search without the namespace and check the
        # namespaces.
        if namespace:
            namespace_key = "SOY_NAMESPACE: '%s'." % full_namespace
            module = None
            if environment_path:
                file_loader = importlib.import_module(
                    environment_path).file_loader
            else:
                file_loader = environment.file_loader
            for sys_path, f_path, f_name in _find_modules(name):
                # Verify the file namespace by comparing the 5th line.
                with file_loader(f_path, f_name, 'r') as f:
                    for _ in range(4):
                        next(f)
                    if namespace_key != next(f).rstrip():
                        continue

                # Strip the root path and the file extension.
                module_path = six.ensure_str(os.path.relpath(
                    f_path, sys_path)).replace('/', '.')
                module_name = os.path.splitext(f_name)[0]

                # Python 2 performs relative or absolute imports. Beginning with
                # Python 3.3, only absolute imports are possible. Compare the
                # docs for the default value of the `level` argument of `__import__`:
                # https://docs.python.org/2/library/functions.html#__import__
                # https://docs.python.org/3/library/functions.html#__import__
                module = getattr(
                    __import__(module_path, globals(), locals(),
                               [module_name]), module_name)
                break
            if module:
                # Add this to the global modules list for faster loading in the future.
                _cache_module(full_namespace, module)
                return module
        raise
Example #54
0
Package containing implementation of all the standard Distutils
commands."""

__revision__ = "$Id: __init__.py,v 1.3 2005/05/16 11:08:49 pearu Exp $"

distutils_all = [  #'build_py',
    'clean',
    'install_clib',
    'install_scripts',
    'bdist',
    'bdist_dumb',
    'bdist_wininst',
]

__import__('distutils.command', globals(), locals(), distutils_all)

__all__ = [
    'build',
    'config_compiler',
    'config',
    'build_src',
    'build_py',
    'build_ext',
    'build_clib',
    'build_scripts',
    'install',
    'install_data',
    'install_headers',
    'install_lib',
    'bdist_rpm',
Example #55
0
#!/usr/bin/env python3
""" Contains the inception_network function """

import tensorflow.keras as K

inception_block = __import__('0-inception_block').inception_block


def inception_network():
    """
    Builds the inception network
    """
    initializer = K.initializers.he_normal(seed=None)

    X = K.Input(shape=(224, 224, 3))

    my_layer = K.layers.Conv2D(
        filters=64,
        kernel_size=(7, 7),
        strides=(2, 2),
        padding='same',
        activation='relu',
        kernel_initializer=initializer,
    )(X)

    my_layer = K.layers.MaxPool2D(pool_size=(3, 3),
                                  padding='same',
                                  strides=(2, 2))(my_layer)

    my_layer = K.layers.Conv2D(
        filters=64,
#!/usr/bin/python3
print_reversed_list_integer = __import__(
    '3-print_reversed_list_integer').print_reversed_list_integer

my_list = [1, 2, 3, 4, 5]
print_reversed_list_integer(my_list)

print_reversed_list_integer(my_list2)
Example #57
0
from codecs import open
from os import path

here = path.abspath(path.dirname(__file__))

# Get the long description from the README file
with open(path.join(here, 'README.rst'), encoding='utf-8') as f:
    long_description = f.read()

setup(
    name='pymysql_split_tool',

    # Versions should comply with PEP440.  For a discussion on single-sourcing
    # the version across setup.py and the project code, see
    # https://packaging.python.org/en/latest/single_source_version.html
    version=__import__('pymysql_split_tool').__version__,

    description='mysql spliting/sharding tools',
    long_description=long_description,

    # The project's main homepage.
    url='https://github.com/echoma/pymysql_split_tool',

    # Author details
    author='Echo Ma',
    author_email='*****@*****.**',

    # Choose your license
    license='Apache 2.0',

    # See https://pypi.python.org/pypi?%3Aaction=list_classifiers
# Copyright (C) 2019 by eHealth Africa : http://www.eHealthAfrica.org
#
# See the NOTICE file distributed with this work for additional information
# regarding copyright ownership.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.

__path__ = __import__('pkgutil').extend_path(__path__, __name__)
Example #59
0
def visit_file(dir, name):
    # Try to match the regexp pattern, if specified.
    if configuration.regexp:
        if not re.search(configuration.regexp, name):
            # We didn't match the regex, we're done.
            return

    if configuration.skip_tests:
        for file_regexp in configuration.skip_tests:
            if re.search(file_regexp, name):
                return

    # We found a match for our test.  Add it to the suite.

    # Update the sys.path first.
    if not sys.path.count(dir):
        sys.path.insert(0, dir)
    base = os.path.splitext(name)[0]

    # Thoroughly check the filterspec against the base module and admit
    # the (base, filterspec) combination only when it makes sense.

    def check(obj, parts):
        for part in parts:
            try:
                parent, obj = obj, getattr(obj, part)
            except AttributeError:
                # The filterspec has failed.
                return False
        return True

    module = __import__(base)

    def iter_filters():
        for filterspec in configuration.filters:
            parts = filterspec.split('.')
            if check(module, parts):
                yield filterspec
            elif parts[0] == base and len(parts) > 1 and check(module, parts[1:]):
                yield '.'.join(parts[1:])
            else:
                for key,value in module.__dict__.items():
                    if check(value, parts):
                        yield key + '.' + filterspec

    filtered = False
    for filterspec in iter_filters():
        filtered = True
        print("adding filter spec %s to module %s" % (filterspec, repr(module)))
        tests = unittest2.defaultTestLoader.loadTestsFromName(filterspec, module)
        configuration.suite.addTests(tests)

    # Forgo this module if the (base, filterspec) combo is invalid
    if configuration.filters and not filtered:
        return

    if not filtered:
        # Add the entire file's worth of tests since we're not filtered.
        # Also the fail-over case when the filterspec branch
        # (base, filterspec) combo doesn't make sense.
        configuration.suite.addTests(
            unittest2.defaultTestLoader.loadTestsFromName(base))
Example #60
0
def _bundle_extensions(objs: Sequence[Model | Document],
                       resources: Resources) -> List[ExtensionEmbed]:
    names: Set[str] = set()
    bundles: List[ExtensionEmbed] = []

    extensions = [".min.js", ".js"] if resources.minified else [".js"]

    for obj in _all_objs(
            objs
    ) if objs is not None else Model.model_class_reverse_map.values():
        if hasattr(obj, "__implementation__"):
            continue
        name = obj.__view_module__.split(".")[0]
        if name == "bokeh":
            continue
        if name in names:
            continue
        names.add(name)
        module = __import__(name)
        this_file = abspath(module.__file__)
        base_dir = dirname(this_file)
        dist_dir = join(base_dir, "dist")

        ext_path = join(base_dir, "bokeh.ext.json")
        if not exists(ext_path):
            continue

        server_prefix = f"{resources.root_url}static/extensions"
        package_path = join(base_dir, "package.json")

        pkg: Pkg | None = None
        if exists(package_path):
            with open(package_path) as io:
                try:
                    pkg = json.load(io)
                except json.decoder.JSONDecodeError:
                    pass

        artifact_path: str
        server_url: str
        cdn_url: str | None = None

        if pkg is not None:
            pkg_name: str | None = pkg.get("name", None)
            if pkg_name is None:
                raise ValueError("invalid package.json; missing package name")
            pkg_version = pkg.get("version", "latest")
            pkg_main = pkg.get("module", pkg.get("main", None))
            if pkg_main is not None:
                cdn_url = f"{_default_cdn_host}/{pkg_name}@{pkg_version}/{pkg_main}"
            else:
                pkg_main = join(dist_dir, f"{name}.js")
            artifact_path = join(base_dir, normpath(pkg_main))
            artifacts_dir = dirname(artifact_path)
            artifact_name = basename(artifact_path)
            server_path = f"{name}/{artifact_name}"
            if not settings.dev:
                sha = hashlib.sha256()
                sha.update(pkg_version.encode())
                vstring = sha.hexdigest()
                server_path = f"{server_path}?v={vstring}"
        else:
            for ext in extensions:
                artifact_path = join(dist_dir, f"{name}{ext}")
                artifacts_dir = dist_dir
                server_path = f"{name}/{name}{ext}"
                if exists(artifact_path):
                    break
            else:
                raise ValueError(
                    f"can't resolve artifact path for '{name}' extension")

        extension_dirs[name] = artifacts_dir
        server_url = f"{server_prefix}/{server_path}"
        embed = ExtensionEmbed(artifact_path, server_url, cdn_url)
        bundles.append(embed)

    return bundles