Python reflect.qual函数代码示例

 def startFactory(self):
     # disable coredumps
     if resource:
         resource.setrlimit(resource.RLIMIT_CORE, (0,0))
     else:
         log.msg('INSECURE: unable to disable core dumps.')
     if not hasattr(self,'publicKeys'):
         self.publicKeys = self.getPublicKeys()
     for keyType, value in self.publicKeys.items():
         if isinstance(value, str):
             warnings.warn("Returning a mapping from strings to "
                     "strings from getPublicKeys()/publicKeys (in %s) "
                     "is deprecated.  Return a mapping from "
                     "strings to Key objects instead." %
                     (qual(self.__class__)),
                     DeprecationWarning, stacklevel=1)
             self.publicKeys[keyType] = keys.Key.fromString(value)
     if not hasattr(self,'privateKeys'):
         self.privateKeys = self.getPrivateKeys()
     for keyType, value in self.privateKeys.items():
         if not isinstance(value, keys.Key):
             warnings.warn("Returning a mapping from strings to "
                     "PyCrypto key objects from "
                     "getPrivateKeys()/privateKeys (in %s) "
                     "is deprecated.  Return a mapping from "
                     "strings to Key objects instead." %
                     (qual(self.__class__),),
                     DeprecationWarning, stacklevel=1)
             self.privateKeys[keyType] = keys.Key(value)
     if not self.publicKeys or not self.privateKeys:
         raise error.ConchError('no host keys, failing')
     if not hasattr(self,'primes'):
         self.primes = self.getPrimes()

 def startFactory(self):
     """
     Check for public and private keys.
     """
     if not hasattr(self, "publicKeys"):
         self.publicKeys = self.getPublicKeys()
     for keyType, value in self.publicKeys.items():
         if isinstance(value, str):
             warnings.warn(
                 "Returning a mapping from strings to "
                 "strings from getPublicKeys()/publicKeys (in %s) "
                 "is deprecated.  Return a mapping from "
                 "strings to Key objects instead." % (qual(self.__class__)),
                 DeprecationWarning,
                 stacklevel=1,
             )
             self.publicKeys[keyType] = keys.Key.fromString(value)
     if not hasattr(self, "privateKeys"):
         self.privateKeys = self.getPrivateKeys()
     for keyType, value in self.privateKeys.items():
         if not isinstance(value, keys.Key):
             warnings.warn(
                 "Returning a mapping from strings to "
                 "PyCrypto key objects from "
                 "getPrivateKeys()/privateKeys (in %s) "
                 "is deprecated.  Return a mapping from "
                 "strings to Key objects instead." % (qual(self.__class__),),
                 DeprecationWarning,
                 stacklevel=1,
             )
             self.privateKeys[keyType] = keys.Key(value)
     if not self.publicKeys or not self.privateKeys:
         raise error.ConchError("no host keys, failing")
     if not hasattr(self, "primes"):
         self.primes = self.getPrimes()

 def test_product(self):
     self.product = Product(store=self.siteStore)
     self.product.types = [
         n.decode('ascii') for n in [qual(Foo), qual(Baz)]]
     self.product.installProductOn(self.userStore)
     i = self.userStore.findUnique(Installation)
     self.assertEqual(i.types, self.product.types)

 def test_deprecatedPreservesName(self):
     """
     The decorated function has the same name as the original.
     """
     version = Version('Twisted', 8, 0, 0)
     dummy = deprecated(version)(dummyCallable)
     self.assertEqual(dummyCallable.__name__, dummy.__name__)
     self.assertEqual(qual(dummyCallable), qual(dummy))

 def test_createProduct(self):
     """
     Verify that L{ProductConfiguration.createProduct} creates a
     correctly configured L{Product} and returns it.
     """
     conf = ProductConfiguration(store=self.userStore)
     product = conf.createProduct([Foo, Baz])
     self.assertEqual(product.types, [qual(Foo), qual(Baz)])

    def reconfigServiceSlaves(self, new_config):

        timer = metrics.Timer("BotMaster.reconfigServiceSlaves")
        timer.start()

        # arrange slaves by name
        old_by_name = dict([ (s.slavename, s)
                            for s in list(self)
                            if interfaces.IBuildSlave.providedBy(s) ])
        old_set = set(old_by_name.iterkeys())
        new_by_name = dict([ (s.slavename, s)
                            for s in new_config.slaves ])
        new_set = set(new_by_name.iterkeys())

        # calculate new slaves, by name, and removed slaves
        removed_names, added_names = util.diffSets(old_set, new_set)

        # find any slaves for which the fully qualified class name has
        # changed, and treat those as an add and remove
        for n in old_set & new_set:
            old = old_by_name[n]
            new = new_by_name[n]
            # detect changed class name
            if reflect.qual(old.__class__) != reflect.qual(new.__class__):
                removed_names.add(n)
                added_names.add(n)

        if removed_names or added_names:
            log.msg("adding %d new slaves, removing %d" %
                    (len(added_names), len(removed_names)))

            for n in removed_names:
                slave = old_by_name[n]

                del self.slaves[n]
                slave.master = None
                slave.botmaster = None

                wfd = defer.waitForDeferred(
                    defer.maybeDeferred(lambda :
                        slave.disownServiceParent()))
                yield wfd
                wfd.getResult()

            for n in added_names:
                slave = new_by_name[n]
                slave.setServiceParent(self)

                slave.botmaster = self
                slave.master = self.master
                self.slaves[n] = slave

        metrics.MetricCountEvent.log("num_slaves",
                len(self.slaves), absolute=True)

        timer.stop()

    def _checkRoundTrip(self, obj):
        """
        Make sure that an object will properly round-trip through 'qual' and
        'namedAny'.

        Raise a L{RuntimeError} if they aren't.
        """
        tripped = reflect.namedAny(reflect.qual(obj))
        if tripped is not obj:
            raise RuntimeError("importing %r is not the same as %r" %
                               (reflect.qual(obj), obj))

 def makeConfigMenu(self, interface):
     """Make a menu for adding a new object to a collection."""
     l = []
     if 1:
         for realClass in coil.getImplementors(interface):
             cfgClass = coil.getConfiguratorClass(realClass)
             nm = getattr(cfgClass, 'configName', None) or reflect.qual(realClass)
             l.append(['new '+reflect.qual(realClass), 'new '+nm])
     for t in self.dispensers.getDispensers(interface):
         obj, methodName, desc = t
         l.append(['dis %d' % hash(t), desc])
     return l

