示例#1
0
 def set(self,  attr, setObj, options = None):
     
     _type = type(self)
     if attr in _type._dictSetCallbacks:
         _type._dictSetCallbacks[attr](self,setObj, options)
     elif attr in self._dictSetCallbacks:
         self._dictSetCallbacks[attr](setObj, options)            
     else:
         if attr in _type._dictGetCallbacks:
             raise Exception(u"BContainer.set: Attribute " + attr + u" is write-protected! Please implement a set-method to write this \
             attribute or remove the get-method to remove write-protection!" )
         # None or empty string as attribute indicates complex set command with a whole dict to be set.
         elif attr == None or attr == u"": 
             types = inspect.getmro(type(setObj))
             if dict in types:
                 return self.__set_dict(setObj, options)
             else:
                 raise Exception("Error BContainer.set: No valid type for collective set. Use dict!")
         elif options == None: 
             self.__Attributes[attr] = setObj
             if attr == u"listPoints":
                 print self.__Attributes
         elif options == u"-p":
             val = self.get(attr)
             types = inspect.getmro(type(val))
             if (float in types) or (int in types):
                 self.set(attr,  val + setObj)
             elif tuple in types:
                 self.set(attr, tuple([a + b for a, b in zip(val, setObj ) ] ) )
             elif list in types:
                 self.set(attr, [a + b for a, b in zip(val, setObj ) ] )
示例#2
0
def inheritdocstring(name, bases, attrs):
    """
    Use as metaclass to inherit class and method docstrings from parent.
    Adapted from http://stackoverflow.com/questions/13937500/inherit-a-parent-class-docstring-as-doc-attribute
    Use this on classes defined in solver-specific interfaces to inherit docstrings from the high-level interface.
    """
    if '__doc__' not in attrs or not attrs["__doc__"]:
        # create a temporary 'parent' to (greatly) simplify the MRO search
        temp = type('temporaryclass', bases, {})
        for cls in inspect.getmro(temp):
            if cls.__doc__ is not None:
                attrs['__doc__'] = cls.__doc__
                break

    for attr_name, attr in attrs.items():
        if not attr.__doc__:
            for cls in inspect.getmro(temp):
                try:
                    if getattr(cls, attr_name).__doc__ is not None:
                        attr.__doc__ = getattr(cls, attr_name).__doc__
                        break
                except (AttributeError, TypeError):
                    continue

    return type(name, bases, attrs)
def load_style_templates(styled_class, styled_attribute=None):
    """
        Looks for a style template based on the styled_class and styled_attribute. The latter is optional. If no
        file exists for the combination, the code will search for the nonattributed style. If that fails, the code
        will continue the search with each ancestor of the styled_class, with and without attribute, until a match is
        found.
    :param styled_class: The class that represents the table being styled
    :param styled_attribute: Optional. The attribute being styled.
    :return:
    """
    for cls in getmro(styled_class):
        if styled_attribute:
            attributed_cartocss_file = FOOTPRINT_TEMPLATE_DIR + "/maps/%s__%s.cartocss" % (cls.__name__, styled_attribute)
            nonattributed_cartocss_file = attributed_cartocss_file.split('__')[0]+'.cartocss'
        else:
            attributed_cartocss_file = None
            nonattributed_cartocss_file = FOOTPRINT_TEMPLATE_DIR + "/maps/%s.cartocss" % cls.__name__

        for cartocss_file in map(lambda f: f, [attributed_cartocss_file, nonattributed_cartocss_file]):
            if os.path.exists(cartocss_file):
                cartocss_style_template = open(
                    cartocss_file,
                    "r").read()

                css_file = cartocss_file.replace('.cartocss', '.css')
                standardcss_style_template = open(
                    css_file, "r").read()
                return dict(cartocss=cartocss_style_template, css=standardcss_style_template)
    raise Exception("No style file found for style_class %s (nor its ancestors) %s %s without styled_attribute %s" %
                    (styled_class.__name__,
                     ', '.join(map(lambda cls: cls.__name__, getmro(styled_class))),
                     'neither with nor' if styled_attribute else '',
                     styled_attribute or ''))
    def test_create_instance(self):
        """
        tests the built-in get_instance() method
        """
        app = self.engine.apps["test_app"]
        hook_expression = app.get_setting("test_hook_std")
        instance_1 = app.create_hook_instance(hook_expression)
        self.assertEqual(instance_1.second_method(another_dummy_param=True), True)
        instance_2 = app.create_hook_instance(hook_expression)
        self.assertNotEqual(instance_1, instance_2)

        # ensure if no base_class arg supplied we have Hook as the base class
        base_classes = inspect.getmro(instance_2.__class__)
        self.assertEqual(base_classes[-2], tank.Hook)
        self.assertEqual(base_classes[-1], object)

        # class to inject as a custom base class
        class Foobar(tank.Hook):
            pass

        # this hook has to be new style hook using `sgtk.get_hook_baseclass`
        test_hook_expression = "{config}/more_hooks/config_test_hook.py"

        # create an instance with an in injected base class
        instance_3 = app.create_hook_instance(test_hook_expression, base_class=Foobar)

        # get the resolution order of the base classes
        base_classes = inspect.getmro(instance_3.__class__)

        # ensure the last 3 classes in the order are Foobar, Hook, object
        self.assertEqual(base_classes[-3], Foobar)
        self.assertEqual(base_classes[-2], tank.Hook)
        self.assertEqual(base_classes[-1], object)
示例#5
0
def _GetClassImplementedInterfaces(class_):
    cache = __ImplementedInterfacesCache.GetSingleton()
    result = cache.GetResult(class_)
    if result is not None:
        return result

    result = set()

    mro = inspect.getmro(class_)

    for c in mro:
        interfaces = getattr(c, '__implements__', ())
        for interface in interfaces:
            interface_mro = inspect.getmro(interface)

            for interface_type in interface_mro:
                if interface_type in [Interface, object]:
                    # Ignore basic types
                    continue
                result.add(interface_type)

    result = frozenset(result)

    cache.SetResult(class_, result)
    return result
示例#6
0
def samegraph(A,B):
    "Returns true if the MRO's of A and B have an intersection."
    mro_A = sets.Set(inspect.getmro(A))
    mro_A.discard(object)
    mro_B = sets.Set(inspect.getmro(B))
    mro_B.discard(object)
    return bool(mro_A & mro_B)
