lsst.afw.typehandling._GenericMap.AutoKeyMeta Class Reference

Inheritance diagram for lsst.afw.typehandling._GenericMap.AutoKeyMeta:

Public Member Functions
def	__call__ (cls, *args, **kwargs)
def	__new__ (cls, name, bases, attrs)
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

A metaclass for abstract mappings whose key type is implied by their
constructor arguments.

This metaclass requires that the mapping have a `dict`-like constructor,
i.e., it takes a mapping or an iterable of key-value pairs as its first
positional parameter.

This class differs from `~lsst.utils.TemplateMeta` only in that the dtype
(or equivalent) constructor keyword is optional. If it is omitted, the
class will attempt to infer it from the first argument.

Definition at line 122 of file _GenericMap.py.

Member Function Documentation

__call__()

def lsst.afw.typehandling._GenericMap.AutoKeyMeta.__call__	(		cls,
		*	args,
		**	kwargs
	)

Reimplemented from lsst.utils.wrappers.TemplateMeta.

Definition at line 135 of file _GenericMap.py.

    def __call__(cls, *args, **kwargs):  # noqa N805, non-self first param
        if len(cls.TEMPLATE_PARAMS) != 1:
            raise ValueError("AutoKeyMeta requires exactly one template parameter")
        dtypeKey = cls.TEMPLATE_PARAMS[0]
        dtype = kwargs.get(dtypeKey, None)
 
        # Try to infer dtype if not provided
        if dtype is None and len(args) >= 1:
            dtype = cls._guessKeyType(args[0])
            if dtype is not None:
                kwargs[dtypeKey] = dtype
 
        return super().__call__(*args, **kwargs)
 

__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

Reimplemented in lsst.afw.table._base.Catalog, and lsst.afw.cameraGeom._detectorCollection.DetectorCollectionBase.

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

Reimplemented in lsst.afw.cameraGeom._detectorCollection.DetectorCollectionBase.

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/0.4.3/Linux64/afw/21.0.0-25-g1d57be3cd+e73869a214/python/lsst/afw/typehandling/_GenericMap.py