def spewer(frame, s, ignored):
    """A trace function for sys.settrace that prints every method call."""
    from twisted.python import reflect
    if frame.f_locals.has_key('self'):
        se = frame.f_locals['self']
        if hasattr(se, '__class__'):
            k = reflect.qual(se.__class__)
        else:
            k = reflect.qual(type(se))
        print 'method %s of %s at %s' % (
            frame.f_code.co_name, k, id(se)
        )

    def reconfigServiceWithBuildbotConfig(self, new_config):

        # arrange childs by name
        old_by_name = self.namedServices
        old_set = set(old_by_name.iterkeys())
        new_config_attr = getattr(new_config, self.config_attr)
        if isinstance(new_config_attr, list):
            new_by_name = dict([(s.name, s)
                                for s in new_config_attr])
        elif isinstance(new_config_attr, dict):
            new_by_name = new_config_attr
        else:
            raise TypeError("config.%s should be a list or dictionary" % (self.config_attr))
        new_set = set(new_by_name.iterkeys())

        # calculate new childs, by name, and removed childs
        removed_names, added_names = util.diffSets(old_set, new_set)

        # find any childs for which the fully qualified class name has
        # changed, and treat those as an add and remove
        for n in old_set & new_set:
            old = old_by_name[n]
            new = new_by_name[n]
            # detect changed class name
            if reflect.qual(old.__class__) != reflect.qual(new.__class__):
                removed_names.add(n)
                added_names.add(n)

        if removed_names or added_names:
            log.msg("adding %d new %s, removing %d" %
                    (len(added_names), self.config_attr, len(removed_names)))

            for n in removed_names:
                child = old_by_name[n]

                yield child.disownServiceParent()

            for n in added_names:
                child = new_by_name[n]
                yield child.setServiceParent(self)

        # get a list of child services to reconfigure
        reconfigurable_services = [svc for svc in self]

        # sort by priority
        reconfigurable_services.sort(key=lambda svc: -svc.reconfig_priority)

        for svc in reconfigurable_services:
            if not svc.name:
                raise ValueError("%r: child %r should have a defined name attribute", self, svc)
            config_sibling = new_by_name.get(svc.name)
            yield svc.reconfigServiceWithSibling(config_sibling)

    def versionUpgrade(self):
        """(internal) Do a version upgrade.
        """
        bases = _aybabtu(self.__class__)
        # put the bases in order so superclasses' persistenceVersion methods
        # will be called first.
        bases.reverse()
        bases.append(self.__class__)  # don't forget me!!
        # first let's look for old-skool versioned's
        if self.__dict__.has_key("persistenceVersion"):

            # Hacky heuristic: if more than one class subclasses Versioned,
            # we'll assume that the higher version number wins for the older
            # class, so we'll consider the attribute the version of the older
            # class.  There are obviously possibly times when this will
            # eventually be an incorrect assumption, but hopefully old-school
            # persistenceVersion stuff won't make it that far into multiple
            # classes inheriting from Versioned.

            pver = self.__dict__["persistenceVersion"]
            del self.__dict__["persistenceVersion"]
            highestVersion = 0
            highestBase = None
            for base in bases:
                if not base.__dict__.has_key("persistenceVersion"):
                    continue
                if base.persistenceVersion > highestVersion:
                    highestBase = base
                    highestVersion = base.persistenceVersion
            if highestBase:
                self.__dict__["%s.persistenceVersion" % reflect.qual(highestBase)] = pver
        for base in bases:
            # ugly hack, but it's what the user expects, really
            if Versioned not in base.__bases__ and not base.__dict__.has_key("persistenceVersion"):
                continue
            currentVers = base.persistenceVersion
            pverName = "%s.persistenceVersion" % reflect.qual(base)
            persistVers = self.__dict__.get(pverName) or 0
            if persistVers:
                del self.__dict__[pverName]
            assert persistVers <= currentVers, "Sorry, can't go backwards in time."
            while persistVers < currentVers:
                persistVers = persistVers + 1
                method = base.__dict__.get("upgradeToVersion%s" % persistVers, None)
                if method:
                    log.msg(
                        "Upgrading %s (of %s @ %s) to version %s"
                        % (reflect.qual(base), reflect.qual(self.__class__), id(self), persistVers)
                    )
                    method(self)
                else:
                    log.msg("Warning: cannot upgrade %s to version %s" % (base, persistVers))

