TaskMetadata

class lsst.pipe.base.TaskMetadata(*, scalars: dict[str, typing.Union[typing.Annotated[float, Strict(strict=True)], typing.Annotated[int, Strict(strict=True)], typing.Annotated[bool, Strict(strict=True)], typing.Annotated[str, Strict(strict=True)]]] = None, arrays: dict[str, list[typing.Annotated[float, Strict(strict=True)]] | list[typing.Annotated[int, Strict(strict=True)]] | list[typing.Annotated[bool, Strict(strict=True)]] | list[typing.Annotated[str, Strict(strict=True)]]] = None, metadata: dict[str, lsst.pipe.base._task_metadata.TaskMetadata] = None)

Bases: BaseModel

Dict-like object for storing task metadata.

Metadata can be stored at two levels: single task or task plus subtasks. The later is called full metadata of a task and has a form

topLevelTaskName:subtaskName:subsubtaskName.itemName

Metadata item key of a task (itemName above) must not contain , which serves as a separator in full metadata keys and turns the value into sub-dictionary. Arbitrary hierarchies are supported.

Attributes Summary

model_computed_fields	Get the computed fields of this model instance.
model_config	Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].
model_extra	Get extra fields set during validation.
model_fields	Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].
model_fields_set	Returns the set of fields that have been explicitly set on this model instance.

Methods Summary

add(name, value)	Store a new value, adding to a list if one already exists.
construct([_fields_set])
copy(*args, **kwargs)	See pydantic.BaseModel.copy.
dict(*[, include, exclude, by_alias, ...])
from_dict(d)	Create a TaskMetadata from a dictionary.
from_metadata(ps)	Create a TaskMetadata from a PropertySet-like object.
from_orm(obj)
get(key[, default])	Retrieve the item associated with the key or a default.
getArray(key)	Retrieve an item as a list even if it is a scalar.
getScalar(key)	Retrieve a scalar item even if the item is a list.
items()	Yield the top-level keys and values.
json(*[, include, exclude, by_alias, ...])
keys()	Return the top-level keys.
model_construct([_fields_set])	Creates a new instance of the Model class with validated data.
model_copy(*args, **kwargs)	See pydantic.BaseModel.model_copy.
model_dump(*args, **kwargs)	See pydantic.BaseModel.model_dump.
model_dump_json(*[, indent, include, ...])	Usage docs: https://docs.pydantic.dev/2.5/concepts/serialization/#modelmodel_dump_json
model_json_schema(*args, **kwargs)	See pydantic.BaseModel.model_json_schema.
model_parametrized_name(params)	Compute the class name for parametrizations of generic classes.
model_post_init(_BaseModel__context)	Override this method to perform additional initialization after __init__ and model_construct.
model_rebuild(*[, force, raise_errors, ...])	Try to rebuild the pydantic-core schema for the model.
model_validate(obj, *[, strict, ...])	Validate a pydantic model instance.
model_validate_json(json_data, *[, strict, ...])	Usage docs: https://docs.pydantic.dev/2.5/concepts/json/#json-parsing
model_validate_strings(obj, *[, strict, context])	Validate the given object contains string data against the Pydantic model.
names()	Return the hierarchical keys from the metadata.
paramNames(topLevelOnly)	Return hierarchical names.
parse_file(path, *[, content_type, ...])
parse_obj(obj)
parse_raw(b, *[, content_type, encoding, ...])
schema([by_alias, ref_template])
schema_json(*[, by_alias, ref_template])
to_dict()	Convert the class to a simple dictionary.
update_forward_refs(**localns)
validate(value)

Attributes Documentation

model_computed_fields

Get the computed fields of this model instance.

Returns:

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

model_config: ClassVar[ConfigDict] = {}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

model_extra

Get extra fields set during validation.

Returns:

A dictionary of extra fields, or None if config.extra is not set to "allow".

model_fields: ClassVar[dict[str, FieldInfo]] = {'arrays': FieldInfo(annotation=dict[str, Union[list[Annotated[float, Strict(strict=True)]], list[Annotated[int, Strict(strict=True)]], list[Annotated[bool, Strict(strict=True)]], list[Annotated[str, Strict(strict=True)]]]], required=False, default_factory=dict), 'metadata': FieldInfo(annotation=dict[str, TaskMetadata], required=False, default_factory=dict), 'scalars': FieldInfo(annotation=dict[str, Union[Annotated[float, Strict(strict=True)], Annotated[int, Strict(strict=True)], Annotated[bool, Strict(strict=True)], Annotated[str, Strict(strict=True)]]], required=False, default_factory=dict)}

