lsst.afw.table.schema.schemaContinued.Key Class Reference

Inheritance diagram for lsst.afw.table.schema.schemaContinued.Key:

Public Member Functions
def	__new__ (cls, name, bases, attrs)
def	__call__ (cls, args, kwds)
def	__subclasscheck__ (cls, subclass)
def	__instancecheck__ (cls, instance)
def	__subclasses__ (cls)
def	register (cls, key, subclass)
def	alias (cls, key, subclass)
def	__getitem__ (cls, key)
def	__iter__ (cls)
def	__len__ (cls)
def	__contains__ (cls, key)
def	keys (cls)
def	values (cls)
def	items (cls)
def	get (cls, key, default=None)

Detailed Description

Definition at line 50 of file schemaContinued.py.

Member Function Documentation

__call__()

def lsst.utils.wrappers.TemplateMeta.__call__ (   cls,   args,   kwds  )

inherited

Definition at line 293 of file wrappers.py.

    def __call__(cls, *args, **kwds):
        # __call__ is invoked when someone tries to construct an instance of
        # the abstract base class.
        # If the ABC defines a "TEMPLATE_PARAMS" attribute, we use those strings
        # as the kwargs we should intercept to find the right type.
        # Generate a type mapping key from input keywords. If the type returned
        # from the keyword lookup is a numpy dtype object, fetch the underlying
        # type of the dtype
        key = []
        for p, d in zip(cls.TEMPLATE_PARAMS, cls.TEMPLATE_DEFAULTS):
            tempKey = kwds.pop(p, d)
            if isinstance(tempKey, np.dtype):
                tempKey = tempKey.type
            key.append(tempKey)
        key = tuple(key)

        # indices are only tuples if there are multiple elements
        clz = cls._registry.get(key[0] if len(key) == 1 else key, None)
        if clz is None:
            d = {k: v for k, v in zip(cls.TEMPLATE_PARAMS, key)}
            raise TypeError("No registered subclass for {}.".format(d))
        return clz(*args, **kwds)

__contains__()

def lsst.utils.wrappers.TemplateMeta.__contains__ (   cls,   key  )

inherited

Definition at line 458 of file wrappers.py.

    def __contains__(cls, key):
        return key in cls._registry

__getitem__()

def lsst.utils.wrappers.TemplateMeta.__getitem__ (   cls,   key  )

inherited

Definition at line 449 of file wrappers.py.

    def __getitem__(cls, key):
        return cls._registry[key]

__instancecheck__()

def lsst.utils.wrappers.TemplateMeta.__instancecheck__ (   cls,   instance  )

inherited

Definition at line 326 of file wrappers.py.

    def __instancecheck__(cls, instance):
        # Special method hook for the isinstance built-in: we return true for
        # an instance of any registered type or true subclass thereof.
        if type(instance) in cls._registry:
            return True
        for v in cls._registry.values():
            if isinstance(instance, v):
                return True
        return False

__iter__()

def lsst.utils.wrappers.TemplateMeta.__iter__ (   cls )

inherited

Definition at line 452 of file wrappers.py.

    def __iter__(cls):
        return iter(cls._registry)

__len__()

def lsst.utils.wrappers.TemplateMeta.__len__ (   cls )

inherited

Definition at line 455 of file wrappers.py.

    def __len__(cls):
        return len(cls._registry)

__new__()

def lsst.utils.wrappers.TemplateMeta.__new__ (   cls,   name,   bases,   attrs  )

inherited