示例#7
0
    def equals(self, other):
        if other is None:
            return False

        # Hack here, we cannot just check the type here,
        # many types like Column is created dynamically,
        # so we check the class name and the sub classes.
        if (
            self.__class__.__name__ != other.__class__.__name__
            or inspect.getmro(type(self))[1:] != inspect.getmro(type(self))[1:]
        ):
            return False

        def cmp(x, y):
            if isinstance(x, Node):
                res = x.equals(y)
            elif isinstance(y, Node):
                res = y.equals(y)
            elif isinstance(x, (tuple, list)) and isinstance(y, (tuple, list)):
                res = all(map(cmp, x, y))
            else:
                res = x == y
            return res

        return all(map(cmp, self._slot_values(), other._slot_values()))
示例#8
0
	def analyze_param(self,param):
		self.temp_require_multipart = False
		if [list,tuple].count(type(param)):
			# Parameter seems to be an array
			if len(param)!=1:
				raise NeedToDefineParseTimeException("Only one element is allowed when defining ladon arrays")
			if type(param[0])!=type:
				raise NeedToDefineParseTimeException("Only types are allowed as list-element when defining an array")
			
			if inspect.getmro(param[0]).count(LadonType):
				self.analyze_class(param[0])
			else:
				self.add_primitive_type(param[0])
				if param[0]==attachment:
					self.temp_require_multipart = True

			self.has_lists = True
			if not self.type_order.count([param[0]]):
				self.type_order += [[param[0]]]
		elif type(param)==type:
			if inspect.getmro(param).count(LadonType):
				self.analyze_class(param)
			else:
				self.add_primitive_type(param)
				if param==attachment:
					self.temp_require_multipart = True
		else:
			raise NeedToDefineParseTimeException("Ladonized param definition must be a LadonType or iterable")
		return self.temp_require_multipart
示例#9
0
 def __init__(self, lhs, rhs):
     self.lhs = lhs
     self.rhs = rhs 
     if types.IEvent in inspect.getmro(type(lhs)):
         event.subscribe(lhs, _(self).fire, self)
     if types.IEvent in inspect.getmro(type(rhs)):
         event.subscribe(rhs, _(self).fire, self)
示例#10
0
def get_class_that_defined_method(meth):
    """
    Return the class that defines a method.

    Arguments:
        meth (str): Class method.

    Returns:
        class: Class object, or None if not a class method.
    """
    if sys.version_info >= (3, 0):
        # Written by @Yoel http://stackoverflow.com/a/25959545
        if inspect.ismethod(meth):
            for cls in inspect.getmro(meth.__self__.__class__):
               if cls.__dict__.get(meth.__name__) is meth:
                    return cls
            meth = meth.__func__ # fallback to __qualname__ parsing
        if inspect.isfunction(meth):
            cls = getattr(inspect.getmodule(meth),
                          meth.__qualname__.split('.<locals>', 1)[0].rsplit('.', 1)[0])
            if isinstance(cls, type):
                return cls
    else:
        try:
            # Writted by @Alex Martelli http://stackoverflow.com/a/961057
            for cls in inspect.getmro(meth.im_class):
                if meth.__name__ in cls.__dict__:
                    return cls
        except AttributeError:
            return None
    return None
示例#11
0
    def get_actions(cls):
        class_stack = inspect.getmro(cls)[::-1]

        cls.actions = cls.class_actions
        cls.actions_forms = {}
        cls.action_templates = {}

        for base_class in class_stack:
            check_classes = inspect.getmro(base_class)
            if base_class != cls and HttpAPIView in check_classes:
                if 'class_actions' in base_class.__dict__:
                    for action in base_class.class_actions:
                        if action not in cls.actions:
                            cls.actions.append(action)
                if 'class_actions_forms' in base_class.__dict__:
                    for action in base_class.class_actions_forms:
                        cls.actions_forms[action] = base_class.class_actions_forms[action]
                if 'class_action_templates' in base_class.__dict__:
                    for action in base_class.class_action_templates:
                        cls.action_templates[action] = base_class.class_action_templates[action]
        
        if 'class_actions_forms' in cls.__dict__:
            cls.actions_forms.update(cls.class_actions_forms)
        
        if 'class_action_templates' in cls.__dict__:
            cls.action_templates.update(cls.class_action_templates)
        
        return cls.actions
示例#12
0
 def paste(self, obj, name = None, bForceOverwrite = False, pathkey = None, bHashById = False):
     
     types = inspect.getmro(type(obj))
     if BContainer in types:
         if bHashById == True:
              
             if PyLinXData.PyLinXDataObjects.PX_IdObject in types:                    
                 key = obj.ID
             else:
                 key = obj.get("Name")
         else:
             key = obj.get("Name")
     else:
         if name == None:
             # TODO: Error-Handling has to be implemented 
             print "Error BContainer.py: No key for paste-function!"
             return
         
     if key in self.__Body.keys():
         if bForceOverwrite:
             self.__Body[key] = obj
             obj.__parent = self                
         else:
             '''
             If an object with corresponding Name exists, then an error message should be returned
             TODO: Has to be impemented
             '''
             pass
     
     else:
         self.__Body[key] = obj
         types = inspect.getmro(type(obj))
         if(BContainer in types):
             obj.__parent = self
 def test_question_pages_without_questions_are_filtered_out(self):
     # empty_page
     QuestionPage.objects.create()
     wizard = TestWizard.wizard_factory()()
     self.assertEqual(len(wizard.form_list), 2)
     self.assertIn(QuestionPageForm, inspect.getmro(wizard.form_list[0]))
     self.assertNotIn(TextPageForm, inspect.getmro(wizard.form_list[-1]))
示例#14
0
def classname_from_method(method):
    """
    Finds the requesting class of a method(bound or unbound)
    :param method: method to use
    :return: the class of the given method
    """
    try:
        for cls in inspect.getmro(method.im_class):
            if method.__name__ in cls.__dict__:
                return cls.__name__
    except AttributeError:
        try:
            if inspect.ismethod(method):
                for cls in inspect.getmro(method.__self__.__class__):
                    if cls.__dict__.get(method.__name__) is method:
                        return cls.__name__
                method = method.__func__
            if inspect.isfunction(method):
                cls = getattr(inspect.getmodule(method),
                              method.__qualname__.split('.<locals>', 1)[0]
                              .rsplit('.', 1)[0])
                if isinstance(cls, type):
                    return cls.__name__
            return ''
        except AttributeError:
            return ''
