def test_listingModulesAlreadyImported(self):
     """ Make sure the module list comes back as we expect from iterModules on a
     package, whether zipped or not, even if the package has already been
     imported.  """
     self._setupSysPath()
     namedAny(self.packageName)
     self._listModules()

    def getPluginMethods(cls, plugin_name = None):
        # Get plugin by name or pk
        if plugin_name:
            plugin_list = Plugin.objects(name = plugin_name)
        else:
            plugin_list = Plugin.objects

        # Parse plugins
        listallmethods = []
        for plugin in plugin_list:
            plugininstance = namedAny('.'.join(('lisa.plugins', str(plugin.name), 'modules', str(plugin.name).lower(), str(plugin.name))))()
            listpluginmethods = []
            for m in inspect.getmembers(plugininstance, predicate = inspect.ismethod):
                if not "__init__" in m and not m.startswith("_"):
                    listpluginmethods.append(m[0])
            listallmethods.append({'plugin': plugin.name, 'methods': listpluginmethods})

        # Parse core plugins
        for f in os.listdir(os.path.normpath(server_path + '/core')):
            fileName, fileExtension = os.path.splitext(f)
            if os.path.isfile(os.path.join(os.path.normpath(server_path + '/core'), f)) and not f.startswith('__init__') and fileExtension != '.pyc':
                coreinstance = namedAny('.'.join(('lisa.server.core', str(fileName).lower(), str(fileName).capitalize())))()
                listcoremethods = []
                for m in inspect.getmembers(coreinstance, predicate = inspect.ismethod):
                    #init shouldn't be listed in methods and _ is for translation
                    if not "__init__" in m and not m.startswith("_"):
                        listcoremethods.append(m[0])
                listallmethods.append({'core': fileName, 'methods': listcoremethods})

        log.msg(listallmethods)
        return listallmethods

 def test_noversionpy(self):
     """
     Former subprojects no longer have an importable C{_version.py}.
     """
     with self.assertRaises(AttributeError):
         reflect.namedAny(
             "twisted.{}._version".format(self.subproject))

        def start():
            node_to_instance = {
                u"client": lambda: maybeDeferred(namedAny("allmydata.client.create_client"), self.basedir),
                u"introducer": lambda: maybeDeferred(namedAny("allmydata.introducer.server.create_introducer"), self.basedir),
                u"stats-gatherer": lambda: maybeDeferred(namedAny("allmydata.stats.StatsGathererService"), read_config(self.basedir, None), self.basedir, verbose=True),
                u"key-generator": key_generator_removed,
            }

            try:
                service_factory = node_to_instance[self.nodetype]
            except KeyError:
                raise ValueError("unknown nodetype %s" % self.nodetype)

            def handle_config_error(fail):
                fail.trap(UnknownConfigError)
                sys.stderr.write("\nConfiguration error:\n{}\n\n".format(fail.value))
                reactor.stop()
                return

            d = service_factory()

            def created(srv):
                srv.setServiceParent(self.parent)
            d.addCallback(created)
            d.addErrback(handle_config_error)
            d.addBoth(self._call_hook, 'running')
            return d

 def test_client(self):
     """
     The L{insults.client} module is deprecated
     """
     namedAny('twisted.conch.insults.client')
     self.ensureDeprecated("twisted.conch.insults.client was deprecated "
                           "in Twisted 10.1.0: Please use "
                           "twisted.conch.insults.insults instead.")

 def test_colors(self):
     """
     The L{insults.colors} module is deprecated
     """
     namedAny('twisted.conch.insults.colors')
     self.ensureDeprecated("twisted.conch.insults.colors was deprecated "
                           "in Twisted 10.1.0: Please use "
                           "twisted.conch.insults.helper instead.")

