Inheritance diagram for lsst.afw.table.base.baseContinued.Catalog:

Public Member Functions
def	getColumnView (self)

def	__getitem__ (self, key)

def	__setitem__ (self, key, value)

def	__delitem__ (self, key)

def	append (self, record)

def	insert (self, key, value)

def	clear (self)

def	addNew (self)

def	cast (self, type_, deep=False)

def	copy (self, deep=False)

def	extend (self, iterable, deep=False, mapper=None)

def	__reduce__ (self)

def	asAstropy (self, cls=None, copy=False, unviewable="copy")
	Return an astropy.table.Table (or subclass thereof) view into this catalog. More...

def	__dir__ (self)

def	__getattr__ (self, name)

def	__str__ (self)

def	__repr__ (self)

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	__iter__ (cls)

def	__len__ (cls)

def	__contains__ (cls, key)

def	keys (cls)

def	values (cls)

def	items (cls)

def	get (cls, key, default=None)

Properties
	columns = property(__getColumns, doc="a column view of the catalog")

Detailed Description

Definition at line 94 of file baseContinued.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
 

◆ delitem()

def lsst.afw.table.base.baseContinued.Catalog.__delitem__	(	self,
		key
	)

Definition at line 153 of file baseContinued.py.

     def __delitem__(self, key):
         self._columns = None
         if isinstance(key, slice):
             self._delslice_(key)
         else:
             self._delitem_(key)
 

◆ dir()

def lsst.afw.table.base.baseContinued.Catalog.__dir__ ( self )

This custom dir is necessary due to the custom getattr below.
Without it, not all of the methods available are returned with dir.
See DM-7199

Definition at line 302 of file baseContinued.py.

     def __dir__(self):
         """
         This custom dir is necessary due to the custom getattr below.
         Without it, not all of the methods available are returned with dir.
         See DM-7199
         """
         def recursive_get_class_dir(cls):
             """
             Return a set containing the names of all methods
             for a given class *and* all of its subclasses.
             """
             result = set()
             if cls.__bases__:
                 for subcls in cls.__bases__:
                     result |= recursive_get_class_dir(subcls)
             result |= set(cls.__dict__.keys())
             return result
         return sorted(set(dir(self.columns)) | set(dir(self.table)) |
                       recursive_get_class_dir(type(self)) | set(self.__dict__.keys()))
 

◆ getattr()

def lsst.afw.table.base.baseContinued.Catalog.__getattr__	(	self,
		name
	)

Definition at line 322 of file baseContinued.py.

     def __getattr__(self, name):
         # Catalog forwards unknown method calls to its table and column view
         # for convenience.  (Feature requested by RHL; complaints about magic
         # should be directed to him.)
         if name == "_columns":
             self._columns = None
             return None
         try:
             return getattr(self.table, name)
         except AttributeError:
             return getattr(self.columns, name)
 

◆ getitem()

def lsst.afw.table.base.baseContinued.Catalog.__getitem__	(	self,
		key
	)

Return the record at index key if key is an integer,
return a column if key is a string field name or Key,
or return a subset of the catalog if key is a slice
or boolean NumPy array.

Definition at line 106 of file baseContinued.py.

     def __getitem__(self, key):
         """Return the record at index key if key is an integer,
         return a column if key is a string field name or Key,
         or return a subset of the catalog if key is a slice
         or boolean NumPy array.
         """
         if type(key) is slice:
             (start, stop, step) = (key.start, key.stop, key.step)
             if step is None:
                 step = 1
             if start is None:
                 start = 0
             if stop is None:
                 stop = len(self)
             return self.subset(start, stop, step)
         elif isinstance(key, np.ndarray):
             if key.dtype == bool:
                 return self.subset(key)
             raise RuntimeError("Unsupported array type for indexing non-contiguous Catalog: %s" %
                                (key.dtype,))
         elif isinstance(key, Key) or isinstance(key, str):
             if not self.isContiguous():
                 if isinstance(key, str):
                     key = self.schema[key].asKey()
                 array = self._getitem_(key)
                 # This array doesn't share memory with the Catalog, so don't let it be modified by
                 # the user who thinks that the Catalog itself is being modified.
                 # Just be aware that this array can only be passed down to C++ as an ndarray::Array<T const>
                 # instead of an ordinary ndarray::Array<T>. If pybind isn't letting it down into C++,
                 # you may have left off the 'const' in the definition.
                 array.flags.writeable = False
                 return array
             return self.columns[key]
         else:
             return self._getitem_(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
 

◆ reduce()

def lsst.afw.table.base.baseContinued.Catalog.__reduce__ ( self )

Definition at line 224 of file baseContinued.py.

     def __reduce__(self):
         import lsst.afw.fits
         return lsst.afw.fits.reduceToFits(self)
 

◆ repr()

def lsst.afw.table.base.baseContinued.Catalog.__repr__ ( self )

Definition at line 342 of file baseContinued.py.

     def __repr__(self):
         return "%s\n%s" % (type(self), self)
 
 
 Catalog.register("Base", BaseCatalog)

◆ setitem()

def lsst.afw.table.base.baseContinued.Catalog.__setitem__	(	self,
		key,
		value
	)

If ``key`` is an integer, set ``catalog[key]`` to ``value``. Otherwise select column ``key``
and set it to ``value``.

Definition at line 142 of file baseContinued.py.

     def __setitem__(self, key, value):
         """
         If ``key`` is an integer, set ``catalog[key]`` to ``value``. Otherwise select column ``key``
         and set it to ``value``.
         """
         self._columns = None
         if isinstance(key, Key) or isinstance(key, str):
             self.columns[key] = value
         else:
             return self.set(key, value)
 

◆ str()

def lsst.afw.table.base.baseContinued.Catalog.__str__ ( self )

Definition at line 334 of file baseContinued.py.

     def __str__(self):
         if self.isContiguous():
             return str(self.asAstropy())
         else:
             fields = ' '.join(x.field.getName() for x in self.schema)
             string = "Non-contiguous afw.Catalog of %d rows.\ncolumns: %s" % (len(self), fields)
             return string
 

◆ 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()))
 