示例#15
0
 def process(self, event, parameter):
     """Process an event by calling the registered handler if there's one.
     """
     method = self.handlers.get(event, None)
     if method:
         # if the method is a method of a class deriving from EventProcessor
         # we pass just parameter
         if (inspect.ismethod(method) and 
             (EventProcessor in inspect.getmro(method.im_class) or
              galry.InteractionManager in inspect.getmro(method.im_class))):
             method(parameter)
         else:
             fig = self.interaction_manager.figure
             # HACK: give access to paint_manager.set_data to the figure,
             # so that event processors can change the data
             # BAD SMELL HERE :(
             if not hasattr(fig, 'set_data'):
                 fig.set_data = self.parent.paint_manager.set_data
                 fig.copy_texture = self.parent.paint_manager.copy_texture
                 fig.set_rendering_options = self.parent.paint_manager.set_rendering_options
                 fig.get_processor = self.interaction_manager.get_processor
                 fig.get_visual = self.paint_manager.get_visual
                 fig.process_interaction = self.parent.process_interaction
             
             fig.resizeGL = self.parent.paint_manager.resizeGL
             # here, we are using the high level interface and figure
             # is the Figure object we pass to this function
             method(fig, parameter)
示例#16
0
def common_bases(seq):
    """http://stackoverflow.com/questions/13252333/python-check-if-all-elements-of-a-list-are-the-same-type"""
    iseq = iter(seq)
    bases = set(inspect.getmro(type(next(iseq))))
    for item in iseq:
        bases = bases.intersection(inspect.getmro(type(item)))
        if not bases:
           break
    return bases
示例#17
0
def ctype_struct_generator(module):
    module_structs = inspect.getmembers(module, predicate=(
        lambda x: (inspect.isclass(x) and ctypes.Structure in inspect.getmro(x))))

    # Sort by the line number in which the class appears
    module_structs.sort(key=lambda x: inspect.getsourcelines(x[1])[1])
    for name, obj in module_structs:
            if ctypes.Structure in inspect.getmro(obj) and hasattr(obj, '_fields_'):
                yield obj
示例#18
0
 def __keyPressEvent_delete():
 
     #keys = self.activeGraphics.getChildKeys()
     objectsInFocus = list(self.activeGraphics.objectsInFocus)
     setDelete = set([])
     #for key in keys:
     for key in self.activeGraphics._BContainer__Body:    
         element = self.activeGraphics.getb(key)
         types = inspect.getmro(type(element))
         if (PyLinXDataObjects.PX_PlottableConnector in types):
             # deleting all connectors which are connected to an object, that is deleted
             elem0 = element.elem0
             if elem0 in objectsInFocus:
                 setDelete.add(element.ID)
             elem1 = element.elem1
             if elem1 in objectsInFocus:
                 setDelete.add(element.ID)
         # deleting all objects in focus
         if element in objectsInFocus:
             setDelete.add(element.ID)
             
     # removing the deleted connectors from the list of connected pins of the connected elements
     for _id in setDelete:
         element = self.activeGraphics.getb(_id)
         types = inspect.getmro(type(element))
         if PyLinXDataObjects.PX_PlottableConnector in types:
             idxInPin = element.idxInPin
             idxOutPin = element.idxOutPin
             elem0 = element.elem0
             elem1 = element.elem1
             #print "elem0: ", elem0
             #print "elem1: ", elem1
             setIdxConnectedOutPins = elem0.get("setIdxConnectedOutPins")
             setIdxConnectedInPins  = elem1.get("setIdxConnectedInPins")
             #print "setIdxConnectedOutPins: ", setIdxConnectedOutPins 
             #print "setIdxConnectedInPins: ", setIdxConnectedInPins
             #print "idxOutPin: ", idxOutPin
             #print "idxInPin: ", idxInPin
             if idxOutPin in setIdxConnectedOutPins: 
                 setIdxConnectedOutPins.remove(idxOutPin)
             if idxInPin in setIdxConnectedInPins: 
                 setIdxConnectedInPins.remove(idxInPin)
             #print "setIdxConnectedOutPins (1): ", setIdxConnectedOutPins 
             #print "setIdxConnectedInPins (1): ", setIdxConnectedInPins
             elem0.set("setIdxConnectedOutPins", setIdxConnectedOutPins)
             elem1.set("setIdxConnectedInPins", setIdxConnectedInPins)
             
     DataDictionary = self.rootContainer.getb("DataDictionary")
     bDictionary = (DataDictionary != None)
     for element in setDelete:
         if bDictionary:
             elementObject = self.activeGraphics.getb(element)
             name = elementObject.get("Name")
             if name in DataDictionary:
                 DataDictionary.pop(name)
         self.activeGraphics.delete(element)
     self.repaint()
示例#19
0
文件: game.py 项目: wlaub/pybld
    def loadModules(self):
        """
        Loads rooms from all modules in rooms/*.py. and sets
        inventory to the room named 'inv', which must exist.
        """
        with open("logs/gameload", "w") as f:
            roomFiles = os.listdir('./rooms')
            items = []
            combos = []
            for name in roomFiles:
                modName, modExt = os.path.splitext(name)
                if modExt == '.py' and modName != '__init__':
                    f.write("loading module {}\n".format(name))
                
                    mod = importlib.import_module("rooms."+modName)

                    for val in dir(mod):
                        try:
                            thing = mod.__dict__[val]
                            if Room in inspect.getmro(thing):
                                f.write("Found Room\n")
                                self._addRoom(thing())
                            if Item in inspect.getmro(thing):
                                f.write("Found item\n")
                                try:
                                    nItem = thing()
                                    items.append(nItem)
                                    self._addItem(nItem)
                                except Exception as e:
                                    f.write(str(e)+'\n')
                            elif Combo in inspect.getmro(thing):
                                try:
                                    nCombo = thing()
                                    combos.append(nCombo)
                                except Exception as e:
                                    f.write(str(e)+'\n')
 
                        except Exception as e:
                            pass

            for item in items:
                room = self.rooms[item.loc]
                room.items[item.name] = item
                item.room = room
                f.write("Adding item {} to room {}\n".format(item.name, room.name))

            for combo in combos:
                room = self.rooms[combo.loc]
                room.combos[combo.name] = combo
                combo.room = room
                f.write("Adding combo {} to room {}\n".format(combo.name, room.name))

            self.inv = self.rooms['inv']

            for name, desc, qty in achieve.achievements:
                self.achievements[name] = Achievement(desc, qty)
示例#20
0
 def receiveMessage(self, message, sender):
     for each in inspect.getmro(message.__class__):
         methodName = 'receiveMsg_%s'%each.__name__
         if hasattr(self, methodName):
             for klasses in inspect.getmro(self.__class__):
                 if hasattr(klasses, methodName):
                     if getattr(klasses, methodName)(self, message, sender) != self.SUPER:
                         return
     if hasattr(self, 'receiveUnrecognizedMessage'):
         self.receiveUnrecognizedMessage(message, sender)