def load(S):
    for line in S.split('\n'):
        line = line.strip()
        if line and not line.startswith('#'):
            (a, o , i) = line.split()
            a = reflect.namedAny(a)
            o = reflect.namedAny(o)
            i = reflect.namedAny(i)
            compy.registerAdapter(a,o,i)

 def test_NMEADeprecation(self):
     """
     L{twisted.protocols.gps.nmea} is deprecated since Twisted 15.2.
     """
     reflect.namedAny("twisted.protocols.gps.nmea")
     warningsShown = self.flushWarnings()
     self.assertEqual(1, len(warningsShown))
     self.assertEqual(
         "twisted.protocols.gps was deprecated in Twisted 15.2.0: "
         "Use twisted.positioning instead.", warningsShown[0]['message'])

 def test_loreDeprecation(self):
     """
     L{twisted.lore} is deprecated since Twisted 14.0.
     """
     reflect.namedAny("twisted.lore")
     warningsShown = self.flushWarnings()
     self.assertEqual(1, len(warningsShown))
     self.assertEqual(
         "twisted.lore was deprecated in Twisted 14.0.0: "
         "Use Sphinx instead.", warningsShown[0]['message'])

 def test_MiceDeprecation(self):
     """
     L{twisted.protocols.mice} is deprecated since Twisted 16.0.
     """
     reflect.namedAny("twisted.protocols.mice")
     warningsShown = self.flushWarnings()
     self.assertEqual(1, len(warningsShown))
     self.assertEqual(
         "twisted.protocols.mice was deprecated in Twisted 16.0.0: "
         "There is no replacement for this module.",
         warningsShown[0]['message'])

 def update_params(self, d):
     super(SourceCodeWidget, self).update_params(d)
     title = d.widget.__class__.__name__
     if not d.source:
         try:
             d.widget = moksha.get_widget(d.widget)
         except Exception, e:
             d.widget = namedAny(d.widget)
         if d.module:
             obj = namedAny(d.widget.__module__)
         else:
             obj = d.widget.__class__
         d.source = inspect.getsource(obj)

        def start():
            node_to_instance = {
                u"client": lambda: namedAny("allmydata.client.create_client")(self.basedir),
                u"introducer": lambda: namedAny("allmydata.introducer.server.create_introducer")(self.basedir),
                u"stats-gatherer": lambda: namedAny("allmydata.stats.StatsGathererService")(read_config(self.basedir, None), self.basedir, verbose=True),
                u"key-generator": key_generator_removed,
            }

            try:
                service_factory = node_to_instance[self.nodetype]
            except KeyError:
                raise ValueError("unknown nodetype %s" % self.nodetype)

            srv = service_factory()
            srv.setServiceParent(self.parent)

