Inheritance diagram for lsst.obs.base.gen2to3.convertRepo.ConvertRepoTask:

Public Member Functions
def	__init__ (self, config=None, Butler3 butler3, Instrument instrument, *kwargs)

def	isDatasetTypeIncluded (self, str datasetTypeName)

str	useSkyMap (self, BaseSkyMap skyMap, str skyMapName)

def	registerUsedSkyMaps (self, Optional[ConversionSubset] subset)

def	useSkyPix (self, SkyPixDimension dimension)

def	registerUsedSkyPix (self, Optional[ConversionSubset] subset)

def	run (self, str root, *Optional[List[CalibRepo]] calibs=None, Optional[List[Rerun]] reruns=None, Optional[Iterable[int]] visits=None, Optional[Pool] pool=None, int processes=1)

def	emptyMetadata (self)

def	getSchemaCatalogs (self)

def	getAllSchemaCatalogs (self)

def	getFullMetadata (self)

def	getFullName (self)

def	getName (self)

def	getTaskDict (self)

def	makeSubtask (self, name, **keyArgs)

def	timer (self, name, logLevel=Log.DEBUG)

def	makeField (cls, doc)

def	__reduce__ (self)

Public Attributes
	butler3

	registry

	universe

	raws

	defineVisits

	instrument

	translatorFactory

	metadata

	log

	config

Static Public Attributes
	ConfigClass = ConvertRepoConfig

Detailed Description

A task that converts one or more related Gen2 data repositories to a
single Gen3 data repository (with multiple collections).

Parameters
----------
config: `ConvertRepoConfig`
    Configuration for this task.
butler3: `lsst.daf.butler.Butler`
    A writeable Gen3 Butler instance that represents the data repository
    that datasets will be ingested into.  If the 'raw' dataset is
    configured to be included in the conversion, ``butler3.run`` should be
    set to the name of the collection raws should be ingested into, and
    ``butler3.collections`` should include a calibration collection from
    which the ``camera`` dataset can be loaded, unless a calibration repo
    is converted and ``doWriteCuratedCalibrations`` is `True`.
instrument : `lsst.obs.base.Instrument`
    The Gen3 instrument that should be used for this conversion.
**kwargs
    Other keyword arguments are forwarded to the `Task` constructor.

Notes
-----
Most of the work of converting repositories is delegated to instances of
the `RepoConverter` hierarchy.  The `ConvertRepoTask` instance itself holds
only state that is relevant for all Gen2 repositories being ingested, while
each `RepoConverter` instance holds only state relevant for the conversion
of a single Gen2 repository.  Both the task and the `RepoConverter`
instances are single use; `ConvertRepoTask.run` and most `RepoConverter`
methods may only be called once on a particular instance.

Definition at line 390 of file convertRepo.py.

Constructor & Destructor Documentation

◆ init()

def lsst.obs.base.gen2to3.convertRepo.ConvertRepoTask.__init__	(		self,
			config = `None`,
		*Butler3	butler3,
		Instrument	instrument,
		**	kwargs
	)

Definition at line 426 of file convertRepo.py.

     def __init__(self, config=None, *, butler3: Butler3, instrument: Instrument, **kwargs):
         config.validate()  # Not a CmdlineTask nor PipelineTask, so have to validate the config here.
         super().__init__(config, **kwargs)
         # Make self.butler3 one that doesn't have any collections associated
         # with it - those are needed by RawIngestTask and DefineVisitsTask, but
         # we don't want them messing with converted datasets, because those
         # have their own logic for figuring out which collections to write to.
         self.butler3 = Butler3(butler=butler3)
         self.registry = self.butler3.registry
         self.universe = self.registry.dimensions
         if self.isDatasetTypeIncluded("raw"):
             self.makeSubtask("raws", butler=butler3)
             self.makeSubtask("defineVisits", butler=butler3)
         else:
             self.raws = None
             self.defineVisits = None
         self.instrument = instrument
         self._configuredSkyMapsBySha1 = {}
         self._configuredSkyMapsByName = {}
         for name, config in self.config.skyMaps.items():
             instance = config.skyMap.apply()
             self._populateSkyMapDicts(name, instance)
         self._usedSkyPix = set()
         self.translatorFactory = self.instrument.makeDataIdTranslatorFactory()
         self.translatorFactory.log = self.log.getChild("translators")
  