◆ addNew()

def lsst.afw.table.base.baseContinued.Catalog.addNew ( self )

Definition at line 172 of file baseContinued.py.

     def addNew(self):
         self._columns = None
         return self._addNew()
 

◆ 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
 

◆ append()

def lsst.afw.table.base.baseContinued.Catalog.append	(	self,
		record
	)

Definition at line 160 of file baseContinued.py.

     def append(self, record):
         self._columns = None
         self._append(record)
 

◆ asAstropy()

def lsst.afw.table.base.baseContinued.Catalog.asAstropy	(	self,
		cls = `None`,
		copy = `False`,
		unviewable = `"copy"`
	)

Return an astropy.table.Table (or subclass thereof) view into this catalog.

Parameters

[in]	cls	Table subclass to use; None implies astropy.table.Table itself. Use astropy.table.QTable to get Quantity columns.
[in]	copy	Whether to copy data from the LSST catalog to the astropy table. Not copying is usually faster, but can keep memory from being freed if columns are later removed from the Astropy view.
[in]	unviewable	One of the following options, indicating how to handle field types (string and Flag) for which views cannot be constructed: 'copy' (default): copy only the unviewable fields. 'raise': raise ValueError if unviewable fields are present. 'skip': do not include unviewable fields in the Astropy Table. This option is ignored if copy=True.

Definition at line 228 of file baseContinued.py.

     def asAstropy(self, cls=None, copy=False, unviewable="copy"):
         """!Return an astropy.table.Table (or subclass thereof) view into this catalog.
 
         @param[in]   cls        Table subclass to use; None implies astropy.table.Table itself.
                                 Use astropy.table.QTable to get Quantity columns.
 
         @param[in]  copy        Whether to copy data from the LSST catalog to the astropy table.
                                 Not copying is usually faster, but can keep memory from being
                                 freed if columns are later removed from the Astropy view.
 
         @param[in]  unviewable  One of the following options, indicating how to handle field types
                                 (string and Flag) for which views cannot be constructed:
                                   - 'copy' (default): copy only the unviewable fields.
                                   - 'raise': raise ValueError if unviewable fields are present.
                                   - 'skip': do not include unviewable fields in the Astropy Table.
                                 This option is ignored if copy=True.
         """
         import astropy.table
         if cls is None:
             cls = astropy.table.Table
         if unviewable not in ("copy", "raise", "skip"):
             raise ValueError(
                 "'unviewable'=%r must be one of 'copy', 'raise', or 'skip'" % (unviewable,))
         ps = self.getMetadata()
         meta = ps.toOrderedDict() if ps is not None else None
         columns = []
         items = self.schema.extract("*", ordered=True)
         for name, item in items.items():
             key = item.key
             unit = item.field.getUnits() or None  # use None instead of "" when empty
             if key.getTypeString() == "String":
                 if not copy:
                     if unviewable == "raise":
                         raise ValueError("Cannot extract string "
                                          "unless copy=True or unviewable='copy' or 'skip'.")
                     elif unviewable == "skip":
                         continue
                 data = np.zeros(
                     len(self), dtype=np.dtype((str, key.getSize())))
                 for i, record in enumerate(self):
                     data[i] = record.get(key)
             elif key.getTypeString() == "Flag":
                 if not copy:
                     if unviewable == "raise":
                         raise ValueError("Cannot extract packed bit columns "
                                          "unless copy=True or unviewable='copy' or 'skip'.")
                     elif unviewable == "skip":
                         continue
                 data = self.columns.get_bool_array(key)
             elif key.getTypeString() == "Angle":
                 data = self.columns.get(key)
                 unit = "radian"
                 if copy:
                     data = data.copy()
             elif "Array" in key.getTypeString() and key.isVariableLength():
                 # Can't get columns for variable-length array fields.
                 if unviewable == "raise":
                     raise ValueError("Cannot extract variable-length array fields unless unviewable='skip'.")
                 elif unviewable == "skip" or unviewable == "copy":
                     continue
             else:
                 data = self.columns.get(key)
                 if copy:
                     data = data.copy()
             columns.append(
                 astropy.table.Column(
                     data,
                     name=name,
                     unit=unit,
                     description=item.field.getDoc()
                 )
             )
         return cls(columns, meta=meta, copy=False)
 