Metadata about the fields defined on the model, mapping of field names to [FieldInfo][pydantic.fields.FieldInfo].

This replaces Model.__fields__ from Pydantic V1.

model_fields_set

Returns the set of fields that have been explicitly set on this model instance.

Returns:

A set of strings representing the fields that have been set,

i.e. that were not filled from defaults.

Methods Documentation

add(name: str, value: Any) → None

Store a new value, adding to a list if one already exists.

Parameters:

namestr

Name of the metadata property.

valueAny

Metadata property value.

classmethod construct(_fields_set: set[str] | None = None, **values: Any) → Model

copy(*args: Any, **kwargs: Any) → Any

See pydantic.BaseModel.copy.

dict(*, include: IncEx = None, exclude: IncEx = None, by_alias: bool = False, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False) → Dict[str, Any]

classmethod from_dict(d: Mapping[str, Any]) → TaskMetadata

Create a TaskMetadata from a dictionary.

Parameters:

dMapping

Mapping to convert. Can be hierarchical. Any dictionaries in the hierarchy are converted to TaskMetadata.

Returns:

metaTaskMetadata

Newly-constructed metadata.

classmethod from_metadata(ps: PropertySetLike) → TaskMetadata

Create a TaskMetadata from a PropertySet-like object.

Parameters:

psPropertySetLike or TaskMetadata

A PropertySet-like object to be transformed to a TaskMetadata. A TaskMetadata can be copied using this class method.

Returns:

tmTaskMetadata

Newly-constructed metadata.

Notes

Items stored in single-element arrays in the supplied object will be converted to scalars in the newly-created object.

classmethod from_orm(obj: Any) → Model

get(key: str, default: Any = None) → Any

Retrieve the item associated with the key or a default.

Parameters:

keystr

The key to retrieve. Can be dot-separated hierarchical.

defaultAny

The value to return if the key does not exist.

Returns:

valueTaskMetadata, float, int, bool, str

A scalar value. If the key refers to an array, the final element is returned and not the array itself; this is consistent with __getitem__ and PropertySet.get, but not to_dict().get.

getArray(key: str) → list[Any]

Retrieve an item as a list even if it is a scalar.

Parameters:

keystr

Item to retrieve.

Returns:

valueslist of any

A list containing the value or values associated with this item.

Raises:

KeyError

Raised if the item is not found.

getScalar(key: str) → str | int | float | bool

Retrieve a scalar item even if the item is a list.

Parameters:

keystr

Item to retrieve.

Returns:

valuestr, int, float, or bool

Either the value associated with the key or, if the key corresponds to a list, the last item in the list.

Raises:

KeyError

Raised if the item is not found.

items() → Iterator[tuple[str, Any]]

Yield the top-level keys and values.

json(*, include: IncEx = None, exclude: IncEx = None, by_alias: bool = False, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False, encoder: Callable[[Any], Any] | None = PydanticUndefined, models_as_dict: bool = PydanticUndefined, **dumps_kwargs: Any) → str

keys() → tuple[str, ...]

Return the top-level keys.

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Model

Creates a new instance of the Model class with validated data.

Creates a new model setting __dict__ and __pydantic_fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed. Behaves as if Config.extra = 'allow' was set since it adds all passed values

Args:

_fields_set: The set of field names accepted for the Model instance. values: Trusted or pre-validated data dictionary.

Returns:

A new instance of the Model class with validated data.

model_copy(*args: Any, **kwargs: Any) → Any

See pydantic.BaseModel.model_copy.

model_dump(*args: Any, **kwargs: Any) → Any

See pydantic.BaseModel.model_dump.

model_dump_json(*, indent: int | None = None, include: IncEx = None, exclude: IncEx = None, by_alias: bool = False, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False, round_trip: bool = False, warnings: bool = True) → str

Usage docs: https://docs.pydantic.dev/2.5/concepts/serialization/#modelmodel_dump_json

Generates a JSON representation of the model using Pydantic’s to_json method.

Args:

indent: Indentation to use in the JSON output. If None is passed, the output will be compact. include: Field(s) to include in the JSON output. Can take either a string or set of strings. exclude: Field(s) to exclude from the JSON output. Can take either a string or set of strings. by_alias: Whether to serialize using field aliases. exclude_unset: Whether to exclude fields that have not been explicitly set. exclude_defaults: Whether to exclude fields that have the default value. exclude_none: Whether to exclude fields that have a value of None. round_trip: Whether to use serialization/deserialization between JSON and class instance. warnings: Whether to show any warnings that occurred during serialization.