def spewer(frame, s, ignored):
    """A trace function for sys.settrace that prints every function or method call."""
    from twisted.python import reflect

    if frame.f_locals.has_key("self"):
        se = frame.f_locals["self"]
        if hasattr(se, "__class__"):
            k = reflect.qual(se.__class__)
        else:
            k = reflect.qual(type(se))
        print "method %s of %s at %s" % (frame.f_code.co_name, k, id(se))
    else:
        print "function %s in %s, line %s" % (frame.f_code.co_name, frame.f_code.co_filename, frame.f_lineno)

    def reconfigServiceSlaves(self, new_config):

        timer = metrics.Timer("BuildSlaveManager.reconfigServiceSlaves")
        timer.start()

        # first we deconfigure everything to let the slaves register again
        yield self.master.data.updates.deconfigureAllBuidslavesForMaster(self.master.masterid)

        # arrange slaves by name
        old_by_name = dict([(s.slavename, s)
                            for s in list(self)
                            if IBuildSlave.providedBy(s)])
        old_set = set(old_by_name.iterkeys())
        new_by_name = dict([(s.slavename, s)
                            for s in new_config.slaves])
        new_set = set(new_by_name.iterkeys())

        # calculate new slaves, by name, and removed slaves
        removed_names, added_names = util.diffSets(old_set, new_set)

        # find any slaves for which the fully qualified class name has
        # changed, and treat those as an add and remove
        for n in old_set & new_set:
            old = old_by_name[n]
            new = new_by_name[n]
            # detect changed class name
            if reflect.qual(old.__class__) != reflect.qual(new.__class__):
                removed_names.add(n)
                added_names.add(n)

        if removed_names or added_names:
            log.msg("adding %d new slaves, removing %d" %
                    (len(added_names), len(removed_names)))

            for n in removed_names:
                slave = old_by_name[n]

                del self.slaves[n]
                slave.master = None

                yield slave.disownServiceParent()

            for n in added_names:
                slave = new_by_name[n]
                yield slave.setServiceParent(self)
                self.slaves[n] = slave

        metrics.MetricCountEvent.log("num_slaves",
                                     len(self.slaves), absolute=True)

        timer.stop()

    def _setUpStore(self):
        """
        Set up a store, install a L{HyperbolaPublicPresence} and its
        dependencies, and create a role
        """
        self.siteStore = Store(filesdir=self.mktemp())
        Mantissa().installSite(
            self.siteStore, u"localhost", u"", generateCert=False)

        # Make it standard so there's no port number in the generated URL.
        # This kind of sucks.  I don't want people assuming SSLPorts are
        # created by Mantissa().installSite().  Oh right, I should add a better
        # API for initializing a Mantissa server. -exarkun
        site = self.siteStore.findUnique(SiteConfiguration)
        ssls = list(site.store.query(SSLPort))
        ssls[0].portNumber = 443

        self.loginSystem = self.siteStore.findUnique(LoginSystem)

        product = Product(store=self.siteStore,
                          types=[qual(HyperbolaPublicPresence)])

        acct = self.loginSystem.addAccount(
            u'user', u'localhost', u'asdf', internal=True)
        self.userStore = acct.avatars.open()

        product.installProductOn(self.userStore)

        self.publicPresence = self.userStore.findUnique(
            HyperbolaPublicPresence)

        self.role = sharing.Role(
            store=self.userStore,
            externalID=u'[email protected]', description=u'foo')

    def spawn(self, hereProto, thereProto, childFDs=None):
        """
        Spawn a subprocess with a connected pair of protocol objects, one in
        the current process, one in the subprocess.

        @param hereProto: a L{Protocol} instance to listen in this process.

        @param thereProto: a top-level class or function that will be imported
            and called in the spawned subprocess.

        @param childFDs: File descriptors to share with the subprocess; same
            format as L{IReactorProcess.spawnProcess}.

        @return: a L{Deferred} that fires when C{hereProto} is ready.
        """
        if not self.running:
            self.pendingSpawns.append((hereProto, thereProto))
            return
        name = qual(thereProto)
        argv = [sys.executable, '-u', '-m', __name__, name]
        self.reactor.spawnProcess(
            BridgeProtocol(self, hereProto), sys.executable,
            argv, os.environ, childFDs=childFDs
        )
        return succeed(hereProto)