Member Function Documentation

◆ reduce()

def lsst.pipe.base.task.Task.__reduce__ ( self )

inherited

Pickler.

Reimplemented in lsst.pipe.drivers.multiBandDriver.MultiBandDriverTask, and lsst.pipe.drivers.coaddDriver.CoaddDriverTask.

Definition at line 432 of file task.py.

     def __reduce__(self):
         """Pickler.
         """
         return self._unpickle_via_factory, (self.__class__, [], self._reduce_kwargs())

◆ emptyMetadata()

def lsst.pipe.base.task.Task.emptyMetadata ( self )

inherited

Empty (clear) the metadata for this Task and all sub-Tasks.

Definition at line 166 of file task.py.

     def emptyMetadata(self):
         """Empty (clear) the metadata for this Task and all sub-Tasks.
         """
         for subtask in self._taskDict.values():
             subtask.metadata = dafBase.PropertyList()
  

◆ getAllSchemaCatalogs()

def lsst.pipe.base.task.Task.getAllSchemaCatalogs ( self )

inherited

Get schema catalogs for all tasks in the hierarchy, combining the
results into a single dict.

Returns
-------
schemacatalogs : `dict`
    Keys are butler dataset type, values are a empty catalog (an
    instance of the appropriate `lsst.afw.table` Catalog type) for all
    tasks in the hierarchy, from the top-level task down
    through all subtasks.

Notes
-----
This method may be called on any task in the hierarchy; it will return
the same answer, regardless.

The default implementation should always suffice. If your subtask uses
schemas the override `Task.getSchemaCatalogs`, not this method.

Definition at line 204 of file task.py.

     def getAllSchemaCatalogs(self):
         """Get schema catalogs for all tasks in the hierarchy, combining the
         results into a single dict.
  
         Returns
         -------
         schemacatalogs : `dict`
             Keys are butler dataset type, values are a empty catalog (an
             instance of the appropriate `lsst.afw.table` Catalog type) for all
             tasks in the hierarchy, from the top-level task down
             through all subtasks.
  
         Notes
         -----
         This method may be called on any task in the hierarchy; it will return
         the same answer, regardless.
  
         The default implementation should always suffice. If your subtask uses
         schemas the override `Task.getSchemaCatalogs`, not this method.
         """
         schemaDict = self.getSchemaCatalogs()
         for subtask in self._taskDict.values():
             schemaDict.update(subtask.getSchemaCatalogs())
         return schemaDict
  

◆ getFullMetadata()

def lsst.pipe.base.task.Task.getFullMetadata ( self )

inherited

Get metadata for all tasks.

Returns
-------
metadata : `lsst.daf.base.PropertySet`
    The `~lsst.daf.base.PropertySet` keys are the full task name.
    Values are metadata for the top-level task and all subtasks,
    sub-subtasks, etc.

Notes
-----
The returned metadata includes timing information (if
``@timer.timeMethod`` is used) and any metadata set by the task. The
name of each item consists of the full task name with ``.`` replaced
by ``:``, followed by ``.`` and the name of the item, e.g.::

    topLevelTaskName:subtaskName:subsubtaskName.itemName

using ``:`` in the full task name disambiguates the rare situation
that a task has a subtask and a metadata item with the same name.

Definition at line 229 of file task.py.

     def getFullMetadata(self):
         """Get metadata for all tasks.
  
         Returns
         -------
         metadata : `lsst.daf.base.PropertySet`
             The `~lsst.daf.base.PropertySet` keys are the full task name.
             Values are metadata for the top-level task and all subtasks,
             sub-subtasks, etc.
  
         Notes
         -----
         The returned metadata includes timing information (if
         ``@timer.timeMethod`` is used) and any metadata set by the task. The
         name of each item consists of the full task name with ``.`` replaced
         by ``:``, followed by ``.`` and the name of the item, e.g.::
  
             topLevelTaskName:subtaskName:subsubtaskName.itemName
  
         using ``:`` in the full task name disambiguates the rare situation
         that a task has a subtask and a metadata item with the same name.
         """
         fullMetadata = dafBase.PropertySet()
         for fullName, task in self.getTaskDict().items():
             fullMetadata.set(fullName.replace(".", ":"), task.metadata)
         return fullMetadata
  

