lsst.pipe.base.struct.Struct Class Reference

Inheritance diagram for lsst.pipe.base.struct.Struct:

Public Member Functions
def	__init__ (self, **keyArgs)
def	getDict (self)
def	mergeItems (self, struct, *nameList)
def	copy (self)
def	__eq__ (self, other)
def	__len__ (self)
def	__repr__ (self)

Detailed Description

A container to which you can add fields as attributes.

Parameters
----------
keyArgs
    keyword arguments specifying fields and their values.

Notes
-----
Intended to be used for the return value from `~lsst.pipe.base.Task.run`
and other `~lsst.pipe.base.Task` methods, and useful for any method that
returns multiple values.

The intent is to allow accessing returned items by name, instead of
unpacking a tuple.  This makes the code much more robust and easier to
read. It allows one to change what values are returned without inducing
mysterious failures: adding items is completely safe, and removing or
renaming items causes errors that are caught quickly and reported in a way
that is easy to understand.

The primary reason for using Struct instead of dict is that the fields may
be accessed as attributes, e.g. ``aStruct.foo`` instead of
``aDict["foo"]``. Admittedly this only saves a few characters, but it
makes the code significantly more readable.

Struct is preferred over named tuples, because named tuples can be used as
ordinary tuples, thus losing all the safety advantages of Struct. In
addition, named tuples are clumsy to define and Structs are much more
mutable (e.g. one can trivially combine Structs and add additional fields).

Examples
--------
>>> myStruct = Struct(
>>>     strVal = 'the value of the field named "strVal"',
>>>     intVal = 35,
>>> )

Definition at line 26 of file struct.py.

Constructor & Destructor Documentation

__init__()

def lsst.pipe.base.struct.Struct.__init__	(		self,
		**	keyArgs
	)

Definition at line 66 of file struct.py.

    def __init__(self, **keyArgs):
        for name, val in keyArgs.items():
            self.__safeAdd(name, val)
 

Member Function Documentation

__eq__()

def lsst.pipe.base.struct.Struct.__eq__	(		self,
			other
	)

Definition at line 143 of file struct.py.

    def __eq__(self, other):
        return self.__dict__ == other.__dict__
 

__len__()

def lsst.pipe.base.struct.Struct.__len__

(

self

)

Definition at line 146 of file struct.py.

    def __len__(self):
        return len(self.__dict__)
 

__repr__()

def lsst.pipe.base.struct.Struct.__repr__

(

self

)

Definition at line 149 of file struct.py.

    def __repr__(self):
        itemsStr = "; ".join(f"{name}={val}" for name, val in self.getDict().items())
        return f"{self.__class__.__name__}({itemsStr})"

copy()

def lsst.pipe.base.struct.Struct.copy

(

self

)

Make a one-level-deep copy (values are not copied).

Returns
-------
copy : `Struct`
    One-level-deep copy of this Struct.

Definition at line 133 of file struct.py.

    def copy(self):
        """Make a one-level-deep copy (values are not copied).
 
        Returns
        -------
        copy : `Struct`
            One-level-deep copy of this Struct.
        """
        return Struct(**self.getDict())
 

getDict()

def lsst.pipe.base.struct.Struct.getDict

(

self

)

Get a dictionary of fields in this struct.

Returns
-------
structDict : `dict`
    Dictionary with field names as keys and field values as values.
    The values are shallow copies.

Definition at line 93 of file struct.py.

    def getDict(self):
        """Get a dictionary of fields in this struct.
 
        Returns
        -------
        structDict : `dict`
            Dictionary with field names as keys and field values as values.
            The values are shallow copies.
        """
        return self.__dict__.copy()
 

mergeItems()

def lsst.pipe.base.struct.Struct.mergeItems	(		self,
			struct,
		*	nameList
	)

Copy specified fields from another struct, provided they don't
already exist.

Parameters
----------
struct : `Struct`
    `Struct` from which to copy.
*nameList : `str`
    All remaining arguments are names of items to copy.

Raises
------
RuntimeError
    Raised if any item in nameList already exists in self (but any
    items before the conflicting item in nameList will have been
    copied).

Examples
--------
For example::

    foo.copyItems(other, "itemName1", "itemName2")

copies ``other.itemName1`` and ``other.itemName2`` into self.

Definition at line 104 of file struct.py.

    def mergeItems(self, struct, *nameList):
        """Copy specified fields from another struct, provided they don't
        already exist.
 
        Parameters
        ----------
        struct : `Struct`
            `Struct` from which to copy.
        *nameList : `str`
            All remaining arguments are names of items to copy.
 
        Raises
        ------
        RuntimeError
            Raised if any item in nameList already exists in self (but any
            items before the conflicting item in nameList will have been
            copied).
 
        Examples
        --------
        For example::
 
            foo.copyItems(other, "itemName1", "itemName2")
 
        copies ``other.itemName1`` and ``other.itemName2`` into self.
        """
        for name in nameList:
            self.__safeAdd(name, getattr(struct, name))
 

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-0.4.3/Linux64/pipe_base/22.0.1+94e66cc9ed/python/lsst/pipe/base/struct.py