Definition at line 261 of file wrappers.py.

    def __new__(cls, name, bases, attrs):
        # __new__ is invoked when the abstract base class is defined (via a
        # class statement).  We save a dict of class attributes (including
        # methods) that were defined in the class body so we can copy them
        # to registered subclasses later.
        # We also initialize an empty dict to store the registered subclasses.
        attrs["_inherited"] = {k: v for k, v in attrs.items()
                               if isAttributeSafeToTransfer(k, v)}
        # The special "TEMPLATE_PARAMS" class attribute, if defined, contains
        # names of the template parameters, which we use to set those
        # attributes on registered subclasses and intercept arguments to the
        # constructor.  This line removes it from the dict of things that
        # should be inherited while setting a default of 'dtype' if it's not
        # defined.
        attrs["TEMPLATE_PARAMS"] = \
            attrs["_inherited"].pop("TEMPLATE_PARAMS", ("dtype",))
        attrs["TEMPLATE_DEFAULTS"] = \
            attrs["_inherited"].pop("TEMPLATE_DEFAULTS",
                                    (None,)*len(attrs["TEMPLATE_PARAMS"]))
        attrs["_registry"] = dict()
        self = type.__new__(cls, name, bases, attrs)

        if len(self.TEMPLATE_PARAMS) == 0:
            raise ValueError(
                "TEMPLATE_PARAMS must be a tuple with at least one element."
            )
        if len(self.TEMPLATE_DEFAULTS) != len(self.TEMPLATE_PARAMS):
            raise ValueError(
                "TEMPLATE_PARAMS and TEMPLATE_DEFAULTS must have same length."
            )
        return self

__subclasscheck__()

def lsst.utils.wrappers.TemplateMeta.__subclasscheck__ (   cls,   subclass  )

inherited

Definition at line 316 of file wrappers.py.

    def __subclasscheck__(cls, subclass):
        # Special method hook for the issubclass built-in: we return true for
        # any registered type or true subclass thereof.
        if subclass in cls._registry:
            return True
        for v in cls._registry.values():
            if issubclass(subclass, v):
                return True
        return False

__subclasses__()

def lsst.utils.wrappers.TemplateMeta.__subclasses__ (   cls )

inherited

Return a tuple of all classes that inherit from this class.

Definition at line 336 of file wrappers.py.

    def __subclasses__(cls):
        """Return a tuple of all classes that inherit from this class.
        """
        # This special method isn't defined as part of the Python data model,
        # but it exists on builtins (including ABCMeta), and it provides useful
        # functionality.
        return tuple(set(cls._registry.values()))

alias()

def lsst.utils.wrappers.TemplateMeta.alias (   cls,   key,   subclass  )

inherited

Add an alias that allows an existing subclass to be accessed with a
different key.

Definition at line 429 of file wrappers.py.

    def alias(cls, key, subclass):
        """Add an alias that allows an existing subclass to be accessed with a
        different key.
        """
        if key is None:
            raise ValueError("None may not be used as a key.")
        if key in cls._registry:
            raise KeyError("Cannot multiply-register key {}".format(key))
        primaryKey = tuple(getattr(subclass, p, None)
                           for p in cls.TEMPLATE_PARAMS)
        if len(primaryKey) == 1:
            # indices are only tuples if there are multiple elements
            primaryKey = primaryKey[0]
        if cls._registry.get(primaryKey, None) != subclass:
            raise ValueError("Subclass is not registered with this base class.")
        cls._registry[key] = subclass

get()

def lsst.utils.wrappers.TemplateMeta.get (   cls,   key,   default = None  )

inherited

Return the subclass associated with the given key (including
aliases), or ``default`` if the key is not recognized.

Definition at line 477 of file wrappers.py.

    def get(cls, key, default=None):
        """Return the subclass associated with the given key (including
        aliases), or ``default`` if the key is not recognized.
        """
        return cls._registry.get(key, default)

items()

def lsst.utils.wrappers.TemplateMeta.items (   cls )

inherited

Return an iterable of (key, subclass) pairs.

Definition at line 472 of file wrappers.py.

    def items(cls):
        """Return an iterable of (key, subclass) pairs.
        """
        return cls._registry.items()

keys()

def lsst.utils.wrappers.TemplateMeta.keys (   cls )

inherited

Return an iterable containing all keys (including aliases).

Definition at line 461 of file wrappers.py.

    def keys(cls):
        """Return an iterable containing all keys (including aliases).
        """
        return cls._registry.keys()

register()

