Example #1
    def serialize(self, ctx, message):
        assert message in (self.REQUEST, self.RESPONSE)

        self.event_manager.fire_event("before_serialize", ctx)

        if ctx.out_error is not None:
            ctx.out_document = [ctx.out_error.to_dict(ctx.out_error)]

            # get the result message
            if message is self.REQUEST:
                out_type = ctx.descriptor.in_message
            elif message is self.RESPONSE:
                out_type = ctx.descriptor.out_message
            if out_type is None:

            out_type_info = out_type._type_info

            # instantiate the result message
            out_instance = out_type()

            # assign raw result to its wrapper, result_message
            for i in range(len(out_type_info)):
                attr_name = out_type_info.keys()[i]
                setattr(out_instance, attr_name, ctx.out_object[i])

            ctx.out_document = self._object_to_doc(out_type, out_instance, skip_depth=self.skip_depth)
            self.event_manager.fire_event("after_serialize", ctx)
Example #2
def make_cache_level(ncaches, prototypes, level, next_cache):
    global next_subsys_index, proto_l1, testerspec, proto_tester

    index = next_subsys_index[level]
    next_subsys_index[level] += 1

    # Create a subsystem to contain the crossbar and caches, and
    # any testers
    subsys = SubSystem()
    setattr(system, "l%dsubsys%d" % (level, index), subsys)

    # The levels are indexing backwards through the list
    ntesters = testerspec[len(cachespec) - level]

    # Scale the progress threshold as testers higher up in the tree
    # (smaller level) get a smaller portion of the overall bandwidth,
    # and also make the interval of packet injection longer for the
    # testers closer to the memory (larger level) to prevent them
    # hogging all the bandwidth
    limit = (len(cachespec) - level + 1) * 100000000
    testers = [proto_tester(interval=10 * (level * level + 1), progress_check=limit) for i in xrange(ntesters)]
    if ntesters:
        subsys.tester = testers

    if level != 0:
        # Create a crossbar and add it to the subsystem, note that
        # we do this even with a single element on this level
        xbar = L2XBar()
        subsys.xbar = xbar
        if next_cache:
            xbar.master = next_cache.cpu_side

        # Create and connect the caches, both the ones fanning out
        # to create the tree, and the ones used to connect testers
        # on this level
        tree_caches = [prototypes[0]() for i in xrange(ncaches[0])]
        tester_caches = [proto_l1() for i in xrange(ntesters)]

        subsys.cache = tester_caches + tree_caches
        for cache in tree_caches:
            cache.mem_side = xbar.slave
            make_cache_level(ncaches[1:], prototypes[1:], level - 1, cache)
        for tester, cache in zip(testers, tester_caches):
            tester.port = cache.cpu_side
            cache.mem_side = xbar.slave
        if not next_cache:
            print "Error: No next-level cache at top level"

        if ntesters > 1:
            # Create a crossbar and add it to the subsystem
            xbar = L2XBar()
            subsys.xbar = xbar
            xbar.master = next_cache.cpu_side
            for tester in testers:
                tester.port = xbar.slave
            # Single tester
            testers[0].port = next_cache.cpu_side
Example #3
    def _addNamedParams(self, alias, **d):
        if not alias:
            # create the reverse mapping: from parameter index to name.
            self.paramnames.update(dict((v,k) for k,v in d.items()))

        # Create a property for each named parameter.
        for n,i in self.namedparams.items():
            #print('Adding named parameter', n, 'to class', self.__class__)
            if hasattr(self.__class__, n):
                #print('  class', self.__class__, 'already has attr', n)
            #if hasattr(self, n):
            #   print('  self of type', self.__class__, 'already has that attr')
            #   continue

            # def makeGetter(ii):
            #   return lambda x: x._getThing(ii)
            # def makeSetter(ii):
            #   return lambda x,v: x._setThing(ii, v)
            # getter = makeGetter(i)
            # setter = makeSetter(i)

            def makeNamedGetter(nm):
                #return lambda x: x._getThing(self.namedparams[nm])
                return lambda x: x._getNamedThing(nm)
            def makeNamedSetter(nm):
                #return lambda x,v: x._setThing(self.namedparams[nm], v)
                return lambda x,v: x._setNamedThing(nm, v)
            getter = makeNamedGetter(n)
            setter = makeNamedSetter(n)

            prop = property(getter, setter, None, 'named param %s' % n)
            setattr(self.__class__, n, prop)
Example #4
 def __init__(self, conn, dumps, loads):
     self._conn = conn
     self._dumps = dumps
     self._loads = loads
     for attr in ('fileno', 'close', 'poll', 'recv_bytes', 'send_bytes'):
         obj = getattr(conn, attr)
         setattr(self, attr, obj)