示例#21
0
def get_adapter_path(obj, to_cls):
    """
    Returns the adapter path that would be used to adapt `obj` to `to_cls`.
    """
    from_cls = type(obj)
    key = (from_cls, to_cls)
    if key not in __mro__:
        __mro__[key] = list(itertools.product(inspect.getmro(from_cls), inspect.getmro(to_cls)))

    return __mro__[key]
示例#22
0
 def __init__(self, cond, ifpart, elsepart):
     self.cond = cond
     self.ifpart = ifpart
     self.elsepart = elsepart
     if types.IEvent in inspect.getmro(type(cond)):
         event.subscribe(cond, _(self).fire, self)
     if types.IEvent in inspect.getmro(type(ifpart)):
         event.subscribe(ifpart, _(self).fire, self)
     if types.IEvent in inspect.getmro(type(elsepart)):
         event.subscribe(elsepart, _(self).fire, self)
示例#23
0
def test_inheritance():
    """Test that inheritance is preserved from object"""
    assert object in getmro(BaseEventEmitter)

    class example(BaseEventEmitter):
        def __init__(self):
            super(example, self).__init__()

    assert BaseEventEmitter in getmro(example)
    assert object in getmro(example)
示例#24
0
文件: stubout.py 项目: openstack/mox3
    def SmartSet(self, obj, attr_name, new_attr):
        """Replace obj.attr_name with new_attr.

        This method is smart and works at the module, class, and instance level
        while preserving proper inheritance. It will not stub out C types
        however unless that has been explicitly allowed by the type.

        This method supports the case where attr_name is a staticmethod or a
        classmethod of obj.

        Notes:
          - If obj is an instance, then it is its class that will actually be
            stubbed. Note that the method Set() does not do that: if obj is
            an instance, it (and not its class) will be stubbed.
          - The stubbing is using the builtin getattr and setattr. So, the
            __get__ and __set__ will be called when stubbing (TODO: A better
            idea would probably be to manipulate obj.__dict__ instead of
            getattr() and setattr()).

        Raises AttributeError if the attribute cannot be found.
        """
        if (inspect.ismodule(obj) or
                (not inspect.isclass(obj) and attr_name in obj.__dict__)):
            orig_obj = obj
            orig_attr = getattr(obj, attr_name)

        else:
            if not inspect.isclass(obj):
                mro = list(inspect.getmro(obj.__class__))
            else:
                mro = list(inspect.getmro(obj))

            mro.reverse()

            orig_attr = None

            for cls in mro:
                try:
                    orig_obj = cls
                    orig_attr = getattr(obj, attr_name)
                except AttributeError:
                    continue

        if orig_attr is None:
            raise AttributeError("Attribute not found.")

        # Calling getattr() on a staticmethod transforms it to a 'normal'
        # function. We need to ensure that we put it back as a staticmethod.
        old_attribute = obj.__dict__.get(attr_name)
        if (old_attribute is not None and
                isinstance(old_attribute, staticmethod)):
            orig_attr = staticmethod(orig_attr)

        self.stubs.append((orig_obj, attr_name, orig_attr))
        setattr(orig_obj, attr_name, new_attr)
示例#25
0
def commonbase(cls1, cls2):   # XXX single inheritance only  XXX hum
    l1 = inspect.getmro(cls1)
    l2 = inspect.getmro(cls2) 
    if l1[-1] != object: 
        l1 = l1 + (object,) 
    if l2[-1] != object: 
        l2 = l2 + (object,) 
    for x in l1: 
        if x in l2: 
            return x 
    assert 0, "couldn't get to commonbase of %r and %r" % (cls1, cls2)
示例#26
0
def create_representation(layer_name,db,rep):
    mod = __import__('layers.'+layer_name)
    for name, obj in inspect.getmembers(mod):
        for name2,obj2 in inspect.getmembers(obj):
            if inspect.isclass(obj2) and \
               name2 == layer_name and \
               RepresentationLayer in inspect.getmro(obj2) and \
               len(inspect.getmro(obj2)) > 1:
                    layer = obj2(name2)
                    layer.create(db,rep)
                    return layer
    return None
示例#27
0
def get_attrs(node):
    from .core import Node

    tp = type(node) if not inspect.isclass(node) else node

    if inspect.getmro(tp) is None:
        tp = type(tp)

    return tuple(compat.OrderedDict.fromkeys(
        it for it in
        itertools.chain(*(cls.__slots__ for cls in inspect.getmro(tp) if issubclass(cls, Node)))
        if not it.startswith('__')))
示例#28
0
    def get_like_type_score(self, related):
        """

        :rtype: decimal.Decimal.
        """
        s_tree  = inspect.getmro(self.content_type.model_class())
        r_tree  = inspect.getmro(related.content_type.model_class())
        shared  = len(set(s_tree) & set(r_tree))
        total   = len(set(s_tree + r_tree))

        return decimal.Decimal(
            (float(shared) / float(total)) * LIKE_TYPE_FACTOR
        )
示例#29
0
def _registered_kl(type_a, type_b):
  """Get the KL function registered for classes a and b."""
  hierarchy_a = inspect.getmro(type_a)
  hierarchy_b = inspect.getmro(type_b)
  dist_to_children = None
  kl_fn = None
  for mro_to_a, parent_a in enumerate(hierarchy_a):
    for mro_to_b, parent_b in enumerate(hierarchy_b):
      candidate_dist = mro_to_a + mro_to_b
      candidate_kl_fn = _DIVERGENCES.get((parent_a, parent_b), None)
      if not kl_fn or (candidate_kl_fn and candidate_dist < dist_to_children):
        dist_to_children = candidate_dist
        kl_fn = candidate_kl_fn
  return kl_fn
示例#30
0
def isInstanceOf(obj,objType):
  """?? Is the object an instance (or derived from) of the class objType?"""

  # Allow a list or tuple of objects to be passed
  if iterable(objType):
    if type(obj) is InstanceType:
      mro = inspect.getmro(obj.__class__)
      for ot in objType:
        if ot in mro: return True

  # If its not iterable do it in one line
  if type(obj) is InstanceType and objType in inspect.getmro(obj.__class__): return True

  return False