◆ getFullName()

def lsst.pipe.base.task.Task.getFullName ( self )

inherited

Get the task name as a hierarchical name including parent task
names.

Returns
-------
fullName : `str`
    The full name consists of the name of the parent task and each
    subtask separated by periods. For example:

    - The full name of top-level task "top" is simply "top".
    - The full name of subtask "sub" of top-level task "top" is
      "top.sub".
    - The full name of subtask "sub2" of subtask "sub" of top-level
      task "top" is "top.sub.sub2".

Definition at line 256 of file task.py.

     def getFullName(self):
         """Get the task name as a hierarchical name including parent task
         names.
  
         Returns
         -------
         fullName : `str`
             The full name consists of the name of the parent task and each
             subtask separated by periods. For example:
  
             - The full name of top-level task "top" is simply "top".
             - The full name of subtask "sub" of top-level task "top" is
               "top.sub".
             - The full name of subtask "sub2" of subtask "sub" of top-level
               task "top" is "top.sub.sub2".
         """
         return self._fullName
  

◆ getName()

def lsst.pipe.base.task.Task.getName ( self )

inherited

Get the name of the task.

Returns
-------
taskName : `str`
    Name of the task.

See also
--------
getFullName

Definition at line 274 of file task.py.

     def getName(self):
         """Get the name of the task.
  
         Returns
         -------
         taskName : `str`
             Name of the task.
  
         See also
         --------
         getFullName
         """
         return self._name
  

◆ getSchemaCatalogs()

def lsst.pipe.base.task.Task.getSchemaCatalogs ( self )

inherited

Get the schemas generated by this task.

Returns
-------
schemaCatalogs : `dict`
    Keys are butler dataset type, values are an empty catalog (an
    instance of the appropriate `lsst.afw.table` Catalog type) for
    this task.

Notes
-----

.. warning::

   Subclasses that use schemas must override this method. The default
   implementation returns an empty dict.

This method may be called at any time after the Task is constructed,
which means that all task schemas should be computed at construction
time, *not* when data is actually processed. This reflects the
philosophy that the schema should not depend on the data.

Returning catalogs rather than just schemas allows us to save e.g.
slots for SourceCatalog as well.

See also
--------
Task.getAllSchemaCatalogs

Definition at line 172 of file task.py.

     def getSchemaCatalogs(self):
         """Get the schemas generated by this task.
  
         Returns
         -------
         schemaCatalogs : `dict`
             Keys are butler dataset type, values are an empty catalog (an
             instance of the appropriate `lsst.afw.table` Catalog type) for
             this task.
  
         Notes
         -----
  
         .. warning::
  
            Subclasses that use schemas must override this method. The default
            implementation returns an empty dict.
  
         This method may be called at any time after the Task is constructed,
         which means that all task schemas should be computed at construction
         time, *not* when data is actually processed. This reflects the
         philosophy that the schema should not depend on the data.
  
         Returning catalogs rather than just schemas allows us to save e.g.
         slots for SourceCatalog as well.
  
         See also
         --------
         Task.getAllSchemaCatalogs
         """
         return {}
  

◆ getTaskDict()

def lsst.pipe.base.task.Task.getTaskDict ( self )

inherited

Get a dictionary of all tasks as a shallow copy.

Returns
-------
taskDict : `dict`
    Dictionary containing full task name: task object for the top-level
    task and all subtasks, sub-subtasks, etc.

Definition at line 288 of file task.py.

     def getTaskDict(self):
         """Get a dictionary of all tasks as a shallow copy.
  
         Returns
         -------
         taskDict : `dict`
             Dictionary containing full task name: task object for the top-level
             task and all subtasks, sub-subtasks, etc.
         """
         return self._taskDict.copy()
  

◆ isDatasetTypeIncluded()

def lsst.obs.base.gen2to3.convertRepo.ConvertRepoTask.isDatasetTypeIncluded	(		self,
		str	datasetTypeName
	)

Return `True` if configuration indicates that the given dataset type
should be converted.

This method is intended to be called primarily by the
`RepoConverter` instances used interally by the task.

Parameters
----------
datasetTypeName: str
    Name of the dataset type.

Returns
-------
included : `bool`
    Whether the dataset should be included in the conversion.