Example #5
    def update_aggregate(self, ag_model, location):
        agg =  ag_model.objects.filter(location=location)
        if agg:
            agg = agg[0]
            agg = ag_model(location=location)
        #print agg.__dict__
        #summaries = []
        trees = Tree.objects.filter(plot__geometry__within=location.geometry)
        plots = Plot.objects.filter(geometry__within=location.geometry)
        #print trees
        agg.total_trees = trees.count()
        agg.total_plots = plots.count()

        trees = trees.exclude( Q(dbh=None) | Q(dbh=0.0) ).exclude(species=None)
        #print agg.total_trees
        #TODO figure out how to summarize diff stratum stuff
        field_names = [x.name for x in ResourceSummaryModel._meta.fields
            if not x.name == 'id']

        if agg.total_trees == 0:
            for f in field_names:
                setattr(agg, f, 0.0)
        #TODO speed this up
            for f in field_names:
                fn = 'treeresource__' + f
                s = trees.aggregate(Sum(fn))[fn + '__sum'] or 0.0
Example #6
 def _loadEntry(self):
     if not hasattr(self, '_flags'):
         info = self._pts._ListEntry(self._id)
         for field in self._attrs:
             setattr(self, '_%s' % field, getattr(info, field))
         for field in self._entry_attrs:
             setattr(self, '_%s' % field, self._pts.getEntry(getattr(info, field)))
Example #7
            def applyMethod(stmts, methodName):
                def method(self, _=None, **kwargs):
                    # Received un-named parameter, it would be a iterable
                    if _ != None:
                        # Parameters are given as a dictionary,
                        # put them in the correct place (bad guy...)
                        if isinstance(_, dict):
                            kwargs = _

                        # Iterable of parameters, execute as normal
                            for kwargs in _:
                                for stmt in stmts:
                                    self.cursor.execute(stmt, kwargs)

                    self.cursor.execute(stmts[0], kwargs)
                    rowid = self.cursor.lastrowid

                    for stmt in stmts[1:]:
                        self.cursor.execute(stmt, kwargs)

                    return rowid

                setattr(self.__class__, methodName, method)
Example #8
        def applyMethod(stmts, methodName):
            def method(self, **kwargs):
                for stmt in stmts:
                    self.cursor.execute(stmt, kwargs)

            setattr(self.__class__, methodName, method)
Example #9
 def __getattr__(self, name):
     if name in self.ok_names:
         attr = getattr(self.real, name)
         setattr(self, name, attr)
         return attr
         raise AttributeError, name  # Attribute not allowed