示例#31
0
    def convert(self, model, mapper, prop, field_args, db_session=None):
        if not hasattr(prop, 'columns') and not hasattr(prop, 'direction'):
            return
        elif not hasattr(prop, 'direction') and len(prop.columns) != 1:
            raise TypeError('Do not know how to convert multiple-column ' +
                            'properties currently')

        kwargs = {
            'validators': [],
            'filters': [],
            'default': None,
        }

        converter = None
        column = None
        types = None

        if not hasattr(prop, 'direction'):
            column = prop.columns[0]
            # Support sqlalchemy.schema.ColumnDefault, so users can benefit
            # from  setting defaults for fields, e.g.:
            #   field = Column(DateTimeField, default=datetime.utcnow)

            default = getattr(column, 'default', None)

            if default is not None:
                # Only actually change default if it has an attribute named
                # 'arg' that's callable.
                callable_default = getattr(default, 'arg', None)

                if callable_default is not None:
                    # ColumnDefault(val).arg can be also a plain value
                    default = callable_default(None) if callable(
                        callable_default) else callable_default

            kwargs['default'] = default

            if column.nullable:
                kwargs['validators'].append(validators.Optional())
            else:
                kwargs['validators'].append(validators.Required())

            if db_session and column.unique:
                kwargs['validators'].append(
                    Unique(lambda: db_session, model, column))

            if self.use_mro:
                types = inspect.getmro(type(column.type))
            else:
                types = [type(column.type)]

            for col_type in types:
                type_string = '%s.%s' % (col_type.__module__,
                                         col_type.__name__)
                if type_string.startswith('sqlalchemy'):
                    type_string = type_string[11:]

                if type_string in self.converters:
                    converter = self.converters[type_string]
                    break
            else:
                for col_type in types:
                    if col_type.__name__ in self.converters:
                        converter = self.converters[col_type.__name__]
                        break
                else:
                    raise ModelConversionError(
                        'Could not find field converter for %s (%r).' %
                        (prop.key, types[0]))
        else:
            # We have a property with a direction.
            if not db_session:
                raise ModelConversionError(
                    "Cannot convert field %s, need DB session." % prop.key)

            foreign_model = prop.mapper.class_

            nullable = True
            for pair in prop.local_remote_pairs:
                if not pair[0].nullable:
                    nullable = False

            kwargs.update({
                'allow_blank':
                nullable,
                'query_factory':
                lambda: db_session.query(foreign_model).all()
            })

            converter = self.converters[prop.direction.name]

        if field_args:
            kwargs.update(field_args)

        return converter(model=model,
                         mapper=mapper,
                         prop=prop,
                         column=column,
                         field_args=kwargs)
示例#32
0
 def __init__(cls, name, bases, dct):
     super(MPITestCaseMeta, cls).__init__(name, bases, dct)
     parent = getmro(cls)[1]
     for n, obj in parent.__dict__.items():
         if n.startswith('assert') or n == 'fail':
             setattr(cls, 'collective_' + n, mpi_fail_if_any(obj))
示例#33
0
    def __init__(self,
                 exc_value=None,
                 exc_type=None,
                 exc_tb=None,
                 captureVars=False):
        """
        Initialize me with an explanation of the error.

        By default, this will use the current C{exception}
        (L{sys.exc_info}()).  However, if you want to specify a
        particular kind of failure, you can pass an exception as an
        argument.

        If no C{exc_value} is passed, then an "original" C{Failure} will
        be searched for. If the current exception handler that this
        C{Failure} is being constructed in is handling an exception
        raised by L{raiseException}, then this C{Failure} will act like
        the original C{Failure}.

        For C{exc_tb} only L{traceback} instances or L{None} are allowed.
        If L{None} is supplied for C{exc_value}, the value of C{exc_tb} is
        ignored, otherwise if C{exc_tb} is L{None}, it will be found from
        execution context (ie, L{sys.exc_info}).

        @param captureVars: if set, capture locals and globals of stack
            frames.  This is pretty slow, and makes no difference unless you
            are going to use L{printDetailedTraceback}.
        """
        global count
        count = count + 1
        self.count = count
        self.type = self.value = tb = None
        self.captureVars = captureVars

        if isinstance(exc_value, str) and exc_type is None:
            raise TypeError("Strings are not supported by Failure")

        stackOffset = 0

        if exc_value is None:
            exc_value = self._findFailure()

        if exc_value is None:
            self.type, self.value, tb = sys.exc_info()
            if self.type is None:
                raise NoCurrentExceptionError()
            stackOffset = 1
        elif exc_type is None:
            if isinstance(exc_value, Exception):
                self.type = exc_value.__class__
            else:  #allow arbitrary objects.
                self.type = type(exc_value)
            self.value = exc_value
        else:
            self.type = exc_type
            self.value = exc_value
        if isinstance(self.value, Failure):
            self.__dict__ = self.value.__dict__
            return
        if tb is None:
            if exc_tb:
                tb = exc_tb
            elif _PY3:
                tb = self.value.__traceback__

        frames = self.frames = []
        stack = self.stack = []

        # added 2003-06-23 by Chris Armstrong. Yes, I actually have a
        # use case where I need this traceback object, and I've made
        # sure that it'll be cleaned up.
        self.tb = tb

        if tb:
            f = tb.tb_frame
        elif not isinstance(self.value, Failure):
            # we don't do frame introspection since it's expensive,
            # and if we were passed a plain exception with no
            # traceback, it's not useful anyway
            f = stackOffset = None

        while stackOffset and f:
            # This excludes this Failure.__init__ frame from the
            # stack, leaving it to start with our caller instead.
            f = f.f_back
            stackOffset -= 1

        # Keeps the *full* stack.  Formerly in spread.pb.print_excFullStack:
        #
        #   The need for this function arises from the fact that several
        #   PB classes have the peculiar habit of discarding exceptions
        #   with bareword "except:"s.  This premature exception
        #   catching means tracebacks generated here don't tend to show
        #   what called upon the PB object.

        while f:
            if captureVars:
                localz = f.f_locals.copy()
                if f.f_locals is f.f_globals:
                    globalz = {}
                else:
                    globalz = f.f_globals.copy()
                for d in globalz, localz:
                    if "__builtins__" in d:
                        del d["__builtins__"]
                localz = localz.items()
                globalz = globalz.items()
            else:
                localz = globalz = ()
            stack.insert(0, (
                f.f_code.co_name,
                f.f_code.co_filename,
                f.f_lineno,
                localz,
                globalz,
            ))
            f = f.f_back

        while tb is not None:
            f = tb.tb_frame
            if captureVars:
                localz = f.f_locals.copy()
                if f.f_locals is f.f_globals:
                    globalz = {}
                else:
                    globalz = f.f_globals.copy()
                for d in globalz, localz:
                    if "__builtins__" in d:
                        del d["__builtins__"]
                localz = list(localz.items())
                globalz = list(globalz.items())
            else:
                localz = globalz = ()
            frames.append((
                f.f_code.co_name,
                f.f_code.co_filename,
                tb.tb_lineno,
                localz,
                globalz,
            ))
            tb = tb.tb_next
        if inspect.isclass(self.type) and issubclass(self.type, Exception):
            parentCs = getmro(self.type)
            self.parents = list(map(reflect.qual, parentCs))
        else:
            self.parents = [self.type]