Definition at line 461 of file convertRepo.py.

     def isDatasetTypeIncluded(self, datasetTypeName: str):
         """Return `True` if configuration indicates that the given dataset type
         should be converted.
  
         This method is intended to be called primarily by the
         `RepoConverter` instances used interally by the task.
  
         Parameters
         ----------
         datasetTypeName: str
             Name of the dataset type.
  
         Returns
         -------
         included : `bool`
             Whether the dataset should be included in the conversion.
         """
         return (
             any(fnmatch.fnmatchcase(datasetTypeName, pattern)
                 for pattern in self.config.datasetIncludePatterns)
             and not any(fnmatch.fnmatchcase(datasetTypeName, pattern)
                         for pattern in self.config.datasetIgnorePatterns)
         )
  

◆ makeField()

def lsst.pipe.base.task.Task.makeField	(	cls,
		doc
	)

inherited

Make a `lsst.pex.config.ConfigurableField` for this task.

Parameters
----------
doc : `str`
    Help text for the field.

Returns
-------
configurableField : `lsst.pex.config.ConfigurableField`
    A `~ConfigurableField` for this task.

Examples
--------
Provides a convenient way to specify this task is a subtask of another
task.

Here is an example of use:

.. code-block:: python

    class OtherTaskConfig(lsst.pex.config.Config):
        aSubtask = ATaskClass.makeField("brief description of task")

Definition at line 359 of file task.py.

     def makeField(cls, doc):
         """Make a `lsst.pex.config.ConfigurableField` for this task.
  
         Parameters
         ----------
         doc : `str`
             Help text for the field.
  
         Returns
         -------
         configurableField : `lsst.pex.config.ConfigurableField`
             A `~ConfigurableField` for this task.
  
         Examples
         --------
         Provides a convenient way to specify this task is a subtask of another
         task.
  
         Here is an example of use:
  
         .. code-block:: python
  
             class OtherTaskConfig(lsst.pex.config.Config):
                 aSubtask = ATaskClass.makeField("brief description of task")
         """
         return ConfigurableField(doc=doc, target=cls)
  

◆ makeSubtask()

def lsst.pipe.base.task.Task.makeSubtask	(		self,
			name,
		**	keyArgs
	)

inherited

Create a subtask as a new instance as the ``name`` attribute of this
task.

Parameters
----------
name : `str`
    Brief name of the subtask.
keyArgs
    Extra keyword arguments used to construct the task. The following
    arguments are automatically provided and cannot be overridden:

    - "config".
    - "parentTask".

Notes
-----
The subtask must be defined by ``Task.config.name``, an instance of
`~lsst.pex.config.ConfigurableField` or
`~lsst.pex.config.RegistryField`.

Definition at line 299 of file task.py.

     def makeSubtask(self, name, **keyArgs):
         """Create a subtask as a new instance as the ``name`` attribute of this
         task.
  
         Parameters
         ----------
         name : `str`
             Brief name of the subtask.
         keyArgs
             Extra keyword arguments used to construct the task. The following
             arguments are automatically provided and cannot be overridden:
  
             - "config".
             - "parentTask".
  
         Notes
         -----
         The subtask must be defined by ``Task.config.name``, an instance of
         `~lsst.pex.config.ConfigurableField` or
         `~lsst.pex.config.RegistryField`.
         """
         taskField = getattr(self.config, name, None)
         if taskField is None:
             raise KeyError(f"{self.getFullName()}'s config does not have field {name!r}")
         subtask = taskField.apply(name=name, parentTask=self, **keyArgs)
         setattr(self, name, subtask)
  

◆ registerUsedSkyMaps()

def lsst.obs.base.gen2to3.convertRepo.ConvertRepoTask.registerUsedSkyMaps	(		self,
		Optional[ConversionSubset]	subset
	)

Register all skymaps that have been marked as used.

This method is intended to be called primarily by the
`RepoConverter` instances used interally by the task.

Parameters
----------
subset : `ConversionSubset`, optional
    Object that will be used to filter converted datasets by data ID.
    If given, it will be updated with the tracts of this skymap that
    overlap the visits in the subset.

