inspect.getmembers

__version__ = "1.0.2"
 
from types import FunctionType
from inspect import getmembers, ismethod, isfunction, isclass
from weakref import WeakKeyDictionary
 
__all__ = ["Aspect", "weave", "iswrapped", "unwrap", "MethodHasNoAdviceError"]

	def _weave(obj, weaveDepth):
		methods = getmembers(obj, weaveTest)
		weavables = [member for name, member in getmembers(obj)]
 
		if weavables and weaveDepth < depth:
			weaveDepth += 1
			for weavable in weavables:

	def _unweave(obj, weaveDepth):
		for methodName, method in getmembers(obj, iswrapped):
			method = unwrap(method, all)
			setattr(obj, methodName, method)
 
		weavables = [member for name, member in getmembers(obj)]
 

#!/usr/bin/python
import re
from inspect import getargs, getmembers, ismethod
 
from twisted.python.filepath import FilePath
 
 

def getMethods(klass):
    output = "\n"
    for methodName, method in getmembers(klass, ismethod):
        addMethod = True
        if methodName.startswith("_"):
            addMethod = False
        if methodName.startswith("__"):

from astromate.IPlateSolver import IPlateSolver
from astromate.ICamera import ICamera
from astromate.ITelescope import ITelescope
from inspect import isclass, getmembers
import sys
 
modules ={u'DlgCameraSetup': [0, '', u'astromate/gui/DlgCameraSetup.py'],

    def __populateChoiceList(self, choiceList, moduleRef, baseClass):
        for module in moduleRef.__all__:
            fqmn = moduleRef.__name__+"."+module
            mod_ = __import__(fqmn, globals(), locals())
            solvers = getmembers(sys.modules[fqmn], lambda m: isclass(m) and issubclass(m, baseClass) and m is not baseClass)
            for className, classRef in solvers:
                choiceList.Append(className, classRef)

 
from oop.utils.ctx import NestLevelCounter, contextualize
from threading import local, Lock, RLock
from inspect import isclass, getmembers
import types
 
__metaclass__= type

				SynchClass.__del__(self)
				cls.__del__(self)
 
			for memnm, memval in getmembers(cls, \
					lambda x: isinstance(x, types.MethodType) and x.im_self is None):
				locals[memnm]= contextualize(memval.im_func, \
						lambda *args, **kwds: SynchClass.locks[args[0]])

from astromate.IPlateSolver import IPlateSolver
from astromate.ICamera import ICamera
from astromate.ITelescope import ITelescope
from inspect import isclass, getmembers
import sys
 
modules ={u'DlgCameraSetup': [0, '', u'gui/DlgCameraSetup.py'],

    def __populateChoiceList(self, choiceList, moduleRef, baseClass):
        for module in moduleRef.__all__:
            fqmn = moduleRef.__name__+"."+module
            mod_ = __import__(fqmn, globals(), locals(), "", -1)
            solvers = getmembers(sys.modules[fqmn], lambda m: isclass(m) and issubclass(m, baseClass) and m is not baseClass)
            for className, classRef in solvers:
                choiceList.Append(className, classRef)

import sys
import codecs
from decimal import Decimal
from inspect import getmembers
from itertools import count, izip_longest, izip
from operator import attrgetter, itemgetter
 

def get_option_attributes(obj):
    return getmembers(obj, lambda x: isinstance(x, Option))
 
def get_command_attributes(obj):
    return getmembers(obj, lambda x: isinstance(x, Command))
 
class Command(Node):

import gobject
import gobject.constants
import weakref
from inspect import getmembers, ismethod
 
from weak import weak_connect
from util import append_attr

    def connect_signals(self, obj):
        """
        Connects marked object methods
        """
        for attr, value in getmembers(obj, ismethod):
            for signal, connect_params in getattr(value, 'signals_to_connect', ()):
                id = self.weak_connect(signal, obj, attr, **connect_params)

def connect_external_signals(obj, **kwargs):
    for attr, value in getmembers(obj, ismethod):
        for (sender_name, signal_name), connect_params in getattr(value, 'external_signals_to_connect', ()):
            sender = kwargs[sender_name]
            id = weak_connect(sender, signal_name, obj, attr, **connect_params)
            append_handler_to_object(obj, attr, id, sender, signal_name, sender_name)
 

from operator import attrgetter
from sys import exc_info as _exc_info
from sys import exc_clear as _exc_clear
from inspect import getargspec, getmembers
 
if os.name == "posix":
    from signal import signal, SIGHUP, SIGINT, SIGTERM

    def _registerHandlers(self, manager):
        p = lambda x: callable(x) and getattr(x, "handler", False)
        handlers = [v for k, v in getmembers(self, p)]
 
        for handler in handlers:
            if handler.channels:
                channels = handler.channels

from inspect import getmembers, ismethod
from django.db import models
from django.db.models.base import ModelBase
from django.utils.translation import ugettext_lazy as _
from django.core.exceptions import ImproperlyConfigured
 
from authority.permissions import BasePermission

            return self._choices[model_cls]
        choices = [] + default
        for perm in self.get_permissions_by_model(model_cls):
            for name, check in getmembers(perm, ismethod):
                if name in perm.checks:
                    signature = '%s.%s' % (perm.label, name)
                    label = getattr(check, 'short_description', signature)

import sys
import codecs
from decimal import Decimal
from inspect import getmembers
from itertools import count, izip_longest
from operator import attrgetter, itemgetter
 

def get_option_attributes(obj):
    return getmembers(obj, lambda x: isinstance(x, Option))
 
def get_command_attributes(obj):
    return getmembers(obj, lambda x: isinstance(x, Command))
 
class Command(Node):