def find_subclasses_in_module(module, base_cls):
    """Finds subclasses of given class in the module."""
    name_values = inspect.getmembers(
        module, lambda x: inspect.isclass(x) and not inspect.isabstract(x) and
        (base_cls in inspect.getmro(x)))
    return [v for _, v in name_values]
示例#35
0
  def SmartSet(self, obj, attr_name, new_attr):
    """Replace obj.attr_name with new_attr.

    This method is smart and works at the module, class, and instance level
    while preserving proper inheritance. It will not stub out C types however
    unless that has been explicitly allowed by the type.

    This method supports the case where attr_name is a staticmethod or a
    classmethod of obj.

    Notes:
      - If obj is an instance, then it is its class that will actually be
        stubbed. Note that the method Set() does not do that: if obj is
        an instance, it (and not its class) will be stubbed.
      - The stubbing is using the builtin getattr and setattr. So, the __get__
        and __set__ will be called when stubbing (TODO: A better idea would
        probably be to manipulate obj.__dict__ instead of getattr() and
        setattr()).

    Args:
      obj: The object whose attributes we want to modify.
      attr_name: The name of the attribute to modify.
      new_attr: The new value for the attribute.

    Raises:
      AttributeError: If the attribute cannot be found.
    """
    if (inspect.ismodule(obj) or
        (not inspect.isclass(obj) and attr_name in obj.__dict__)):
      orig_obj = obj
      orig_attr = getattr(obj, attr_name)
    else:
      if not inspect.isclass(obj):
        mro = list(inspect.getmro(obj.__class__))
      else:
        mro = list(inspect.getmro(obj))

      mro.reverse()

      orig_attr = None
      found_attr = False

      for cls in mro:
        try:
          orig_obj = cls
          orig_attr = getattr(obj, attr_name)
          found_attr = True
        except AttributeError:
          continue

      if not found_attr:
        raise AttributeError('Attribute not found.')

    # Calling getattr() on a staticmethod transforms it to a 'normal' function.
    # We need to ensure that we put it back as a staticmethod.
    old_attribute = obj.__dict__.get(attr_name)
    if old_attribute is not None and isinstance(old_attribute, staticmethod):
      orig_attr = staticmethod(orig_attr)

    self.stubs.append((orig_obj, attr_name, orig_attr))
    setattr(orig_obj, attr_name, new_attr)
示例#36
0
def names_and_fields(self, _fields_, superclass, anonymous_fields=None):
    # _fields_: list of (name, ctype, [optional_bitfield])
    if isinstance(_fields_, tuple):
        _fields_ = list(_fields_)
    for f in _fields_:
        tp = f[1]
        if not isinstance(tp, _CDataMeta):
            raise TypeError("Expected CData subclass, got %s" % (tp, ))
        if isinstance(tp, StructOrUnionMeta):
            tp._make_final()
        if len(f) == 3:
            if (not hasattr(tp, '_type_') or not isinstance(tp._type_, str)
                    or tp._type_ not in "iIhHbBlLqQ"):
                #XXX: are those all types?
                #     we just dont get the type name
                #     in the interp level thrown TypeError
                #     from rawffi if there are more
                raise TypeError('bit fields not allowed for type ' +
                                tp.__name__)

    all_fields = []
    for cls in reversed(inspect.getmro(superclass)):
        # The first field comes from the most base class
        all_fields.extend(getattr(cls, '_fields_', []))
    all_fields.extend(_fields_)
    names = [f[0] for f in all_fields]
    rawfields = []
    for f in all_fields:
        if len(f) > 2:
            rawfields.append((f[0], f[1]._ffishape_, f[2]))
        else:
            rawfields.append((f[0], f[1]._ffishape_))

    # hack for duplicate field names
    already_seen = set()
    names1 = names
    names = []
    for f in names1:
        if f not in already_seen:
            names.append(f)
            already_seen.add(f)
    already_seen = set()
    for i in reversed(range(len(rawfields))):
        if rawfields[i][0] in already_seen:
            rawfields[i] = (('$DUP%d$%s' % (i, rawfields[i][0]), ) +
                            rawfields[i][1:])
        already_seen.add(rawfields[i][0])
    # /hack

    _set_shape(self, rawfields, self._is_union)

    fields = {}
    for i, field in enumerate(all_fields):
        name = field[0]
        value = field[1]
        is_bitfield = (len(field) == 3)
        fields[name] = Field(name, self._ffistruct_.fieldoffset(name),
                             self._ffistruct_.fieldsize(name), value, i,
                             is_bitfield)

    if anonymous_fields:
        resnames = []
        for i, field in enumerate(all_fields):
            name = field[0]
            value = field[1]
            is_bitfield = (len(field) == 3)
            startpos = self._ffistruct_.fieldoffset(name)
            if name in anonymous_fields:
                for subname in value._names_:
                    resnames.append(subname)
                    subfield = getattr(value, subname)
                    relpos = startpos + subfield.offset
                    subvalue = subfield.ctype
                    fields[subname] = Field(subname,
                                            relpos,
                                            subvalue._sizeofinstances(),
                                            subvalue,
                                            i,
                                            is_bitfield,
                                            inside_anon_field=fields[name])
            else:
                resnames.append(name)
        names = resnames
    self._names_ = names
    for name, field in fields.items():
        setattr(self, name, field)