Definition at line 520 of file convertRepo.py.

     def registerUsedSkyMaps(self, subset: Optional[ConversionSubset]):
         """Register all skymaps that have been marked as used.
  
         This method is intended to be called primarily by the
         `RepoConverter` instances used interally by the task.
  
         Parameters
         ----------
         subset : `ConversionSubset`, optional
             Object that will be used to filter converted datasets by data ID.
             If given, it will be updated with the tracts of this skymap that
             overlap the visits in the subset.
         """
         for struct in self._configuredSkyMapsBySha1.values():
             if struct.used:
                 struct.instance.register(struct.name, self.butler3)
                 if subset is not None and self.config.relatedOnly:
                     subset.addSkyMap(self.registry, struct.name)
  

◆ registerUsedSkyPix()

def lsst.obs.base.gen2to3.convertRepo.ConvertRepoTask.registerUsedSkyPix	(		self,
		Optional[ConversionSubset]	subset
	)

Register all skymaps that have been marked as used.

This method is intended to be called primarily by the
`RepoConverter` instances used interally by the task.

Parameters
----------
subset : `ConversionSubset`, optional
    Object that will be used to filter converted datasets by data ID.
    If given, it will be updated with the pixelization IDs that
    overlap the visits in the subset.

Definition at line 552 of file convertRepo.py.

     def registerUsedSkyPix(self, subset: Optional[ConversionSubset]):
         """Register all skymaps that have been marked as used.
  
         This method is intended to be called primarily by the
         `RepoConverter` instances used interally by the task.
  
         Parameters
         ----------
         subset : `ConversionSubset`, optional
             Object that will be used to filter converted datasets by data ID.
             If given, it will be updated with the pixelization IDs that
             overlap the visits in the subset.
         """
         if subset is not None and self.config.relatedOnly:
             for dimension in self._usedSkyPix:
                 subset.addSkyPix(self.registry, dimension)
  

◆ run()

def lsst.obs.base.gen2to3.convertRepo.ConvertRepoTask.run	(		self,
		str	root,
		*Optional[List[CalibRepo]]	calibs = `None`,
		Optional[List[Rerun]]	reruns = `None`,
		Optional[Iterable[int]]	visits = `None`,
		Optional[Pool]	pool = `None`,
		int	processes = `1`
	)

Convert a group of related data repositories.

Parameters
----------
root : `str`
    Complete path to the root Gen2 data repository.  This should be
    a data repository that includes a Gen2 registry and any raw files
    and/or reference catalogs.
calibs : `list` of `CalibRepo`
    Specifications for Gen2 calibration repos to convert.  If `None`
    (default), curated calibrations only will be written to the default
    calibration collection for this instrument; set to ``()`` explictly
    to disable this.
reruns : `list` of `Rerun`
    Specifications for rerun (processing output) repos to convert.  If
    `None` (default), no reruns are converted.
visits : iterable of `int`, optional
    The integer IDs of visits to convert.  If not provided, all visits
    in the Gen2 root repository will be converted.
pool : `multiprocessing.Pool`, optional
    If not `None`, a process pool with which to parallelize some
    operations.
processes : `int`, optional
    The number of processes to use for conversion.