Returns:

A JSON string representation of the model.

classmethod model_json_schema(*args: Any, **kwargs: Any) → Any

See pydantic.BaseModel.model_json_schema.

classmethod model_parametrized_name(params: tuple[type[Any], ...]) → str

Compute the class name for parametrizations of generic classes.

This method can be overridden to achieve a custom naming scheme for generic BaseModels.

Args:

params: Tuple of types of the class. Given a generic class

Model with 2 type variables and a concrete model Model[str, int], the value (str, int) would be passed to params.

Returns:

String representing the new class where params are passed to cls as type variables.

Raises:

TypeError: Raised when trying to generate concrete names for non-generic models.

model_post_init(_BaseModel__context: Any) → None

Override this method to perform additional initialization after __init__ and model_construct. This is useful if you want to do some validation that requires the entire model to be initialized.

classmethod model_rebuild(*, force: bool = False, raise_errors: bool = True, _parent_namespace_depth: int = 2, _types_namespace: dict[str, Any] | None = None) → bool | None

Try to rebuild the pydantic-core schema for the model.

This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.

Args:

force: Whether to force the rebuilding of the model schema, defaults to False. raise_errors: Whether to raise errors, defaults to True. _parent_namespace_depth: The depth level of the parent namespace, defaults to 2. _types_namespace: The types namespace, defaults to None.

Returns:

Returns None if the schema is already “complete” and rebuilding was not required. If rebuilding _was_ required, returns True if rebuilding was successful, otherwise False.

classmethod model_validate(obj: Any, *, strict: bool | None = None, from_attributes: bool | None = None, context: dict[str, Any] | None = None) → Model

Validate a pydantic model instance.

Args:

obj: The object to validate. strict: Whether to raise an exception on invalid fields. from_attributes: Whether to extract data from object attributes. context: Additional context to pass to the validator.

Raises:

ValidationError: If the object could not be validated.

Returns:

The validated model instance.

classmethod model_validate_json(json_data: str | bytes | bytearray, *, strict: bool | None = None, context: dict[str, Any] | None = None) → Model

Usage docs: https://docs.pydantic.dev/2.5/concepts/json/#json-parsing

Validate the given JSON data against the Pydantic model.

Args:

json_data: The JSON data to validate. strict: Whether to enforce types strictly. context: Extra variables to pass to the validator.

Returns:

The validated Pydantic model.

Raises:

ValueError: If json_data is not a JSON string.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: dict[str, Any] | None = None) → Model

Validate the given object contains string data against the Pydantic model.

Args:

obj: The object contains string data to validate. strict: Whether to enforce types strictly. context: Extra variables to pass to the validator.

Returns:

The validated Pydantic model.

names() → set[str]

Return the hierarchical keys from the metadata.

Returns:

namescollections.abc.Set

A set of all keys, including those from the hierarchy and the top-level hierarchy.

paramNames(topLevelOnly: bool) → set[str]

Return hierarchical names.

Parameters:

topLevelOnlybool

Control whether only top-level items are returned or items from the hierarchy.

Returns:

paramNamesset of str

If topLevelOnly is True, returns any keys that are not part of a hierarchy. If False also returns fully-qualified names from the hierarchy. Keys associated with the top of a hierarchy are never returned.

classmethod parse_file(path: str | Path, *, content_type: str | None = None, encoding: str = 'utf8', proto: DeprecatedParseProtocol | None = None, allow_pickle: bool = False) → Model

classmethod parse_obj(obj: Any) → Model

classmethod parse_raw(b: str | bytes, *, content_type: str | None = None, encoding: str = 'utf8', proto: DeprecatedParseProtocol | None = None, allow_pickle: bool = False) → Model

classmethod schema(by_alias: bool = True, ref_template: str = '#/$defs/{model}') → Dict[str, Any]

classmethod schema_json(*, by_alias: bool = True, ref_template: str = '#/$defs/{model}', **dumps_kwargs: Any) → str

to_dict() → dict[str, Any]

Convert the class to a simple dictionary.

Returns:

ddict

Simple dictionary that can contain scalar values, array values or other dictionary values.

Notes

Unlike dict(), this method hides the model layout and combines scalars, arrays, and other metadata in the same dictionary. Can be used when a simple dictionary is needed. Use TaskMetadata.from_dict() to convert it back.

classmethod update_forward_refs(**localns: Any) → None

classmethod validate(value: Any) → Model