示例#37
0
    def _stop_buggy_background_worker_qthreads(widget):
        """
        There is a bug in the worker/threading code in the BrowserWidget that was fixed
        in v0.1.17 and the tk-multi-workfiles Save As dialog that was fixed in v0.3.22.  
        
        The bug results in a fatal crash if the BrowserWidget is cleaned up properly or
        if the Save As dialog is closed before the thread has completely stopped!  
        
        However, because the engine was previously not releasing any dialogs, the cleanup 
        code was never running which meant the bug was hidden!
        
        Now the engine has been fixed so that it cleans up correctly, all old versions 
        of Multi Publish and apps using a pre-v0.1.17 version of the BrowserWidget became
        extremely unstable.
        
        As a workaround, this function finds all pre-v0.1.17 BrowserWidgets and 
        pre-v0.3.22 SaveAsForms and applies a fix (basically waits for the worker thread 
        to stop) to avoid instability!
        """
        checked_classes = {}

        widgets = [widget]
        for w in widgets:

            # look through class hierarchy - can't use isinstance here
            # because we don't know which module the BrowserWidget would
            # be from!
            cls_type = None
            for cls in inspect.getmro(type(w)):

                # stop if we've previously checked this class:
                cls_type = checked_classes.get(cls, None)
                if cls_type != None:
                    break
                checked_classes[cls] = ""

                # only care about certain specific classes:
                if cls.__name__ == "BrowserWidget":
                    # tk-framework-widget.BrowserWidget

                    # check the class has some members we know about and that
                    # have been there since the first version of the code:
                    if (hasattr(w, "_worker")
                            and isinstance(w._worker, QtCore.QThread)
                            and hasattr(w, "_app")
                            and isinstance(w._app, application.Application)
                            and hasattr(w, "_spin_icons")
                            and isinstance(w._spin_icons, list)):
                        # assume that this is derived from an actual tk-framework-widget.BrowserWidget!
                        cls_type = "BrowserWidget"
                elif cls.__name__ == "SaveAsForm":
                    # tk-multi-workfiles.SaveAsForm

                    # check the class has some members we know about and that
                    # have been there since the first version of the code:
                    if (hasattr(w, "_preview_updater")
                            and isinstance(w._preview_updater, QtCore.QThread)
                            and hasattr(w, "_reset_version")
                            and isinstance(w._reset_version, bool)):
                        # assume that this is derived from an actual tk-multi-workfiles.SaveAsForm!
                        cls_type = "SaveAsForm"

                if cls_type != None:
                    checked_classes[cls] = cls_type
                    break

            if cls_type:
                worker = None
                if cls_type == "BrowserWidget":
                    worker = w._worker
                elif cls_type == "SaveAsForm":
                    worker = w._preview_updater
                else:
                    continue

                # now check to see if the worker already contains the fix:
                if hasattr(worker, "_SGTK_IMPLEMENTS_QTHREAD_CRASH_FIX_"):
                    # this is already fixed so we don't need to do anything more!
                    continue

                # lets make sure the worker is stopped...
                worker.stop()
                # and wait for the thread to finish - this line is the fix!
                worker.wait()
            else:
                # add all child widgets to list to be checked
                widgets.extend(w.children())
                continue
示例#38
0
def sympify(a, locals=None, convert_xor=True, strict=False, rational=False):
    """
    Converts an arbitrary expression to a type that can be used inside sympy.

    For example, it will convert python ints into instance of sympy.Rational,
    floats into instances of sympy.Float, etc. It is also able to coerce symbolic
    expressions which inherit from Basic. This can be useful in cooperation
    with SAGE.

    It currently accepts as arguments:
       - any object defined in sympy (except matrices [TODO])
       - standard numeric python types: int, long, float, Decimal
       - strings (like "0.09" or "2e-19")
       - booleans, including ``None`` (will leave them unchanged)
       - lists, sets or tuples containing any of the above

    If the argument is already a type that sympy understands, it will do
    nothing but return that value. This can be used at the beginning of a
    function to ensure you are working with the correct type.

    >>> from sympy import sympify

    >>> sympify(2).is_integer
    True
    >>> sympify(2).is_real
    True

    >>> sympify(2.0).is_real
    True
    >>> sympify("2.0").is_real
    True
    >>> sympify("2e-45").is_real
    True

    If the expression could not be converted, a SympifyError is raised.

    >>> sympify("x***2")
    Traceback (most recent call last):
    ...
    SympifyError: SympifyError: "could not parse u'x***2'"


    If the option ``strict`` is set to ``True``, only the types for which an
    explicit conversion has been defined are converted. In the other
    cases, a SympifyError is raised.

    >>> sympify(True)
    True
    >>> sympify(True, strict=True)
    Traceback (most recent call last):
    ...
    SympifyError: SympifyError: True

    To extend `sympify` to convert custom objects (not derived from `Basic`),
    the static dictionary `convert` is provided. The custom converters are
    usually added at import time, and will apply to all objects of the given
    class or its derived classes.

    For example, all geometry objects derive from `GeometryEntity` class, and
    should not be altered by the converter, so we add the following after
    defining that class:

    >>> from sympy.core.sympify import converter
    >>> from sympy.geometry.entity import GeometryEntity
    >>> converter[GeometryEntity] = lambda x: x

    """
    from containers import Tuple

    try:
        cls = a.__class__
    except AttributeError:  #a is probably an old-style class object
        cls = type(a)
    if cls in sympy_classes:
        return a
    if cls in (bool, type(None)):
        if strict:
            raise SympifyError(a)
        else:
            return a

    try:
        return converter[cls](a)
    except KeyError:
        for superclass in getmro(cls):
            try:
                return converter[superclass](a)
            except KeyError:
                continue

    try:
        return a._sympy_()
    except AttributeError:
        pass

    if not isinstance(a, basestring):
        for coerce in (float, int):
            try:
                return sympify(coerce(a))
            except (TypeError, ValueError, AttributeError, SympifyError):
                continue

    if strict:
        raise SympifyError(a)

    if isinstance(a, tuple):
        return Tuple(*[sympify(x, locals=locals, convert_xor=convert_xor,
            rational=rational) for x in a])
    if iterable(a):
        try:
            return type(a)([sympify(x, locals=locals, convert_xor=convert_xor,
                rational=rational) for x in a])
        except TypeError:
            # Not all iterables are rebuildable with their type.
            pass

    # At this point we were given an arbitrary expression
    # which does not inherit from Basic and doesn't implement
    # _sympy_ (which is a canonical and robust way to convert
    # anything to SymPy expression).
    #
    # As a last chance, we try to take "a"'s  normal form via unicode()
    # and try to parse it. If it fails, then we have no luck and
    # return an exception
    try:
        a = unicode(a)
    except Exception, exc:
        raise SympifyError(a, exc)
示例#39
0
    s.save()
fdsfds

with open_book("../gnucash_books/default_book.gnucash") as s:
    # accessing the book object from the session
    book = s.book

    # accessing root accounts
    root = book.root_account

    # accessing children accounts of root
    r = s.book.root_account.children(name="Assets").children[0]
    for acc in s.book.root_account.children(name="Assets").children[0].children:
        print(acc)

    print(inspect.getmro(Budget))
    print(inspect.getmro(Recurrence))
    b = Budget(name=lambda x: x, foo="3")
    b = Budget(name=lambda x: x, foo="3")
    fdsd
    print(b)
fdsfds

with create_book() as s:
    # retrieve list of slots
    print(s.book.slots)

    # set slots
    s.book["myintkey"] = 3
    s.book["mystrkey"] = "hello"
    s.book["myboolkey"] = True
示例#40
0
def is_pure_dataclass(value):
    if not dataclasses_support or not inspect.isclass(value):
        return False
    dataclasses = import_dataclasses('is_pure_dataclass')
    classes = [c for c in inspect.getmro(value) if c != object]
    return all(dataclasses.is_dataclass(c) for c in classes)
