Public Member Functions
def	getOrderedNames (self)

def	__iter__ (self)

def	checkUnits (self, parse_strict='raise')

def	addField (self, field, type=None, doc="", units="", size=None, doReplace=False, parse_strict="raise")

def	extract (self, patterns, kwds)

def	__reduce__ (self)

Detailed Description

Definition at line 92 of file schemaContinued.py.

Member Function Documentation

◆ iter()

def lsst.afw.table.schema.schemaContinued.Schema.__iter__ ( self )

Iterate over the items in the Schema.

Definition at line 104 of file schemaContinued.py.

     def __iter__(self):
         """Iterate over the items in the Schema.
         """
         items = []
         self.forEach(items.append)
         return iter(items)
 

◆ reduce()

def lsst.afw.table.schema.schemaContinued.Schema.__reduce__ ( self )

For pickle support.

Definition at line 205 of file schemaContinued.py.

     def __reduce__(self):
         """For pickle support."""
         fields = []
         for item in self:
             fields.append(item.field)
         return (makeSchemaFromFields, (fields,))
 
 

◆ addField()

def lsst.afw.table.schema.schemaContinued.Schema.addField	(	self,
		field,
		type = `None`,
		doc = `""`,
		units = `""`,
		size = `None`,
		doReplace = `False`,
		parse_strict = `"raise"`
	)

Add a field to the Schema.

Parameters
----------
field : str,Field
    The string name of the Field, or a fully-constructed Field object.
    If the latter, all other arguments besides doReplace are ignored.
type\n : str,type
    The type of field to create.  Valid types are the keys of the
    afw.table.Field dictionary.
doc : str
    Documentation for the field.
unit : str
    Units for the field, or an empty string if unitless.
size : int
    Size of the field; valid for string and array fields only.
doReplace : bool
    If a field with this name already exists, replace it instead of
    raising pex.exceptions.InvalidParameterError.
parse_strict : str
    One of 'raise' (default), 'warn', or 'strict', indicating how to
    handle unrecognized unit strings.  See also astropy.units.Unit.

Definition at line 120 of file schemaContinued.py.

                  doReplace=False, parse_strict="raise"):
         """Add a field to the Schema.
 
         Parameters
         ----------
         field : str,Field
             The string name of the Field, or a fully-constructed Field object.
             If the latter, all other arguments besides doReplace are ignored.
         type\n : str,type
             The type of field to create.  Valid types are the keys of the
             afw.table.Field dictionary.
         doc : str
             Documentation for the field.
         unit : str
             Units for the field, or an empty string if unitless.
         size : int
             Size of the field; valid for string and array fields only.
         doReplace : bool
             If a field with this name already exists, replace it instead of
             raising pex.exceptions.InvalidParameterError.
         parse_strict : str
             One of 'raise' (default), 'warn', or 'strict', indicating how to
             handle unrecognized unit strings.  See also astropy.units.Unit.
         """
         if isinstance(field, str):
             field = Field[type](field, doc=doc, units=units,
                                 size=size, parse_strict=parse_strict)
         return field._addTo(self, doReplace)
 

◆ checkUnits()

def lsst.afw.table.schema.schemaContinued.Schema.checkUnits	(	self,
		parse_strict = `'raise'`
	)

Check that all units in the Schema are valid Astropy unit strings.

Definition at line 111 of file schemaContinued.py.

     def checkUnits(self, parse_strict='raise'):
         """Check that all units in the Schema are valid Astropy unit strings.
         """
         def func(item):
             astropy.units.Unit(item.field.getUnits(),
                                parse_strict=parse_strict)
         self.forEach(func)
 

◆ extract()

def lsst.afw.table.schema.schemaContinued.Schema.extract	(	self,
		patterns,
		kwds
	)

Extract a dictionary of {<name>: <schema-item>} 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.

Additional Keyword Arguments
----------------------------
regex : `str` or `re` pattern
    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 149 of file schemaContinued.py.

     def extract(self, *patterns, **kwds):
         """
         Extract a dictionary of {<name>: <schema-item>} 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.
 
         Additional Keyword Arguments
         ----------------------------
         regex : `str` or `re` pattern
             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.
         """
         if kwds.pop("ordered", False):
             d = collections.OrderedDict()
         else:
             d = dict()
         regex = kwds.pop("regex", None)
         sub = kwds.pop("sub", None)
         if sub is not None and regex is None:
             raise ValueError(
                 "'sub' keyword argument to extract is invalid without 'regex' argument")
         if kwds:
             raise ValueError(
                 "Unrecognized keyword arguments for extract: %s" % ", ".join(kwds.keys()))
         for item in self:
             trueName = item.field.getName()
             names = [trueName]
             for alias, target in self.getAliasMap().items():
                 if trueName.startswith(target):
                     names.append(trueName.replace(target, alias, 1))
             for name in names:
                 if regex is not None:
                     m = re.match(regex, name)
                     if m is not None:
                         if sub is not None:
                             name = m.expand(sub)
                         d[name] = item
                         continue  # continue middle loop so we don't match the same name twice
                 for pattern in patterns:
                     if fnmatch.fnmatchcase(name, pattern):
                         d[name] = item
                         break  # break inner loop so we don't match the same name twice
         return d
 

◆ getOrderedNames()

def lsst.afw.table.schema.schemaContinued.Schema.getOrderedNames ( self )

Return a list of field names in the order the fields were added to the Schema.

Definition at line 94 of file schemaContinued.py.

     def getOrderedNames(self):
         """Return a list of field names in the order the fields were added to the Schema.
         """
         names = []
 
         def func(item):
             names.append(item.field.getName())
         self.forEach(func)
         return names
 

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/schema/schemaContinued.py

Public Member Functions