Example #10
def delete_objects(seen_objs):
    Iterate through a list of seen classes, and remove any instances that are
    referred to.
        ordered_classes = seen_objs.keys()
    except CyclicDependency:
        # If there is a cyclic dependency, we cannot in general delete the
        # objects.  However, if an appropriate transaction is set up, or if the
        # database is lax enough, it will succeed. So for now, we go ahead and
        # try anyway.
        ordered_classes = seen_objs.unordered_keys()

    obj_pairs = {}
    for cls in ordered_classes:
        items = seen_objs[cls].items()
        obj_pairs[cls] = items

        # Pre-notify all instances to be deleted.
        for pk_val, instance in items:
            signals.pre_delete.send(sender=cls, instance=instance)

        pk_list = [pk for pk,instance in items]
        del_query = sql.DeleteQuery(cls, connection)

        update_query = sql.UpdateQuery(cls, connection)
        for field, model in cls._meta.get_fields_with_model():
            if (field.rel and field.null and field.rel.to in seen_objs and
                    filter(lambda f: f.column == field.column,
                if model:
                    sql.UpdateQuery(model, connection).clear_related(field,
                    update_query.clear_related(field, pk_list)

    # Now delete the actual data.
    for cls in ordered_classes:
        items = obj_pairs[cls]

        pk_list = [pk for pk,instance in items]
        del_query = sql.DeleteQuery(cls, connection)

        # Last cleanup; set NULLs where there once was a reference to the
        # object, NULL the primary key of the found objects, and perform
        # post-notification.
        for pk_val, instance in items:
            for field in cls._meta.fields:
                if field.rel and field.null and field.rel.to in seen_objs:
                    setattr(instance, field.attname, None)

            signals.post_delete.send(sender=cls, instance=instance)
            setattr(instance, cls._meta.pk.attname, None)

Example #11
def get_cached_row(klass, row, index_start, max_depth=0, cur_depth=0,
    Helper function that recursively returns an object with the specified
    related attributes already populated.
    if max_depth and requested is None and cur_depth > max_depth:
        # We've recursed deeply enough; stop now.
        return None

    restricted = requested is not None
    index_end = index_start + len(klass._meta.fields)
    fields = row[index_start:index_end]
    if not [x for x in fields if x is not None]:
        # If we only have a list of Nones, there was not related object.
        obj = None
        obj = klass(*fields)
    for f in klass._meta.fields:
        if not select_related_descend(f, restricted, requested):
        if restricted:
            next = requested[f.name]
            next = None
        cached_row = get_cached_row(f.rel.to, row, index_end, max_depth,
                cur_depth+1, next)
        if cached_row:
            rel_obj, index_end = cached_row
            if obj is not None:
                setattr(obj, f.get_cache_name(), rel_obj)
    return obj, index_end
Example #12
 def __call__(self, parser, namespace, fname, option_string=None):
     ext = os.path.splitext(fname)[1][1:]
     if ext not in allowed:
         option_string = '({})'.format(option_string) if option_string else ''
         parser.error("file extension is not one of {}{}".format(allowed, option_string))
         setattr(namespace, self.dest, fname)
Example #13
    def register(self, mod):
        # Derive the name of the kernel from the module
        name = mod[mod.rfind('.') + 1:]

        # See if a kernel has already been registered under this name
        if hasattr(self, name):
            # Same name different module
            if getattr(self, name)._mod != mod:
                raise RuntimeError('Attempt to re-register "{}" with a '
                                   'different module'.format(name))
            # Otherwise (since we're already registered) return

        # Generate the kernel providing method
        def kernel_meth(self, tplargs, dims, **kwargs):
            # Render the source of kernel
            src, ndim, argn, argt = self._render_kernel(name, mod, tplargs)

            # Compile the kernel
            fun = self._build_kernel(name, src, list(it.chain(*argt)))

            # Process the argument list
            argb = self._build_arglst(dims, argn, argt, kwargs)

            # Return a ComputeKernel subclass instance
            return self._instantiate_kernel(dims, fun, argb)

        # Attach the module to the method as an attribute
        kernel_meth._mod = mod

        # Bind
        setattr(self, name, types.MethodType(kernel_meth, self))
Example #14
    def _make_scalar_compound_controller(self, fcurves, keyframes, bez_chans, default_xform):
        ctrl = plCompoundController()
        subctrls = ("X", "Y", "Z")
        for i in subctrls:
            setattr(ctrl, i, plLeafController())
        exported_frames = ([], [], [])
        ctrl_fcurves = { i.array_index: i for i in fcurves }

        for keyframe in keyframes:
            for i, subctrl in enumerate(subctrls):
                fval = keyframe.values.get(i, None)
                if fval is not None:
                    keyframe_type = hsKeyFrame.kBezScalarKeyFrame if i in bez_chans else hsKeyFrame.kScalarKeyFrame
                    exported = hsScalarKey()
                    exported.frame = keyframe.frame_num
                    exported.frameTime = keyframe.frame_time
                    exported.inTan = keyframe.in_tans[i]
                    exported.outTan = keyframe.out_tans[i]
                    exported.type = keyframe_type
                    exported.value = fval
        for i, subctrl in enumerate(subctrls):
            my_keyframes = exported_frames[i]

            # ensure this controller has at least ONE keyframe
            if not my_keyframes:
                hack_frame = hsScalarKey()
                hack_frame.frame = 0
                hack_frame.frameTime = 0.0
                hack_frame.type = hsKeyFrame.kScalarKeyFrame
                hack_frame.value = default_xform[i]
            getattr(ctrl, subctrl).keys = (my_keyframes, my_keyframes[0].type)
        return ctrl
Example #15
 def _set(self, value):
     '''set value for attribute %s.
     value -- initialize value, immutable type
     ''' %str(key)
     if not hasattr(self, what.attrs_aname):
         setattr(self, what.attrs_aname, {})
     getattr(self, what.attrs_aname)[key] = value
Example #16
def _ordered_dict(loader: SafeLineLoader,
                  node: yaml.nodes.MappingNode) -> OrderedDict:
    """Load YAML mappings into an ordered dictionary to preserve key order."""
    nodes = loader.construct_pairs(node)

    seen = {}  # type: Dict
    min_line = None
    for (key, _), (node, _) in zip(nodes, node.value):
        line = getattr(node, '__line__', 'unknown')
        if line != 'unknown' and (min_line is None or line < min_line):
            min_line = line
        if key in seen:
            fname = getattr(loader.stream, 'name', '')
            first_mark = yaml.Mark(fname, 0, seen[key], -1, None, None)
            second_mark = yaml.Mark(fname, 0, line, -1, None, None)
            raise yaml.MarkedYAMLError(
                context="duplicate key: \"{}\"".format(key),
                context_mark=first_mark, problem_mark=second_mark,
        seen[key] = line

    processed = OrderedDict(nodes)
    setattr(processed, '__config_file__', loader.name)
    setattr(processed, '__line__', min_line)
    return processed
Example #17
    def __init__(self, *args, **kwargs):
        """Constructor to resolve values for all Parameters.

        For example, the Task::

            class MyTask(luigi.Task):
                count = luigi.IntParameter()

        can be instantiated as ``MyTask(count=10)``.
        params = self.get_params()
        param_values = self.get_param_values(params, args, kwargs)

        # Set all values on class instance
        for key, value in param_values:
            setattr(self, key, value)

        # Register args and kwargs as an attribute on the class. Might be useful
        self.param_args = tuple(value for key, value in param_values)
        self.param_kwargs = dict(param_values)

        # Build up task id
        task_id_parts = []
        param_objs = dict(params)
        for param_name, param_value in param_values:
            if dict(params)[param_name].significant:
                task_id_parts.append('%s=%s' % (param_name, param_objs[param_name].serialize(param_value)))

        self.task_id = '%s(%s)' % (self.task_family, ', '.join(task_id_parts))
        self.__hash = hash(self.task_id)
Example #18
    def read(self, read_path=None):
        """Read the metadata from the associated file. If read_path is
        specified, read metadata from that file instead.

        Raises a `ReadError` if the file could not be read.
        if read_path is None:
            read_path = self.path
            read_path = normpath(read_path)
            f = MediaFile(syspath(read_path))
        except (OSError, IOError) as exc:
            raise ReadError(read_path, exc)

        for key in ITEM_KEYS_META:
            value = getattr(f, key)
            if isinstance(value, (int, long)):
                # Filter values wider than 64 bits (in signed
                # representation). SQLite cannot store them.
                # py26: Post transition, we can use:
                # value.bit_length() > 63
                if abs(value) >= 2 ** 63:
                    value = 0
            setattr(self, key, value)

        # Database's mtime should now reflect the on-disk value.
        if read_path == self.path:
            self.mtime = self.current_mtime()

        self.path = read_path
Example #19
    def _lun_type(self, xml_root):
        lun_type = constants.PRODUCT_LUN_TYPE.get(self.conf.san_product,

        def _verify_conf_lun_type(lun_type):
            if lun_type not in constants.LUN_TYPE_MAP:
                msg = _("Invalid lun type %s is configured.") % lun_type
                raise exception.InvalidInput(reason=msg)

            if self.conf.san_product in constants.PRODUCT_LUN_TYPE:
                product_lun_type = constants.PRODUCT_LUN_TYPE[
                if lun_type != product_lun_type:
                    msg = _("%(array)s array requires %(valid)s lun type, "
                            "but %(conf)s is specified.") % {
                        'array': self.conf.san_product,
                        'valid': product_lun_type,
                        'conf': lun_type}
                    raise exception.InvalidInput(reason=msg)

        text = xml_root.findtext('LUN/LUNType')
        if text:
            lun_type = text.strip()

        lun_type = constants.LUN_TYPE_MAP[lun_type]
        setattr(self.conf, 'lun_type', lun_type)
Example #20
    def write(self, path=None):
        """Write the item's metadata to a media file.

        ``path`` defaults to the item's path property.

        Can raise either a `ReadError` or a `WriteError`.
        if path is None:
            path = self.path
            path = normpath(path)
            f = MediaFile(syspath(path))
        except (OSError, IOError) as exc:
            raise ReadError(self.path, exc)

        plugins.send('write', item=self, path=path)

        for key in ITEM_KEYS_WRITABLE:
            setattr(f, key, self[key])
        except (OSError, IOError, MutagenError) as exc:
            raise WriteError(self.path, exc)

        # The file has a new mtime.
        self.mtime = self.current_mtime()
        plugins.send('after_write', item=self)
Example #21
            def applyMethod(sql, methodName):
                def method(self, **kwargs):
                    self.cursor.execute(sql, kwargs)
                    return self.cursor.lastrowid

                setattr(self.__class__, methodName, method)
def option_none(option, opt, value, parser):
    """ checks a parameter for taking value"""
    if parser.rargs and not parser.rargs[0].startswith('-'):
        print "Option arg error"
        print opt, " option should be empty"
    setattr(parser.values, option.dest, True)
Example #23
    def populatePanel(self, contentPanel, headerPanel):
        contentSizer = contentPanel.GetSizer()
        self.panel = contentPanel
        self.headerPanel = headerPanel

        gridPrice = wx.GridSizer(1, 3)
        contentSizer.Add( gridPrice, 0, wx.EXPAND | wx.ALL, 0)
        for type in ("ship", "fittings", "total"):
            image = "%sPrice_big" % type if type != "ship" else "ship_big"
            box = wx.BoxSizer(wx.HORIZONTAL)
            gridPrice.Add(box, 0, wx.ALIGN_TOP)

            box.Add(bitmapLoader.getStaticBitmap(image, contentPanel, "icons"), 0, wx.ALIGN_CENTER)

            vbox = wx.BoxSizer(wx.VERTICAL)
            box.Add(vbox, 1, wx.EXPAND)

            vbox.Add(wx.StaticText(contentPanel, wx.ID_ANY, type.capitalize()), 0, wx.ALIGN_LEFT)

            hbox = wx.BoxSizer(wx.HORIZONTAL)

            lbl = wx.StaticText(contentPanel, wx.ID_ANY, "0.00 ISK")
            setattr(self, "labelPrice%s" % type.capitalize(), lbl)
            hbox.Add(lbl, 0, wx.ALIGN_LEFT)

#            hbox.Add(wx.StaticText(contentPanel, wx.ID_ANY, " ISK"), 0, wx.ALIGN_LEFT)
        self.labelEMStatus = wx.StaticText(contentPanel, wx.ID_ANY, "")
Example #24
def port_cassavotes():
    from r2.models import Vote, Account, Link, Comment
    from r2.models.vote import CassandraVote, CassandraLinkVote, CassandraCommentVote
    from r2.lib.db.tdb_cassandra import CL
    from r2.lib.utils import fetch_things2, to36, progress

    ts = [(Vote.rel(Account, Link), CassandraLinkVote),
          (Vote.rel(Account, Comment), CassandraCommentVote)]

    dataattrs = set(['valid_user', 'valid_thing', 'ip', 'organic'])

    for prel, crel in ts:
        vq = prel._query(sort=desc('_date'),
        vq = fetch_things2(vq)
        vq = progress(vq, persec=True)
        for v in vq:
            t1 = to36(v._thing1_id)
            t2 = to36(v._thing2_id)
            cv = crel(thing1_id = t1,
                      thing2_id = t2,
            for dkey, dval in v._t.iteritems():
                if dkey in dataattrs:
                    setattr(cv, dkey, dval)

Example #25
    def __init__(self, *args, **kwargs):
        xpcshell.XPCShellTestThread.__init__(self, *args, **kwargs)

        # embed the mobile params from the harness into the TestThread
        mobileArgs = kwargs.get('mobileArgs')
        for key in mobileArgs:
            setattr(self, key, mobileArgs[key])
Example #26
 def init(self, XMLRoot=None):
   """Initialisation is called before populating with XML data. The basic
   implementation simply dynamically assigns variable names and their values,
   converted to the most sane type found. Reimplement as necessary."""
   if XMLRoot != None:
     for prop in XMLRoot:
       setattr(self, prop.tag, Utility.convert(prop.text))
Example #27
 def load_cascade_file(self, module_path, cascade_file_path):
     if not hasattr(self.__class__, "cascade"):
         if isabs(cascade_file_path):
             cascade_file = cascade_file_path
             cascade_file = join(abspath(dirname(module_path)), cascade_file_path)
         setattr(self.__class__, "cascade", cv.Load(cascade_file))
Example #28
 def setValues(self,**kargs):
     #print "setValues",kargs
     for k in kargs:
         #print k,kargs[k]
         if hasattr(self,k):
             #print getattr(self,k)
 def from_element(cls, elem):
     new_note = Note()
     for child_el in elem:
         if not child_el.tag:
         setattr(new_note, child_el.tag, child_el.text)
     return new_note
Example #30
    def create_or_update_by_guid(self, guid, **kwargs):
        Look up a FeedItem by GUID, updating it if it exists, and creating
        it if it doesn't.

        We don't limit it by feed because an item could be in another feed if
        some feeds are themselves aggregators. That's also why we don't update
        the feed field if the feed item already exists.

        Returns (item, created) like get_or_create().
            item = self.get(guid=guid)

        except self.model.DoesNotExist:
            # Create a new item
            log.debug('Creating entry: %s', guid)
            kwargs['guid'] = guid
            item = self.create(**kwargs)

            log.debug('Updating entry: %s', guid)

            # Update an existing one.
            kwargs.pop('feed', None)

            # Don't update the date since most feeds get this wrong.

            for k, v in kwargs.items():
                setattr(item, k, v)

        return item