Definition at line 569 of file convertRepo.py.

             processes: int = 1):
         """Convert a group of related data repositories.
  
         Parameters
         ----------
         root : `str`
             Complete path to the root Gen2 data repository.  This should be
             a data repository that includes a Gen2 registry and any raw files
             and/or reference catalogs.
         calibs : `list` of `CalibRepo`
             Specifications for Gen2 calibration repos to convert.  If `None`
             (default), curated calibrations only will be written to the default
             calibration collection for this instrument; set to ``()`` explictly
             to disable this.
         reruns : `list` of `Rerun`
             Specifications for rerun (processing output) repos to convert.  If
             `None` (default), no reruns are converted.
         visits : iterable of `int`, optional
             The integer IDs of visits to convert.  If not provided, all visits
             in the Gen2 root repository will be converted.
         pool : `multiprocessing.Pool`, optional
             If not `None`, a process pool with which to parallelize some
             operations.
         processes : `int`, optional
             The number of processes to use for conversion.
         """
         if pool is None and processes > 1:
             pool = Pool(processes)
         if calibs is None:
             calibs = [CalibRepo(path=None)]
         if visits is not None:
             subset = ConversionSubset(instrument=self.instrument.getName(), visits=frozenset(visits))
         else:
             if self.config.relatedOnly:
                 self.log.warn("config.relatedOnly is True but all visits are being ingested; "
                               "no filtering will be done.")
             subset = None
  
         # Check that at most one CalibRepo is marked as default, to fail before
         # we actually write anything.
         defaultCalibRepos = [c.path for c in calibs if c.default]
         if len(defaultCalibRepos) > 1:
             raise ValueError(f"Multiple calib repos marked as default: {defaultCalibRepos}.")
  
         # Make converters for all Gen2 repos.
         converters = []
         # Start with the root repo, which must always be given even if we are
         # not configured to convert anything from it.
         rootConverter = RootRepoConverter(task=self, root=root, subset=subset, instrument=self.instrument)
         converters.append(rootConverter)
         # Calibration repos are next.
         for spec in calibs:
             calibRoot = spec.path
             if calibRoot is not None:
                 if not os.path.isabs(calibRoot):
                     calibRoot = os.path.join(rootConverter.root, calibRoot)
                 converter = CalibRepoConverter(task=self, root=calibRoot,
                                                labels=spec.labels,
                                                instrument=self.instrument,
                                                mapper=rootConverter.mapper,
                                                subset=rootConverter.subset)
                 converters.append(converter)
             # CalibRepo entries that don't have a path are just there for
             # curated calibs and maybe to set up a collection pointer; that's
             # handled further down (after we've done everything we can that
             # doesn't involve actually writing to the output Gen3 repo).
         # And now reruns.
         rerunConverters = {}
         for spec in reruns:
             runRoot = spec.path
             if not os.path.isabs(runRoot):
                 runRoot = os.path.join(rootConverter.root, runRoot)
             spec.guessCollectionNames(self.instrument, rootConverter.root)
             converter = StandardRepoConverter(task=self, root=runRoot, run=spec.runName,
                                               instrument=self.instrument, subset=rootConverter.subset)
             converters.append(converter)
             rerunConverters[spec.runName] = converter
  
         # Register the instrument if we're configured to do so.
         if self.config.doRegisterInstrument:
             self.instrument.register(self.registry)
  
         # Run raw ingest (does nothing if we weren't configured to convert the
         # 'raw' dataset type).
         rootConverter.runRawIngest(pool=pool)
  
         # Write curated calibrations to all calibration collections where they
         # were requested (which may be implicit, by passing calibs=None).  Also
         # set up a CHAINED collection that points to the default CALIBRATION
         # collection if one is needed.
         for spec in calibs:
             if spec.curated:
                 self.instrument.writeCuratedCalibrations(self.butler3, labels=spec.labels)
             if spec.default and spec.labels:
                 # This is guaranteed to be True at most once in the loop by
                 # logic at the top of this method.
                 defaultCalibName = self.instrument.makeCalibrationCollectionName()
                 self.butler3.registry.registerCollection(defaultCalibName, CollectionType.CHAINED)
                 recommendedCalibName = self.instrument.makeCalibrationCollectionName(*spec.labels)
                 self.butler3.registry.registerCollection(recommendedCalibName, CollectionType.CALIBRATION)
                 self.butler3.registry.setCollectionChain(defaultCalibName, [recommendedCalibName])
  
         # Define visits (also does nothing if we weren't configurd to convert
         # the 'raw' dataset type).
         rootConverter.runDefineVisits(pool=pool)
  
         # Walk Gen2 repos to find datasets convert.
         for converter in converters:
             converter.prep()
  
         # Insert dimensions that are potentially shared by all Gen2
         # repositories (and are hence managed directly by the Task, rather
         # than a converter instance).
         # This also finishes setting up the (shared) converter.subsets object
         # that is used to filter data IDs for config.relatedOnly.
         self.registerUsedSkyMaps(rootConverter.subset)
         self.registerUsedSkyPix(rootConverter.subset)
  
         # Look for datasets, generally by scanning the filesystem.
         # This requires dimensions to have already been inserted so we can use
         # dimension information to identify related datasets.
         for converter in converters:
             converter.findDatasets()
  
         # Expand data IDs.
         for converter in converters:
             converter.expandDataIds()
  
         # Actually ingest datasets.
         for converter in converters:
             converter.ingest()
  
         # Perform any post-ingest processing.
         for converter in converters:
             converter.finish()
  
         # Make the umbrella collection, if desired.
         if self.config.doMakeUmbrellaCollection:
             umbrella = self.instrument.makeUmbrellaCollectionName()
             self.registry.registerCollection(umbrella, CollectionType.CHAINED)
             children = list(self.registry.getCollectionChain(umbrella))
             children.extend(rootConverter.getCollectionChain())
             children.append(self.instrument.makeCalibrationCollectionName())
             if BaseSkyMap.SKYMAP_RUN_COLLECTION_NAME not in children:
                 # Ensure the umbrella collection includes the global skymap
                 # collection, even if it's currently empty.
                 self.registry.registerRun(BaseSkyMap.SKYMAP_RUN_COLLECTION_NAME)
                 children.append(BaseSkyMap.SKYMAP_RUN_COLLECTION_NAME)
             children.extend(self.config.extraUmbrellaChildren)
             self.log.info("Defining %s from chain %s.", umbrella, children)
             self.registry.setCollectionChain(umbrella, children)
  
         # Add chained collections for reruns.
         for spec in reruns:
             if spec.chainName is not None:
                 self.butler3.registry.registerCollection(spec.chainName, type=CollectionType.CHAINED)
                 chain = [spec.runName]
                 chain.extend(rerunConverters[spec.runName].getCollectionChain())
                 for parent in spec.parents:
                     chain.append(parent)
                     parentConverter = rerunConverters.get(parent)
                     if parentConverter is not None:
                         chain.extend(parentConverter.getCollectionChain())
                 chain.extend(rootConverter.getCollectionChain())
                 if len(calibs) == 1:
                     # Exactly one calibration repo being converted, so it's
                     # safe-ish to assume that's the one the rerun used.
                     chain.append(self.instrument.makeCalibrationCollectionName(*calibs[0].labels))
                 self.log.info("Defining %s from chain %s.", spec.chainName, chain)
                 self.butler3.registry.setCollectionChain(spec.chainName, chain)