def lsst.utils.wrappers.TemplateMeta.register (   cls,   key,   subclass  )

inherited

Register a subclass of this ABC with the given key (a string,
number, type, or other hashable).

Register may only be called once for a given key or a given subclass.

Definition at line 344 of file wrappers.py.

    def register(cls, key, subclass):
        """Register a subclass of this ABC with the given key (a string,
        number, type, or other hashable).

        Register may only be called once for a given key or a given subclass.
        """
        if key is None:
            raise ValueError("None may not be used as a key.")
        if subclass in cls._registry.values():
            raise ValueError(
                "This subclass has already registered with another key; "
                "use alias() instead."
            )
        if cls._registry.setdefault(key, subclass) != subclass:
            if len(cls.TEMPLATE_PARAMS) == 1:
                d = {cls.TEMPLATE_PARAMS[0]: key}
            else:
                d = {k: v for k, v in zip(cls.TEMPLATE_PARAMS, key)}
            raise KeyError(
                "Another subclass is already registered with {}".format(d)
            )
        # If the key used to register a class matches the default key,
        # make the static methods available through the ABC
        if cls.TEMPLATE_DEFAULTS:
            defaults = (cls.TEMPLATE_DEFAULTS[0] if
                        len(cls.TEMPLATE_DEFAULTS) == 1 else
                        cls.TEMPLATE_DEFAULTS)
            if key == defaults:
                conflictStr = ("Base class has attribute {}"
                               " which is a {} method of {}."
                               " Cannot link method to base class.")
                # In the following if statements, the explicit lookup in
                # __dict__ must be done, as a call to getattr returns the
                # bound method, which no longer reports as a static or class
                # method. The static methods must be transfered to the ABC
                # in this unbound state, so that python will still see them
                # as static methods and not attempt to pass self. The class
                # methods must be transfered to the ABC as a bound method
                # so that the correct cls be called with the class method
                for name in subclass.__dict__:
                    if name in ("__new__", "__init_subclass__"):
                        continue
                    obj = subclass.__dict__[name]
                    # copy over the static methods
                    isBuiltin = isinstance(obj, types.BuiltinFunctionType)
                    isStatic = isinstance(obj, staticmethod)
                    if isBuiltin or isStatic:
                        if hasattr(cls, name):
                            raise AttributeError(
                                conflictStr.format(name, "static", subclass))
                        setattr(cls, name, obj)
                    # copy over the class methods
                    elif isinstance(obj, classmethod):
                        if hasattr(cls, name):
                            raise AttributeError(
                                conflictStr.format(name, "class", subclass))
                        setattr(cls, name, getattr(subclass, name))

        def setattrSafe(name, value):
            try:
                currentValue = getattr(subclass, name)
                if currentValue != value:
                    msg = ("subclass already has a '{}' attribute with "
                           "value {} != {}.")
                    raise ValueError(
                        msg.format(name, currentValue, value)
                    )
            except AttributeError:
                setattr(subclass, name, value)

        if len(cls.TEMPLATE_PARAMS) == 1:
            setattrSafe(cls.TEMPLATE_PARAMS[0], key)
        elif len(cls.TEMPLATE_PARAMS) == len(key):
            for p, k in zip(cls.TEMPLATE_PARAMS, key):
                setattrSafe(p, k)
        else:
            raise ValueError(
                "key must have {} elements (one for each of {})".format(
                    len(cls.TEMPLATE_PARAMS), cls.TEMPLATE_PARAMS
                )
            )

        for name, attr in cls._inherited.items():
            setattr(subclass, name, attr)

values()

def lsst.utils.wrappers.TemplateMeta.values (   cls )

inherited

Return an iterable of registered subclasses, with duplicates
corresponding to any aliases.

Definition at line 466 of file wrappers.py.

    def values(cls):
        """Return an iterable of registered subclasses, with duplicates
        corresponding to any aliases.
        """
        return cls._registry.values()

---

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

---

Generated on Thu Aug 8 2019 20:21:05 for LSSTApplications by   1.8.13