lsst.afw.table.base.baseContinued.BaseRecord Class Reference

Public Member Functions
def	extract (self, patterns, kwds)
def	__repr__ (self)

Detailed Description

Definition at line 33 of file baseContinued.py.

Member Function Documentation

__repr__()

def lsst.afw.table.base.baseContinued.BaseRecord.__repr__

(

self

)

Definition at line 90 of file baseContinued.py.

    def __repr__(self):
        return "%s\n%s" % (type(self), str(self))

extract()

def lsst.afw.table.base.baseContinued.BaseRecord.extract	(		self,
			patterns,
			kwds
	)

Extract a dictionary of {<name>: <field-value>} in which the field names
match the given shell-style glob pattern(s).

Any number of glob patterns may be passed; the result will be the union of all
the result of each glob considered separately.

Parameters
----------

items : `dict`
    The result of a call to self.schema.extract(); this will be used
    instead of doing any new matching, and allows the pattern matching
    to be reused to extract values from multiple records.  This
    keyword is incompatible with any position arguments and the regex,
    sub, and ordered keyword arguments.

split : `bool`
    If True, fields with named subfields (e.g. points) will be split
    into separate items in the dict; instead of {"point":
    lsst.geom.Point2I(2,3)}, for instance, you'd get {"point.x":
    2, "point.y": 3}. Default is False.

regex : `str` or `re` pattern object
    A regular expression to be used in addition to any glob patterns
    passed as positional arguments.  Note that this will be compared
    with re.match, not re.search.

sub : `str`
    A replacement string (see `re.MatchObject.expand`) used to set the
    dictionary keys of any fields matched by regex.

ordered : `bool`
    If `True`, a `collections.OrderedDict` will be returned instead of
    a standard dict, with the order corresponding to the definition
    order of the `Schema`. `Default is False`.

Definition at line 35 of file baseContinued.py.

    def extract(self, *patterns, **kwds):
        """Extract a dictionary of {<name>: <field-value>} in which the field names
        match the given shell-style glob pattern(s).

        Any number of glob patterns may be passed; the result will be the union of all
        the result of each glob considered separately.

        Parameters
        ----------

        items : `dict`
            The result of a call to self.schema.extract(); this will be used
            instead of doing any new matching, and allows the pattern matching
            to be reused to extract values from multiple records.  This
            keyword is incompatible with any position arguments and the regex,
            sub, and ordered keyword arguments.

        split : `bool`
            If True, fields with named subfields (e.g. points) will be split
            into separate items in the dict; instead of {"point":
            lsst.geom.Point2I(2,3)}, for instance, you'd get {"point.x":
            2, "point.y": 3}. Default is False.

        regex : `str` or `re` pattern object
            A regular expression to be used in addition to any glob patterns
            passed as positional arguments.  Note that this will be compared
            with re.match, not re.search.

        sub : `str`
            A replacement string (see `re.MatchObject.expand`) used to set the
            dictionary keys of any fields matched by regex.

        ordered : `bool`
            If `True`, a `collections.OrderedDict` will be returned instead of
            a standard dict, with the order corresponding to the definition
            order of the `Schema`. `Default is False`.
        """
        d = kwds.pop("items", None)
        split = kwds.pop("split", False)
        if d is None:
            d = self.schema.extract(*patterns, **kwds).copy()
        elif kwds:
            raise ValueError(
                "Unrecognized keyword arguments for extract: %s" % ", ".join(kwds.keys()))
        # must use list because we might be adding/deleting elements
        for name, schemaItem in list(d.items()):
            key = schemaItem.key
            if split and key.HAS_NAMED_SUBFIELDS:
                for subname, subkey in zip(key.subfields, key.subkeys):
                    d["%s.%s" % (name, subname)] = self.get(subkey)
                del d[name]
            else:
                d[name] = self.get(schemaItem.key)
        return d

---

The documentation for this class was generated from the following file:

• /j/snowflake/release/lsstsw/stack/Linux64/afw/18.1.0/python/lsst/afw/table/base/baseContinued.py