def pipedpath_constructor(loader, node):
    path = loader.construct_python_str(node)
    original_path = path
    package = piped
    
    # the path may be an empty string, which should be the root piped package path.
    if path:
        paths = path.split(os.path.sep)

        for i in range(1, len(paths)+1):
            package_name = '.'.join(['piped'] + paths[:i])

            try:
                any = reflect.namedAny(package_name)
            except (AttributeError, reflect.ObjectNotFound) as e:
                # AttributeErrors may occur if we look a file that has the
                # same prefix as an existing module or package
                break

            # we don't want to start looking into modules:
            if not is_package(any):
                break
            package = any

            # update the remaining path
            path = os.path.sep.join(paths[i:])

    root = filepath.FilePath(package.__file__).parent()
    fp = root.preauthChild(util.expand_filepath(path))

    # add markers for dumping the configuration
    fp.origpath = original_path
    fp.pipedpath = True
    return fp

    def _tryNamedAny(self, arg):
        try:
            try:
                n = reflect.namedAny(arg)
            except ValueError, ve:
                if ve.args == ('Empty module name',):
                    raise ArgumentError
                else:
                    raise
        except ArgumentError:
            raise
        except:
            f = failure.Failure()
            f.printTraceback()
            self['_couldNotImport'][arg] = f
            return

        # okay, we can use named any to import it, so now wtf is it?
        if inspect.ismodule(n):
            filename = os.path.basename(n.__file__)
            filename = os.path.splitext(filename)[0]
            if filename == '__init__':
                self['packages'].append(n)
            else:
                self['modules'].append(n)
        elif inspect.isclass(n):
            self['testcases'].append(n)
        elif inspect.ismethod(n):
            self['methods'].append(n)
        else:
            raise ArgumentError, "could not figure out how to use %s" % arg

    def __init__(self, profile_name, engine, events=None, checkout=None, checkin=None, ping_interval=10.0, retry_interval=5.0):
        super(EngineManager, self).__init__()
        self.profile_name = profile_name
        self.ping_interval = ping_interval
        self.retry_interval = retry_interval

        self.events = {} if events is None else events
        self.checkout = [] if checkout is None else checkout
        self.checkin = [] if checkin is None else checkin

        self.engine_configuration = copy.deepcopy(engine)
        self._fail_if_configuration_is_invalid()
        self.engine_configuration.setdefault('proxy', self.proxy_factory(self))

        if 'poolclass' in self.engine_configuration:
            self.engine_configuration['poolclass'] = reflect.namedAny(self.engine_configuration['poolclass'])

        self.is_connected = False

        self.engine = sa.engine_from_config(self.engine_configuration, prefix='')
        self._bind_events()

        self.on_connection_established = event.Event()
        self.on_connection_lost = event.Event()
        self.on_connection_failed = event.Event()

 def render_examples(self, ctx, data):
     for name in examples:
         cls = reflect.namedAny(name)
         yield T.div(class_='example')[
             T.h1[T.a(href=url.here.child(name))[cls.title]],
             T.p[cls.description],
             ]

    def _getChildPerms(self, childAuthor):
        """
        Get the permissions that should be applied to a child of this blurb

        @param childAuthor: the author of the child blurb
        @type childAuthor: L{xmantissa.sharing.Role}

        @return: mapping of roles to interfaces
        @rtype: C{dict} of L{xmantissa.sharing.Role} to C{list} of
        L{zope.interface.Interface}
        """
        # By default, the author is allowed to edit and comment upon their own
        # entries.  Not even the owner of the area gets to edit (although they
        # probably get to delete).
        roleToPerms = {childAuthor: [ihyperbola.IEditable, ihyperbola.ICommentable]}
        currentBlurb = self

        # With regards to permission, children supersede their parents.  For
        # example, if you want to lock comments on a particular entry, you can
        # give it a new FlavorPermission and its parents will no longer
        # override.  We are specifically iterating upwards from the child here
        # for this reason.
        newFlavor = FLAVOR.commentFlavors[self.flavor]
        while currentBlurb is not None:
            for fp in self.store.query(
                FlavorPermission, AND(FlavorPermission.flavor == newFlavor, FlavorPermission.blurb == currentBlurb)
            ):
                # This test makes sure the parent doesn't override by
                # clobbering the entry in the dictionary.
                if fp.role not in roleToPerms:
                    roleToPerms[fp.role] = [namedAny(x.encode("ascii")) for x in fp.permissions]
            currentBlurb = currentBlurb.parent
        return roleToPerms

def tryImports(*names):
    for name in names:
        try:
            return namedAny(name)
        except ObjectNotFound:
            pass
    raise

def make_loop_proxy(params):
    target = params.get('target')
    timeout = params.get('timeout', 60.0)
    if isinstance(target, basestring):
        target = reflect.namedAny(target)
    logger.debug("create loop-rpc-proxy, target is %r", target)
    return LoopRPCProxy(target=target, timeout=timeout)

    def getResults(self):
        """ return resultset
		"""
        if self.isValidRequest():
            if self.dataChanged == False:
                self.results = None
                try:
                    self.modelClass = namedAny(self.requestObj["sourcetable"])
                    self.modelObj = self.modelClass()
                    self.searchstring = self.requestObj["searchstring"]
                    colName = self.requestObj["column"]
                    attr = getattr(self.modelObj, colName)
                    op = self.requestObj["operation"]
                    print "Operation = ", op, "colName = ", colName.strip(), "sourcestring = ", self.searchstring
                    if op == "in":
                        lookup = "%s__contains" % colName.strip()
                    elif op == "eq":
                        lookup = "%s__exact" % colName.strip()
                    elif op == "sw":
                        lookup = "%s__startswith" % colName.strip()
                    elif op == "ew":
                        lookup = "%s__endswith" % colName.strip()

                    query = {lookup: self.searchstring}
                    self.results = list(self.modelClass.objects.filter(**query).values())
                except:
                    e = sys.exc_info()[0]
                    print "Exception in AutocompleteRequest.getResults():", e
                    pass
        else:
            self.results = None
        self.dataChanged = True
        return self.results