◆ cast()

def lsst.afw.table.base.baseContinued.Catalog.cast	(	self,
		type_,
		deep = `False`
	)

Return a copy of the catalog with the given type, optionally
cloning the table and deep-copying all records if deep==True.

Definition at line 176 of file baseContinued.py.

     def cast(self, type_, deep=False):
         """Return a copy of the catalog with the given type, optionally
         cloning the table and deep-copying all records if deep==True.
         """
         if deep:
             table = self.table.clone()
             table.preallocate(len(self))
         else:
             table = self.table
         copy = type_(table)
         copy.extend(self, deep=deep)
         return copy
 

◆ clear()

def lsst.afw.table.base.baseContinued.Catalog.clear ( self )

Definition at line 168 of file baseContinued.py.

     def clear(self):
         self._columns = None
         self._clear()
 

◆ copy()

def lsst.afw.table.base.baseContinued.Catalog.copy	(	self,
		deep = `False`
	)

Copy a catalog (default is not a deep copy).

Definition at line 189 of file baseContinued.py.

     def copy(self, deep=False):
         """
         Copy a catalog (default is not a deep copy).
         """
         return self.cast(type(self), deep)
 

◆ extend()

def lsst.afw.table.base.baseContinued.Catalog.extend	(	self,
		iterable,
		deep = `False`,
		mapper = `None`
	)

Append all records in the given iterable to the catalog.

Arguments:
  iterable ------ any Python iterable containing records
  deep ---------- if True, the records will be deep-copied; ignored
          if mapper is not None (that always implies True).
  mapper -------- a SchemaMapper object used to translate records

Definition at line 195 of file baseContinued.py.

     def extend(self, iterable, deep=False, mapper=None):
         """Append all records in the given iterable to the catalog.
 
         Arguments:
           iterable ------ any Python iterable containing records
           deep ---------- if True, the records will be deep-copied; ignored
                           if mapper is not None (that always implies True).
           mapper -------- a SchemaMapper object used to translate records
         """
         self._columns = None
         # We can't use isinstance here, because the SchemaMapper symbol isn't available
         # when this code is part of a subclass of Catalog in another package.
         if type(deep).__name__ == "SchemaMapper":
             mapper = deep
             deep = None
         if isinstance(iterable, type(self)):
             if mapper is not None:
                 self._extend(iterable, mapper)
             else:
                 self._extend(iterable, deep)
         else:
             for record in iterable:
                 if mapper is not None:
                     self._append(self.table.copyRecord(record, mapper))
                 elif deep:
                     self._append(self.table.copyRecord(record))
                 else:
                     self._append(record)
 

◆ 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)
 

◆ getColumnView()

def lsst.afw.table.base.baseContinued.Catalog.getColumnView ( self )

Definition at line 96 of file baseContinued.py.

     def getColumnView(self):
         self._columns = self._getColumnView()
         return self._columns
 

◆ insert()

def lsst.afw.table.base.baseContinued.Catalog.insert	(	self,
		key,
		value
	)

Definition at line 164 of file baseContinued.py.

     def insert(self, key, value):
         self._columns = None
         self._insert(key, value)
 

◆ 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()
 

Property Documentation

◆ columns

lsst.afw.table.base.baseContinued.Catalog.columns = property(__getColumns, doc="a column view of the catalog")

static

Definition at line 104 of file baseContinued.py.

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

Public Member Functions

Properties

Detailed Description

Member Function Documentation

◆ __call__()

◆ __contains__()

◆ __delitem__()

◆ __dir__()

◆ __getattr__()

◆ __getitem__()

◆ __instancecheck__()

◆ __iter__()

◆ __len__()

◆ __new__()

◆ __reduce__()

◆ __repr__()

◆ __setitem__()

◆ __str__()

◆ __subclasscheck__()

◆ __subclasses__()

◆ addNew()

◆ alias()

◆ append()

◆ asAstropy()

◆ cast()

◆ clear()

◆ copy()

◆ extend()

◆ get()

◆ getColumnView()

◆ insert()

◆ items()

◆ keys()

◆ register()

◆ values()

Property Documentation

◆ columns

◆ call()

◆ contains()

◆ delitem()

◆ dir()

◆ getattr()

◆ getitem()

◆ instancecheck()

◆ iter()

◆ len()

◆ new()

◆ reduce()

◆ repr()

◆ setitem()

◆ str()

◆ subclasscheck()

◆ subclasses()