◆ timer()

def lsst.pipe.base.task.Task.timer	(	self,
		name,
		logLevel = `Log.DEBUG`
	)

inherited

Context manager to log performance data for an arbitrary block of
code.

Parameters
----------
name : `str`
    Name of code being timed; data will be logged using item name:
    ``Start`` and ``End``.
logLevel
    A `lsst.log` level constant.

Examples
--------
Creating a timer context:

.. code-block:: python

    with self.timer("someCodeToTime"):
        pass  # code to time

See also
--------
timer.logInfo

Definition at line 327 of file task.py.

     def timer(self, name, logLevel=Log.DEBUG):
         """Context manager to log performance data for an arbitrary block of
         code.
  
         Parameters
         ----------
         name : `str`
             Name of code being timed; data will be logged using item name:
             ``Start`` and ``End``.
         logLevel
             A `lsst.log` level constant.
  
         Examples
         --------
         Creating a timer context:
  
         .. code-block:: python
  
             with self.timer("someCodeToTime"):
                 pass  # code to time
  
         See also
         --------
         timer.logInfo
         """
         logInfo(obj=self, prefix=name + "Start", logLevel=logLevel)
         try:
             yield
         finally:
             logInfo(obj=self, prefix=name + "End", logLevel=logLevel)
  

◆ useSkyMap()

str lsst.obs.base.gen2to3.convertRepo.ConvertRepoTask.useSkyMap	(		self,
		BaseSkyMap	skyMap,
		str	skyMapName
	)

Indicate that a repository uses the given SkyMap.

This method is intended to be called primarily by the
`RepoConverter` instances used interally by the task.

Parameters
----------
skyMap : `lsst.skymap.BaseSkyMap`
    SkyMap instance being used, typically retrieved from a Gen2
    data repository.
skyMapName : `str`
    The name of the gen2 skymap, for error reporting.

Returns
-------
name : `str`
    The name of the skymap in Gen3 data IDs.

Raises
------
    LookupError
        Raised if the specified skymap cannot be found.