示例#41
0
# in other programming language, we are ChildClass extends ParentClass
# in python, we write ChildClass(ParentClass): which means the same thing
# python supports inheriting multiple classes, ChildClass(ParentOneClass, ParentTwoClass):

# in python every class, custom or user-defined, inherits `object` class
# but in python 3, we do not have to use `MyClass(object):`, python interprets `MyClass:` as the same

# we can view the inheritance tree by inspecting method resolution order or MRO (discussed later)
# A boolean value is an instance of `bool` class which inherits `int` class which inherits `object` class
# we can use `__class__` property of an object to see its constructor class
boolVal = True

# in case of multiple inheritance, `__bases__` return all inherited classes while `__base__` returns first inherit class
print('boolVal.__class__.__bases__ => ', boolVal.__class__.__bases__)
# we can use `getmro` function from `insepct` package to see MRO
print('getmro(boolVal.__class__) => ', getmro(boolVal.__class__))

# When a child class inherits parent class, child class has access to all properties and methods of parent class.

# When we try to access an attribute on an instance of child class, it first searches for instance attribute, then class attribute on it, then class attribute on parent class, then class attributes on the classes they inherit


# single inheritance
class AGrandParentOne:
    classAttrA = 'AGrandParentOneClassAttrA'
    classAttrB = 'AGrandParentOneClassAttrB'
    classAttrC = 'AGrandParentOneClassAttrC'


class AParentOne(AGrandParentOne):
    classAttrA = 'AParentOneClassAttrA'
示例#42
0
 def export_capacities(self):
     """  List Mimetypes that current object can export to
     """
     return [export for cls in getmro(type(self)) if hasattr(cls, "EXPORT_TO") for export in cls.EXPORT_TO]
    for method in inspect.getmembers(q, predicate=inspect.ismethod):
        # print(type(method[1]))
        print(method[0])
        print()

        print('Invoke:')
        class_name = "Quadrilateral"
        method = "get_area"
        obj = globals()[class_name](a=3, b=4, c=3, d=4, diagonal=5)
        answer = getattr(obj, method)()
        print(answer)

        print('Superclass:')
        # print(super(q.__class__))
        print(inspect.getmro(Quadrilateral)[1])
        print('-----------------------------------------')

        #
        # def myfunc():
        #     felf = globals()[inspect.getframeinfo(inspect.currentframe()).function]
        #     print("** myfunc inspect : %s"%felf.__name__)
        #
        #     felf = globals()[sys._getframe().f_code.co_name]
        #     print("** myfunc globals : %s"%felf.__name__)
        #
        #     print( 'wrapper =' )
        #     print( myfunc )
        #
        #     print( 'done myfunc' )
示例#44
0
import inspect
print "The class hierarchy for built-in exceptions is:"
inspect.getclasstree(inspect.getmro(BaseException))


def classtree(cls, indent=0):
    print '.' * indent, cls.__name__
    for subcls in cls.__subclasses__():
        classtree(subcls, indent + 3)


classtree(BaseException)
示例#45
0
文件: flexure.py 项目: zrduan/landlab
    def __init__(self, grid, Youngs_modulus=6.5e11, Poissons_ratio=0.25,
                 rho_mantle=3300., rho_fill=0., elastic_thickness=35000.,
                 BC_W='0Displacement0Slope', BC_E='0Displacement0Slope',
                 BC_N='0Displacement0Slope', BC_S='0Displacement0Slope',
                 g=9.81, **kwds):
        """Constructor for Wickert's gFlex in Landlab."""
        assert RasterModelGrid in inspect.getmro(grid.__class__)
        if NO_GFLEX:
            raise ImportError(
                "gFlex not installed! For installation instructions see " +
                "gFlex on GitHub: https://github.com/awickert/gFlex")
        BC_options = ('0Displacement0Slope', '0Moment0Shear', '0Slope0Shear',
                      'Periodic')

        # instantiate the module:
        self.flex = gflex.F2D()
        flex = self.flex

        # set up the grid variables:
        self._grid = grid
        flex.dx = grid.dx
        flex.dy = grid.dy

        # we assume these properties are fixed in this relatively
        # straightforward implementation, but they can still be set if you
        # want:
        try:
            flex.Method = kwds['Method']
        except KeyError:
            flex.Method = 'FD'
        try:
            flex.PlateSolutionType = kwds['PlateSolutionType']
        except KeyError:
            flex.PlateSolutionType = 'vWC1994'
        try:
            flex.Solver = kwds['Solver']
        except KeyError:
            flex.Solver = 'direct'
        try:
            quiet = kwds['Quiet']
        except KeyError:
            flex.Quiet = True
        else:
            flex.Quiet = bool(quiet)

        flex.E = float(Youngs_modulus)
        flex.nu = float(Poissons_ratio)
        flex.rho_m = float(rho_mantle)
        flex.rho_fill = float(rho_fill)
        flex.g = float(g)
        flex.BC_W = BC_W
        flex.BC_E = BC_E
        flex.BC_S = BC_S
        flex.BC_N = BC_N
        for i in (flex.BC_E, flex.BC_W, flex.BC_N, flex.BC_S):
            assert i in BC_options

        if BC_W == 'Periodic':
            assert BC_E == 'Periodic'
        if BC_E == 'Periodic':
            assert BC_W == 'Periodic'
        if BC_N == 'Periodic':
            assert BC_S == 'Periodic'
        if BC_S == 'Periodic':
            assert BC_N == 'Periodic'

        Te_in = elastic_thickness
        try:
            flex.Te = float(Te_in)
        except ValueError:
            try:
                flex.Te = grid.at_node[Te_in].view().reshape(grid.shape)
            except TypeError:
                flex.Te = Te_in.view().reshape(grid.shape)
            self._input_var_names.add(Te_in)
            self._output_var_names.add(Te_in)

        # set up the link between surface load stresses in the gFlex component
        # and the LL grid field:
        flex.qs = grid.at_node['surface_load__stress'].view().reshape(
            grid.shape)

        # create a holder for the "pre-flexure" state of the grid, to allow
        # updating of elevs:
        self.pre_flex = np.zeros(grid.number_of_nodes, dtype=float)

        # create the primary output field:
        self.grid.add_zeros('lithosphere_surface__elevation_increment', at='node',
                            dtype=float, noclobber=False)
示例#46
0
 def getParserTags(cls):
     tags = {}
     for cls in reversed(getmro(cls)):
         if hasattr(cls, "PARSER_TAGS"):
             tags.update(cls.PARSER_TAGS)
     return tags