Definition at line 485 of file convertRepo.py.

     def useSkyMap(self, skyMap: BaseSkyMap, skyMapName: str) -> str:
         """Indicate that a repository uses the given SkyMap.
  
         This method is intended to be called primarily by the
         `RepoConverter` instances used interally by the task.
  
         Parameters
         ----------
         skyMap : `lsst.skymap.BaseSkyMap`
             SkyMap instance being used, typically retrieved from a Gen2
             data repository.
         skyMapName : `str`
             The name of the gen2 skymap, for error reporting.
  
         Returns
         -------
         name : `str`
             The name of the skymap in Gen3 data IDs.
  
         Raises
         ------
             LookupError
                 Raised if the specified skymap cannot be found.
         """
         sha1 = skyMap.getSha1()
         if sha1 not in self._configuredSkyMapsBySha1:
             self._populateSkyMapDicts(skyMapName, skyMap)
         try:
             struct = self._configuredSkyMapsBySha1[sha1]
         except KeyError as err:
             msg = f"SkyMap '{skyMapName}' with sha1={sha1} not included in configuration."
             raise LookupError(msg) from err
         struct.used = True
         return struct.name
  

◆ useSkyPix()

def lsst.obs.base.gen2to3.convertRepo.ConvertRepoTask.useSkyPix	(		self,
		SkyPixDimension	dimension
	)

Indicate that a repository uses the given SkyPix dimension.

This method is intended to be called primarily by the
`RepoConverter` instances used interally by the task.

Parameters
----------
dimension : `lsst.daf.butler.SkyPixDimension`
    Dimension represening a pixelization of the sky.

Definition at line 539 of file convertRepo.py.

     def useSkyPix(self, dimension: SkyPixDimension):
         """Indicate that a repository uses the given SkyPix dimension.
  
         This method is intended to be called primarily by the
         `RepoConverter` instances used interally by the task.
  
         Parameters
         ----------
         dimension : `lsst.daf.butler.SkyPixDimension`
             Dimension represening a pixelization of the sky.
         """
         self._usedSkyPix.add(dimension)
  

Member Data Documentation

◆ butler3

lsst.obs.base.gen2to3.convertRepo.ConvertRepoTask.butler3

Definition at line 433 of file convertRepo.py.

◆ config

lsst.pipe.base.task.Task.config

inherited

Definition at line 162 of file task.py.

◆ ConfigClass

lsst.obs.base.gen2to3.convertRepo.ConvertRepoTask.ConfigClass = ConvertRepoConfig

static

Definition at line 422 of file convertRepo.py.

◆ defineVisits

lsst.obs.base.gen2to3.convertRepo.ConvertRepoTask.defineVisits

Definition at line 441 of file convertRepo.py.

◆ instrument

lsst.obs.base.gen2to3.convertRepo.ConvertRepoTask.instrument

Definition at line 442 of file convertRepo.py.

◆ log

lsst.pipe.base.task.Task.log

inherited

Definition at line 161 of file task.py.

◆ metadata

lsst.pipe.base.task.Task.metadata

inherited

Definition at line 134 of file task.py.

◆ raws

lsst.obs.base.gen2to3.convertRepo.ConvertRepoTask.raws

Definition at line 440 of file convertRepo.py.

◆ registry

lsst.obs.base.gen2to3.convertRepo.ConvertRepoTask.registry

Definition at line 434 of file convertRepo.py.

◆ translatorFactory

lsst.obs.base.gen2to3.convertRepo.ConvertRepoTask.translatorFactory

Definition at line 449 of file convertRepo.py.

◆ universe

lsst.obs.base.gen2to3.convertRepo.ConvertRepoTask.universe

Definition at line 435 of file convertRepo.py.

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

/j/snowflake/release/lsstsw/stack/0.2.1/Linux64/obs_base/21.0.0-27-gbbd0d29+ae871e0f33/python/lsst/obs/base/gen2to3/convertRepo.py

Public Member Functions

Public Attributes

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __init__()

Member Function Documentation

◆ __reduce__()

◆ emptyMetadata()

◆ getAllSchemaCatalogs()

◆ getFullMetadata()

◆ getFullName()

◆ getName()

◆ getSchemaCatalogs()

◆ getTaskDict()

◆ isDatasetTypeIncluded()

◆ makeField()

◆ makeSubtask()

◆ registerUsedSkyMaps()

◆ registerUsedSkyPix()

◆ run()

◆ timer()

◆ useSkyMap()

◆ useSkyPix()

Member Data Documentation

◆ butler3

◆ config

◆ ConfigClass

◆ defineVisits

◆ instrument

◆ log

◆ metadata

◆ raws

◆ registry

◆ translatorFactory

◆ universe

◆ init()

◆ reduce()