+Get AsyncResult instance for the specified task.
+
Arguments:
+ task_id (str): Task id to get result for.
+
add_to_chord
+
defadd_to_chord(
+ self,
+ sig,
+ lazy=False
+)
+
+Add signature to the chord the current task is a member of.
+
.. versionadded:: 4.0
+
Currently only supported by the Redis result backend.
+
Arguments:
+ sig (Signature): Signature to extend chord with.
+ lazy (bool): If enabled the new task won't actually be called,
+ and sig.delay() must be called manually.
Arguments:
+ status (str): Current task state.
+ retval (Any): Task return value/exception.
+ task_id (str): Unique id of the task.
+ args (Tuple): Original arguments for the task.
+ kwargs (Dict): Original keyword arguments for the task.
+ einfo (~billiard.einfo.ExceptionInfo): Exception information.
+
Returns:
+ None: The return value of this handler is ignored.
+Execute this task locally, by blocking until the task returns.
+
Arguments:
+ args (Tuple): positional arguments passed on to the task.
+ kwargs (Dict): keyword arguments passed on to the task.
+ throw (bool): Re-raise task exceptions.
+ Defaults to the :setting:task_eager_propagates setting.
+Apply tasks asynchronously by sending a message.
+
Arguments:
+ args (Tuple): The positional arguments to pass on to the task.
+
kwargs (Dict): The keyword arguments to pass on to the task.
+
+countdown (float): Number of seconds into the future that the
+ task should execute. Defaults to immediate execution.
+
+eta (~datetime.datetime): Absolute time and date of when the task
+ should be executed. May not be specified if `countdown`
+ is also supplied.
+
+expires (float, ~datetime.datetime): Datetime or
+ seconds in the future for the task should expire.
+ The task won't be executed after the expiration time.
+
+shadow (str): Override task name used in logs/monitoring.
+ Default is retrieved from :meth:`shadow_name`.
+
+connection (kombu.Connection): Re-use existing broker connection
+ instead of acquiring one from the connection pool.
+
+retry (bool): If enabled sending of the task message will be
+ retried in the event of connection loss or failure.
+ Default is taken from the :setting:`task_publish_retry`
+ setting. Note that you need to handle the
+ producer/connection manually for this to work.
+
+retry_policy (Mapping): Override the retry policy used.
+ See the :setting:`task_publish_retry_policy` setting.
+
+time_limit (int): If set, overrides the default time limit.
+
+soft_time_limit (int): If set, overrides the default soft
+ time limit.
+
+queue (str, kombu.Queue): The queue to route the task to.
+ This must be a key present in :setting:`task_queues`, or
+ :setting:`task_create_missing_queues` must be
+ enabled. See :ref:`guide-routing` for more
+ information.
+
+exchange (str, kombu.Exchange): Named custom exchange to send the
+ task to. Usually not used in combination with the ``queue``
+ argument.
+
+routing_key (str): Custom routing key used to route the task to a
+ worker server. If in combination with a ``queue`` argument
+ only used to specify custom routing keys to topic exchanges.
+
+priority (int): The task priority, a number between 0 and 9.
+ Defaults to the :attr:`priority` attribute.
+
+serializer (str): Serialization method to use.
+ Can be `pickle`, `json`, `yaml`, `msgpack` or any custom
+ serialization method that's been registered
+ with :mod:`kombu.serialization.registry`.
+ Defaults to the :attr:`serializer` attribute.
+
+compression (str): Optional compression method
+ to use. Can be one of ``zlib``, ``bzip2``,
+ or any custom compression methods registered with
+ :func:`kombu.compression.register`.
+ Defaults to the :setting:`task_compression` setting.
+
+link (Signature): A single, or a list of tasks signatures
+ to apply if the task returns successfully.
+
+link_error (Signature): A single, or a list of task signatures
+ to apply if an error occurs while executing the task.
+
+producer (kombu.Producer): custom producer to use when publishing
+ the task.
+
+add_to_parent (bool): If set to True (default) and the task
+ is applied while executing another task, then the result
+ will be appended to the parent tasks ``request.children``
+ attribute. Trailing can also be disabled by default using the
+ :attr:`trail` attribute
+
+ignore_result (bool): If set to `False` (default) the result
+ of a task will be stored in the backend. If set to `True`
+ the result will not be stored. This can also be set
+ using the :attr:`ignore_result` in the `app.task` decorator.
+
+publisher (kombu.Producer): Deprecated alias to ``producer``.
+
+headers (Dict): Message headers to be included in the message.
+
+
Returns:
+ celery.result.AsyncResult: Promise of future evaluation.
+
Raises:
+ TypeError: If not enough arguments are passed, or too many
+ arguments are passed. Note that signature checks may
+ be disabled by specifying @task(typing=False).
+ kombu.exceptions.OperationalError: If a connection to the
+ transport cannot be made, or if the connection is lost.
+
Note:
+ Also supports all keyword arguments supported by
+ :meth:kombu.Producer.publish.
Arguments:
+ task_id (str): Unique id of the task to execute.
+ args (Tuple): Original arguments for the task to execute.
+ kwargs (Dict): Original keyword arguments for the task to execute.
+
Returns:
+ None: The return value of this handler is ignored.
+
chunks
+
defchunks(
+ self,
+ it,
+ n
+)
+
+Create a :class:~celery.canvas.chunks task for this task.
+
delay
+
defdelay(
+ self,
+ *args,
+ **kwargs
+)
+
+Star argument version of :meth:apply_async.
+
Does not support the extra options enabled by :meth:apply_async.
+
Arguments:
+ args (Any): Positional arguments passed on to the task.
+ *kwargs (Any): Keyword arguments passed on to the task.
+Returns:
+ celery.result.AsyncResult: Future promise.
+
map
+
defmap(
+ self,
+ it
+)
+
+Create a :class:~celery.canvas.xmap task from it.
+
This is run by the worker when the task is to be retried.
+
Arguments:
+ exc (Exception): The exception sent to :meth:retry.
+ task_id (str): Unique id of the retried task.
+ args (Tuple): Original arguments for the retried task.
+ kwargs (Dict): Original keyword arguments for the retried task.
+ einfo (~billiard.einfo.ExceptionInfo): Exception information.
+
Returns:
+ None: The return value of this handler is ignored.
Run by the worker if the task executes successfully.
+
Arguments:
+ retval (Any): The return value of the task.
+ task_id (str): Unique id of the executed task.
+ args (Tuple): Original arguments for the executed task.
+ kwargs (Dict): Original keyword arguments for the executed task.
+
Returns:
+ None: The return value of this handler is ignored.
+
pop_request
+
defpop_request(
+ self
+)
+
+
push_request
+
defpush_request(
+ self,
+ *args,
+ **kwargs
+)
+
+
replace
+
defreplace(
+ self,
+ sig
+)
+
+Replace this task, with a new task inheriting the task id.
+
Execution of the host task ends immediately and no subsequent statements
+will be run.
+
.. versionadded:: 4.0
+
Arguments:
+ sig (Signature): signature to replace with.
+ visitor (StampingVisitor): Visitor API object.
+
Raises:
+ ~@Ignore: This is always raised when called in asynchronous context.
+ It is best to always use return self.replace(...) to convey
+ to the reader that the task won't continue after being replaced.
Note:
+ Although the task will never return above as retry raises an
+ exception to notify the worker, we use raise in front of the
+ retry to convey that the rest of the block won't be executed.
+
Arguments:
+ args (Tuple): Positional arguments to retry with.
+ kwargs (Dict): Keyword arguments to retry with.
+ exc (Exception): Custom exception to report when the max retry
+ limit has been exceeded (default:
+ :exc:~@MaxRetriesExceededError).
+
If this argument is set and retry is called while
+ an exception was raised (``sys.exc_info()`` is set)
+ it will attempt to re-raise the current exception.
+
+ If no exception was raised it will raise the ``exc``
+ argument provided.
+countdown (float): Time in seconds to delay the retry for.
+eta (~datetime.datetime): Explicit time and date to run the
+ retry at.
+max_retries (int): If set, overrides the default retry limit for
+ this execution. Changes to this parameter don't propagate to
+ subsequent task retry attempts. A value of :const:`None`,
+ means "use the default", so if you want infinite retries you'd
+ have to set the :attr:`max_retries` attribute of the task to
+ :const:`None` first.
+time_limit (int): If set, overrides the default time limit.
+soft_time_limit (int): If set, overrides the default soft
+ time limit.
+throw (bool): If this is :const:`False`, don't raise the
+ :exc:`~@Retry` exception, that tells the worker to mark
+ the task as being retried. Note that this means the task
+ will be marked as failed if the task raises an exception,
+ or successful if it returns after the retry call.
+**options (Any): Extra options to pass on to :meth:`apply_async`.
+
+
Raises:
+
celery.exceptions.Retry:
+ To tell the worker that the task has been re-sent for retry.
+ This always happens, unless the `throw` keyword argument
+ has been explicitly set to :const:`False`, and is considered
+ normal operation.
+
This can be used to add custom event types in :pypi:Flower
+and other monitors.
+
Arguments:
+ type_ (str): Type of event, e.g. "task-failed".
+
Keyword Arguments:
+ retry (bool): Retry sending the message
+ if the connection is lost. Default is taken from the
+ :setting:task_publish_retry setting.
+ retry_policy (Mapping): Retry settings. Default is taken
+ from the :setting:task_publish_retry_policy setting.
+ **fields (Any): Map containing information about the event.
+ Must be JSON serializable.
Arguments:
+ task_id (str): Id of the task to update.
+ Defaults to the id of the current task.
+ state (str): New state.
+ meta (Dict): State meta-data.
Attributes:
+ class_vars: The names of the class variables defined on the model.
+ private_attributes: Metadata about the private attributes of the model.
+ signature: The synthesized __init__ [Signature][inspect.Signature] of the model.
+
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The core schema of the model.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+ This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+ __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
+__pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
+__pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.
+
+__pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
+__pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.
+
+__pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
+ is set to `'allow'`.
+__pydantic_fields_set__: The names of fields explicitly set during instantiation.
+__pydantic_private__: Values of private attributes set on the model instance.
+
+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.
+
!!! note
+ model_construct() generally respects the model_config.extra setting on the provided model.
+ That is, if model_config.extra == 'allow', then all extra passed values are added to the model instance's __dict__
+ and __pydantic_extra__ fields. If model_config.extra == 'ignore' (the default), then all extra passed values are ignored.
+ Because no validation is performed with a call to model_construct(), having model_config.extra == 'forbid' does not result in
+ an error if extra values are passed, but they will be ignored.
+
Args:
+ _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
+ this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute.
+ Otherwise, the field names from the values argument will be used.
+ values: Trusted or pre-validated data dictionary.
+
Returns:
+ A new instance of the Model class with validated data.
Args:
+ by_alias: Whether to use attribute aliases or not.
+ ref_template: The reference template.
+ schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+ GenerateJsonSchema with your desired modifications
+ mode: The mode in which to generate the schema.
+
Returns:
+ The JSON schema for the given model class.
+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.
+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.
Args:
+ obj: The object to validate.
+ strict: Whether to enforce types strictly.
+ 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.
+Validate the given object with string data against the Pydantic model.
+
Args:
+ obj: The object containing string data to validate.
+ strict: Whether to enforce types strictly.
+ context: Extra variables to pass to the validator.
Args:
+ include: Optional set or mapping specifying which fields to include in the copied model.
+ exclude: Optional set or mapping specifying which fields to exclude in the copied model.
+ update: Optional dictionary of field-value pairs to override field values in the copied model.
+ deep: If True, the values of fields that are Pydantic models will be deep-copied.
+
+Returns:
+ A copy of the model with included, excluded and updated fields as specified.
+
+
+#### dict
+
+```python3
+def dict(
+ self,
+ *,
+ include: 'IncEx | None' = None,
+ exclude: 'IncEx | None' = None,
+ by_alias: 'bool' = False,
+ exclude_unset: 'bool' = False,
+ exclude_defaults: 'bool' = False,
+ exclude_none: 'bool' = False
+) -> 'Dict[str, Any]'
+
Args:
+ update: Values to change/add in the new model. Note: the data is not validated
+ before creating the new model. You should trust this data.
+ deep: Set to True to make a deep copy of the model.
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
Args:
+ mode: The mode in which to_python should run.
+ If mode is 'json', the output will only contain JSON serializable types.
+ If mode is 'python', the output may contain non-JSON-serializable Python objects.
+ include: A set of fields to include in the output.
+ exclude: A set of fields to exclude from the output.
+ context: Additional context to pass to the serializer.
+ by_alias: Whether to use the field's alias in the dictionary key if defined.
+ exclude_unset: Whether to exclude fields that have not been explicitly set.
+ exclude_defaults: Whether to exclude fields that are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A dictionary representation of the model.
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.
+ exclude: Field(s) to exclude from the JSON output.
+ context: Additional context to pass to the serializer.
+ 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 are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A JSON string representation of the model.
+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.
+
UserRole
+
classUserRole(
+ *args,
+ **kwds
+)
+
+
Create a collection of name/value pairs.
+
Example enumeration:
+
+
+
+
class Color(Enum):
+... RED = 1
+... BLUE = 2
+... GREEN = 3
+
+
+
+
Access them by:
+
+
attribute access::
+
+
+
+
+
Color.RED
+
+
+
+
+
+
value lookup:
+
+
+
+
+
Color(1)
+
+
+
+
+
+
name lookup:
+
+
+
+
+
Color['RED']
+
+
+
+
+
Enumerations can be iterated over, and know how many members they have:
+
+
+
+
len(Color)
+3
+
list(Color)
+[, , ]
+
+
+
+
Methods can be added to enumerations, and members can have their own
+attributes -- see the documentation for details.
+Generate Login URL for authentication using OAuth2 Application registered with OpenStreetMap.
+Click on the download url returned to get access_token.
+
Parameters: None
+
Returns:
+- login_url (dict) - URL to authorize user to the application via. Openstreetmap
+ OAuth2 with client_id, redirect_uri, and permission scope as query_string parameters
+Updates user information based on the given osm_id.
+User Role :
+ ADMIN = 1
+ STAFF = 2
+ GUEST = 3
+Args:
+- osm_id (int): The OSM ID of the user to update.
+- update_data (User): The data to update for the user.
+
Returns:
+- Dict[str, Any]: A dictionary containing the updated user information.
+
Raises:
+- HTTPException: If the user with the given osm_id is not found.
Attributes:
+ class_vars: The names of the class variables defined on the model.
+ private_attributes: Metadata about the private attributes of the model.
+ signature: The synthesized __init__ [Signature][inspect.Signature] of the model.
+
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The core schema of the model.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+ This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+ __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
+__pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
+__pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.
+
+__pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
+__pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.
+
+__pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
+ is set to `'allow'`.
+__pydantic_fields_set__: The names of fields explicitly set during instantiation.
+__pydantic_private__: Values of private attributes set on the model instance.
+
+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.
+
!!! note
+ model_construct() generally respects the model_config.extra setting on the provided model.
+ That is, if model_config.extra == 'allow', then all extra passed values are added to the model instance's __dict__
+ and __pydantic_extra__ fields. If model_config.extra == 'ignore' (the default), then all extra passed values are ignored.
+ Because no validation is performed with a call to model_construct(), having model_config.extra == 'forbid' does not result in
+ an error if extra values are passed, but they will be ignored.
+
Args:
+ _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
+ this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute.
+ Otherwise, the field names from the values argument will be used.
+ values: Trusted or pre-validated data dictionary.
+
Returns:
+ A new instance of the Model class with validated data.
Args:
+ by_alias: Whether to use attribute aliases or not.
+ ref_template: The reference template.
+ schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+ GenerateJsonSchema with your desired modifications
+ mode: The mode in which to generate the schema.
+
Returns:
+ The JSON schema for the given model class.
+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.
+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.
Args:
+ obj: The object to validate.
+ strict: Whether to enforce types strictly.
+ 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.
+Validate the given object with string data against the Pydantic model.
+
Args:
+ obj: The object containing string data to validate.
+ strict: Whether to enforce types strictly.
+ context: Extra variables to pass to the validator.
Args:
+ include: Optional set or mapping specifying which fields to include in the copied model.
+ exclude: Optional set or mapping specifying which fields to exclude in the copied model.
+ update: Optional dictionary of field-value pairs to override field values in the copied model.
+ deep: If True, the values of fields that are Pydantic models will be deep-copied.
+
+Returns:
+ A copy of the model with included, excluded and updated fields as specified.
+
+
+#### dict
+
+```python3
+def dict(
+ self,
+ *,
+ include: 'IncEx | None' = None,
+ exclude: 'IncEx | None' = None,
+ by_alias: 'bool' = False,
+ exclude_unset: 'bool' = False,
+ exclude_defaults: 'bool' = False,
+ exclude_none: 'bool' = False
+) -> 'Dict[str, Any]'
+
Args:
+ update: Values to change/add in the new model. Note: the data is not validated
+ before creating the new model. You should trust this data.
+ deep: Set to True to make a deep copy of the model.
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
Args:
+ mode: The mode in which to_python should run.
+ If mode is 'json', the output will only contain JSON serializable types.
+ If mode is 'python', the output may contain non-JSON-serializable Python objects.
+ include: A set of fields to include in the output.
+ exclude: A set of fields to exclude from the output.
+ context: Additional context to pass to the serializer.
+ by_alias: Whether to use the field's alias in the dictionary key if defined.
+ exclude_unset: Whether to exclude fields that have not been explicitly set.
+ exclude_defaults: Whether to exclude fields that are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A dictionary representation of the model.
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.
+ exclude: Field(s) to exclude from the JSON output.
+ context: Additional context to pass to the serializer.
+ 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 are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A JSON string representation of the model.
+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.
+
+
+
+
+
+
+
+
Args:
+ request (Request): The request object.
+ cron_id (int): ID of the cron entry to update.
+ cron_data (Dict): Data for partially updating the cron entry.
+ user_data (AuthUser): User authentication data.
+
Returns:
+ Dict: Result of the cron update process.
+
Raises:
+ HTTPException: If the cron entry is not found.
Args:
+ request (Request): The request object.
+ dataset_title (str): The title of the dataset to search for.
+ skip (int): Number of entries to skip.
+ limit (int): Maximum number of entries to retrieve.
+
Returns:
+ List[dict]: List of Cron entries matching the dataset title.
Args:
+ request (Request): The request object.
+ cron_id (int): ID of the cron entry to update.
+ cron_data (dict): Data for updating the cron entry.
+ user_data (AuthUser): User authentication data.
+
Returns:
+ dict: Result of the cron update process.
+
Raises:
+ HTTPException: If the cron entry is not found.
+Generates the current raw OpenStreetMap data available on database based on the input geometry, query and spatial features.
+
Steps to Run Snapshot :
+
+
Post the your request here and your request will be on queue, endpoint will return as following :
+ {
+ "task_id": "your task_id",
+ "track_link": "/tasks/task_id/"
+ }
+
Now navigate to /tasks/ with your task id to track progress and result
Args:
+ request (Request): An HTTP request object.
+ params (StatsRequestParams): Parameters for the statistics request, including the polygon geometry.
+
Returns:
+ dict: A dictionary containing statistics for the specified polygon.
+Tracks the request from the task id provided by Raw Data API for the request
+
Args:
+
task_id ([type]): [Unique id provided on response from /snapshot/]
+
+
Returns:
+
id: Id of the task
+status : Possible values includes:
+
+ PENDING
+
+ The task is waiting for execution.
+
+ STARTED
+
+ The task has been started.
+
+ RETRY
+
+ The task is to be retried, possibly because of failure.
+
+ FAILURE
+
+ The task raised an exception, or has exceeded the retry limit. The result attribute then contains the exception raised by the task.
+
+ SUCCESS
+
+ The task executed successfully. The result attribute then contains the tasks return value.
+
+result : Result of task
+
+
Successful task will have additional nested json inside
Gives status about how recent the osm data is , it will give the last time
+that database was updated completely
+
+
+ Response 200OK
+
+
+
+
+
+
{
+"lastUpdated":"2022-06-27 19:59:24+05:45"
+}
+
+⚠️This example has been generated automatically from the schema and it is not accurate. Refer to the schema for more information.
+
+Schema of the response body
+
Generates the current raw OpenStreetMap data available on database based on
+the input geometry, query and spatial features.
+
Steps to Run Snapshot :
+
+
Post the your request here and your request will be on queue, endpoint
+will return as following :
+ {
+ "task_id": "your task_id",
+ "track_link": "/tasks/task_id/"
+ }
+
Now navigate to /tasks/ with your task id to track progress and result
+⚠️This example has been generated automatically from the schema and it is not accurate. Refer to the schema for more information.
+
+Schema of the response body
+
+⚠️This example has been generated automatically from the schema and it is not accurate. Refer to the schema for more information.
+
+Schema of the response body
+
+⚠️This example has been generated automatically from the schema and it is not accurate. Refer to the schema for more information.
+
+Schema of the response body
+
+⚠️This example has been generated automatically from the schema and it is not accurate. Refer to the schema for more information.
+
+Schema of the response body
+
+⚠️This example has been generated automatically from the schema and it is not accurate. Refer to the schema for more information.
+
+Schema of the response body
+
Args:
+ dataset_title (str): The title of the dataset to search for.
+ skip (int): Number of entries to skip.
+ limit (int): Maximum number of entries to retrieve.
+
Returns:
+ List[dict]: List of Cron entries matching the dataset title.
+Executes a query and exports the result to file(s).
+
Parameters:
+- query (str): SQL query to execute.
+- category_name (str): Name of the category.
+- feature_type (str): Feature type.
+- export_formats (List[ExportTypeInfo]): List of export formats.
+
Returns:
+- List of resource dictionaries containing export information.
Parameters:
+- query (str): The SQL query to execute.
+- attach_pgsql (bool): Flag to indicate whether to attach a PostgreSQL database.
+- load_spatial (bool): Flag to indicate whether to load the spatial extension.
+Translates building stats to a human-readable statement.
+
Args:
+ osm_building_count (int): Count of buildings from OpenStreetMap.
+ ai_building_count (int): Count of buildings from AI estimates.
+ avg_timestamp (timestamp): Average timestamp of data.
+ last_edit_timestamp(timestamp): Last edit timestamp of an area
+ osm_building_count_6_months (int): Count of buildings updated in the last 6 months.
+
Returns:
+ str: Human-readable building statement.
+Translates road stats to a human-readable statement.
+
Args:
+ osm_highway_length (float): Length of roads from OpenStreetMap.
+ ai_highway_length (float): Length of roads from AI estimates.
+ avg_timestamp (str): Average timestamp of data.
+ osm_highway_length_6_months (float): Length of roads updated in the last 6 months.
+
Returns:
+ str: Human-readable road statement.
+
Methods
+
get_osm_analytics_meta_stats
+
defget_osm_analytics_meta_stats(
+ self
+)
+
+Gets the raw stats translated into a JSON body using the OSM Analytics API.
+
Returns:
+ dict: Raw statistics translated into JSON.
+
get_summary_stats
+
defget_summary_stats(
+ self
+)
+
+Generates summary statistics for buildings and roads.
+
Returns:
+ dict: Summary statistics including building and road statements.
Class responsible for the Rawdata Extraction from available sources ,
+ Currently Works for Underpass source Current Snapshot
+Returns:
+Geojson Zip file
+Supports:
+-Any Key value pair of osm tags
+-A Polygon
+-Osm element type (Optional)
+
Static methods
+
close_con
+
defclose_con(
+ con
+)
+
+Closes connection if exists
+
get_grid_id
+
defget_grid_id(
+ geom,
+ cur
+)
+
+Gets the intersecting related grid id for the geometry that is passed
+
Args:
+ geom (type): description
+ cur (type): description
+
Returns:
+ type: grid id , geometry dump and the area of geometry
+Function written to support ogr type extractions as well , In this way we will be able to support all file formats supported by Ogr , Currently it is slow when dataset gets bigger as compared to our own conversion method but rich in feature and data types even though it is slow
+
+Responsible for Extracting rawdata current snapshot, Initially it creates a geojson file , Generates query , run it with 1000 chunk size and writes it directly to the geojson file and closes the file after dump
+Args:
+ exportname: takes filename as argument to create geojson file passed from routers
+
Returns:
+ geom_area: area of polygon supplied
+ working_dir: dir where results are saved
+
get_countries_list
+
defget_countries_list(
+ self,
+ q
+)
+
+Gets Countries list from the database
+
Args:
+ q (type): list filter query string
+
Returns:
+ featurecollection: geojson of country
+
get_country
+
defget_country(
+ self,
+ q
+)
+
+Gets specific country from the database
+
Args:
+ cid (type): country cid
+
Returns:
+ featurecollection: geojson of country
+
get_osm_feature
+
defget_osm_feature(
+ self,
+ osm_id
+)
+
+Returns geometry of osm_id in geojson
+
Args:
+ osm_id (type): osm_id of feature
+
Returns:
+ featurecollection: Geojson
+
S3FileTransfer
+
classS3FileTransfer(
+
+)
+
+
Responsible for the file transfer to s3 from API maachine
+Used for transferring file to s3 after reading path from the user , It will wait for the upload to complete
+Parameters :file_path --- your local file path to upload ,
+ file_prefix -- prefix for the filename which is stored
+sample function call :
+ S3FileTransfer.transfer(file_path="exports",file_prefix="upload_test")
+
Users
+
classUsers(
+
+)
+
+
Users class provides CRUD operations for interacting with the 'users' table in the database.
+
Methods:
+- create_user(osm_id: int, role: int) -> Dict[str, Any]: Inserts a new user into the database.
+- read_user(osm_id: int) -> Dict[str, Any]: Retrieves user information based on the given osm_id.
+- update_user(osm_id: int, update_data: UserUpdate) -> Dict[str, Any]: Updates user information based on the given osm_id.
+- delete_user(osm_id: int) -> Dict[str, Any]: Deletes a user based on the given osm_id.
+- read_users(skip: int = 0, limit: int = 10) -> List[Dict[str, Any]]: Retrieves a list of users with optional pagination.
+
Usage:
+users = Users()
+
Methods
+
create_user
+
defcreate_user(
+ self,
+ osm_id,
+ role
+)
+
+Inserts a new user into the 'users' table and returns the created user's osm_id.
+
Args:
+- osm_id (int): The OSM ID of the new user.
+- role (int): The role of the new user.
+
Returns:
+- Dict[str, Any]: A dictionary containing the osm_id of the newly created user.
+
Raises:
+- HTTPException: If the user creation fails.
+
delete_user
+
defdelete_user(
+ self,
+ osm_id
+)
+
+Deletes a user based on the given osm_id.
+
Args:
+- osm_id (int): The OSM ID of the user to delete.
+
Returns:
+- Dict[str, Any]: A dictionary containing the deleted user information.
+
Raises:
+- HTTPException: If the user with the given osm_id is not found.
+
read_user
+
defread_user(
+ self,
+ osm_id
+)
+
+Retrieves user information based on the given osm_id.
+
Args:
+- osm_id (int): The OSM ID of the user to retrieve.
+
Returns:
+- Dict[str, Any]: A dictionary containing user information if the user is found.
+ If the user is not found, returns a default user with 'role' set to 3.
+
Raises:
+- HTTPException: If there's an issue with the database query.
+
read_users
+
defread_users(
+ self,
+ skip=0,
+ limit=10
+)
+
+Retrieves a list of users with optional pagination.
+
Args:
+- skip (int): The number of users to skip (for pagination).
+- limit (int): The maximum number of users to retrieve (for pagination).
+
Returns:
+- List[Dict[str, Any]]: A list of dictionaries containing user information.
+Generate a Extraction query to extract features based on given parameters.
+
Args:
+- base_table_name (str): Base table name.
+- select (List[str]): List of selected fields.
+- feature_type (str): Type of feature (points, lines, polygons).
+- where (str): SQL-like condition to filter features.
+
Returns:
+str: Extraction query to extract features.
+used for specifically focused on export tool , this will generate separate queries for line point and polygon can be used on other datatype support - Rawdata extraction
+
+Generate a DuckDB query to create a table from a PostgreSQL query.
+
Args:
+- base_table_name (str): Base table name.
+- table (str): PostgreSQL table name.
+- cid (int, optional): Country ID for filtering. Defaults to None.
+- geometry (Polygon, optional): Custom polygon geometry. Defaults to None.
+- single_category_where (str, optional): Where clause for single category to fetch it from postgres
+- enable_users_detail (bool, optional): Enable user details. Defaults to False.
Attributes:
+ class_vars: The names of the class variables defined on the model.
+ private_attributes: Metadata about the private attributes of the model.
+ signature: The synthesized __init__ [Signature][inspect.Signature] of the model.
+
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The core schema of the model.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+ This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+ __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
+__pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
+__pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.
+
+__pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
+__pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.
+
+__pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
+ is set to `'allow'`.
+__pydantic_fields_set__: The names of fields explicitly set during instantiation.
+__pydantic_private__: Values of private attributes set on the model instance.
+
+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.
+
!!! note
+ model_construct() generally respects the model_config.extra setting on the provided model.
+ That is, if model_config.extra == 'allow', then all extra passed values are added to the model instance's __dict__
+ and __pydantic_extra__ fields. If model_config.extra == 'ignore' (the default), then all extra passed values are ignored.
+ Because no validation is performed with a call to model_construct(), having model_config.extra == 'forbid' does not result in
+ an error if extra values are passed, but they will be ignored.
+
Args:
+ _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
+ this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute.
+ Otherwise, the field names from the values argument will be used.
+ values: Trusted or pre-validated data dictionary.
+
Returns:
+ A new instance of the Model class with validated data.
Args:
+ by_alias: Whether to use attribute aliases or not.
+ ref_template: The reference template.
+ schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+ GenerateJsonSchema with your desired modifications
+ mode: The mode in which to generate the schema.
+
Returns:
+ The JSON schema for the given model class.
+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.
+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.
Args:
+ obj: The object to validate.
+ strict: Whether to enforce types strictly.
+ 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.
+Validate the given object with string data against the Pydantic model.
+
Args:
+ obj: The object containing string data to validate.
+ strict: Whether to enforce types strictly.
+ context: Extra variables to pass to the validator.
Args:
+ include: Optional set or mapping specifying which fields to include in the copied model.
+ exclude: Optional set or mapping specifying which fields to exclude in the copied model.
+ update: Optional dictionary of field-value pairs to override field values in the copied model.
+ deep: If True, the values of fields that are Pydantic models will be deep-copied.
+
+Returns:
+ A copy of the model with included, excluded and updated fields as specified.
+
+
+#### dict
+
+```python3
+def dict(
+ self,
+ *,
+ include: 'IncEx | None' = None,
+ exclude: 'IncEx | None' = None,
+ by_alias: 'bool' = False,
+ exclude_unset: 'bool' = False,
+ exclude_defaults: 'bool' = False,
+ exclude_none: 'bool' = False
+) -> 'Dict[str, Any]'
+
Args:
+ update: Values to change/add in the new model. Note: the data is not validated
+ before creating the new model. You should trust this data.
+ deep: Set to True to make a deep copy of the model.
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
Args:
+ mode: The mode in which to_python should run.
+ If mode is 'json', the output will only contain JSON serializable types.
+ If mode is 'python', the output may contain non-JSON-serializable Python objects.
+ include: A set of fields to include in the output.
+ exclude: A set of fields to exclude from the output.
+ context: Additional context to pass to the serializer.
+ by_alias: Whether to use the field's alias in the dictionary key if defined.
+ exclude_unset: Whether to exclude fields that have not been explicitly set.
+ exclude_defaults: Whether to exclude fields that are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A dictionary representation of the model.
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.
+ exclude: Field(s) to exclude from the JSON output.
+ context: Additional context to pass to the serializer.
+ 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 are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A JSON string representation of the model.
+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.
+
Attributes:
+ class_vars: The names of the class variables defined on the model.
+ private_attributes: Metadata about the private attributes of the model.
+ signature: The synthesized __init__ [Signature][inspect.Signature] of the model.
+
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The core schema of the model.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+ This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+ __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
+__pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
+__pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.
+
+__pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
+__pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.
+
+__pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
+ is set to `'allow'`.
+__pydantic_fields_set__: The names of fields explicitly set during instantiation.
+__pydantic_private__: Values of private attributes set on the model instance.
+
+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.
+
!!! note
+ model_construct() generally respects the model_config.extra setting on the provided model.
+ That is, if model_config.extra == 'allow', then all extra passed values are added to the model instance's __dict__
+ and __pydantic_extra__ fields. If model_config.extra == 'ignore' (the default), then all extra passed values are ignored.
+ Because no validation is performed with a call to model_construct(), having model_config.extra == 'forbid' does not result in
+ an error if extra values are passed, but they will be ignored.
+
Args:
+ _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
+ this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute.
+ Otherwise, the field names from the values argument will be used.
+ values: Trusted or pre-validated data dictionary.
+
Returns:
+ A new instance of the Model class with validated data.
Args:
+ by_alias: Whether to use attribute aliases or not.
+ ref_template: The reference template.
+ schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+ GenerateJsonSchema with your desired modifications
+ mode: The mode in which to generate the schema.
+
Returns:
+ The JSON schema for the given model class.
+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.
+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.
Args:
+ obj: The object to validate.
+ strict: Whether to enforce types strictly.
+ 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.
+Validate the given object with string data against the Pydantic model.
+
Args:
+ obj: The object containing string data to validate.
+ strict: Whether to enforce types strictly.
+ context: Extra variables to pass to the validator.
Args:
+ include: Optional set or mapping specifying which fields to include in the copied model.
+ exclude: Optional set or mapping specifying which fields to exclude in the copied model.
+ update: Optional dictionary of field-value pairs to override field values in the copied model.
+ deep: If True, the values of fields that are Pydantic models will be deep-copied.
+
+Returns:
+ A copy of the model with included, excluded and updated fields as specified.
+
+
+#### dict
+
+```python3
+def dict(
+ self,
+ *,
+ include: 'IncEx | None' = None,
+ exclude: 'IncEx | None' = None,
+ by_alias: 'bool' = False,
+ exclude_unset: 'bool' = False,
+ exclude_defaults: 'bool' = False,
+ exclude_none: 'bool' = False
+) -> 'Dict[str, Any]'
+
Args:
+ update: Values to change/add in the new model. Note: the data is not validated
+ before creating the new model. You should trust this data.
+ deep: Set to True to make a deep copy of the model.
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
Args:
+ mode: The mode in which to_python should run.
+ If mode is 'json', the output will only contain JSON serializable types.
+ If mode is 'python', the output may contain non-JSON-serializable Python objects.
+ include: A set of fields to include in the output.
+ exclude: A set of fields to exclude from the output.
+ context: Additional context to pass to the serializer.
+ by_alias: Whether to use the field's alias in the dictionary key if defined.
+ exclude_unset: Whether to exclude fields that have not been explicitly set.
+ exclude_defaults: Whether to exclude fields that are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A dictionary representation of the model.
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.
+ exclude: Field(s) to exclude from the JSON output.
+ context: Additional context to pass to the serializer.
+ 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 are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A JSON string representation of the model.
+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.
+
Attributes:
+ class_vars: The names of the class variables defined on the model.
+ private_attributes: Metadata about the private attributes of the model.
+ signature: The synthesized __init__ [Signature][inspect.Signature] of the model.
+
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The core schema of the model.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+ This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+ __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
+__pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
+__pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.
+
+__pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
+__pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.
+
+__pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
+ is set to `'allow'`.
+__pydantic_fields_set__: The names of fields explicitly set during instantiation.
+__pydantic_private__: Values of private attributes set on the model instance.
+
+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.
+
!!! note
+ model_construct() generally respects the model_config.extra setting on the provided model.
+ That is, if model_config.extra == 'allow', then all extra passed values are added to the model instance's __dict__
+ and __pydantic_extra__ fields. If model_config.extra == 'ignore' (the default), then all extra passed values are ignored.
+ Because no validation is performed with a call to model_construct(), having model_config.extra == 'forbid' does not result in
+ an error if extra values are passed, but they will be ignored.
+
Args:
+ _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
+ this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute.
+ Otherwise, the field names from the values argument will be used.
+ values: Trusted or pre-validated data dictionary.
+
Returns:
+ A new instance of the Model class with validated data.
Args:
+ by_alias: Whether to use attribute aliases or not.
+ ref_template: The reference template.
+ schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+ GenerateJsonSchema with your desired modifications
+ mode: The mode in which to generate the schema.
+
Returns:
+ The JSON schema for the given model class.
+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.
+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.
Args:
+ obj: The object to validate.
+ strict: Whether to enforce types strictly.
+ 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.
+Validate the given object with string data against the Pydantic model.
+
Args:
+ obj: The object containing string data to validate.
+ strict: Whether to enforce types strictly.
+ context: Extra variables to pass to the validator.
Args:
+ include: Optional set or mapping specifying which fields to include in the copied model.
+ exclude: Optional set or mapping specifying which fields to exclude in the copied model.
+ update: Optional dictionary of field-value pairs to override field values in the copied model.
+ deep: If True, the values of fields that are Pydantic models will be deep-copied.
+
+Returns:
+ A copy of the model with included, excluded and updated fields as specified.
+
+
+#### dict
+
+```python3
+def dict(
+ self,
+ *,
+ include: 'IncEx | None' = None,
+ exclude: 'IncEx | None' = None,
+ by_alias: 'bool' = False,
+ exclude_unset: 'bool' = False,
+ exclude_defaults: 'bool' = False,
+ exclude_none: 'bool' = False
+) -> 'Dict[str, Any]'
+
Args:
+ update: Values to change/add in the new model. Note: the data is not validated
+ before creating the new model. You should trust this data.
+ deep: Set to True to make a deep copy of the model.
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
Args:
+ mode: The mode in which to_python should run.
+ If mode is 'json', the output will only contain JSON serializable types.
+ If mode is 'python', the output may contain non-JSON-serializable Python objects.
+ include: A set of fields to include in the output.
+ exclude: A set of fields to exclude from the output.
+ context: Additional context to pass to the serializer.
+ by_alias: Whether to use the field's alias in the dictionary key if defined.
+ exclude_unset: Whether to exclude fields that have not been explicitly set.
+ exclude_defaults: Whether to exclude fields that are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A dictionary representation of the model.
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.
+ exclude: Field(s) to exclude from the JSON output.
+ context: Additional context to pass to the serializer.
+ 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 are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A JSON string representation of the model.
+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.
+
CategoryModel
+
classCategoryModel(
+ /,
+ **data:'Any'
+)
+
+
Model for category configuration settings.
+
Fields:
+- hdx (HDXModel): HDX configuration model.
+- types (List[str]): List of feature types (points, lines, polygons).
+- select (List[str]): List of selected fields.
+- where (str): SQL-like condition to filter features.
+- formats (List[str]): List of Export Formats (suffixes).
+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.
+
!!! note
+ model_construct() generally respects the model_config.extra setting on the provided model.
+ That is, if model_config.extra == 'allow', then all extra passed values are added to the model instance's __dict__
+ and __pydantic_extra__ fields. If model_config.extra == 'ignore' (the default), then all extra passed values are ignored.
+ Because no validation is performed with a call to model_construct(), having model_config.extra == 'forbid' does not result in
+ an error if extra values are passed, but they will be ignored.
+
Args:
+ _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
+ this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute.
+ Otherwise, the field names from the values argument will be used.
+ values: Trusted or pre-validated data dictionary.
+
Returns:
+ A new instance of the Model class with validated data.
Args:
+ by_alias: Whether to use attribute aliases or not.
+ ref_template: The reference template.
+ schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+ GenerateJsonSchema with your desired modifications
+ mode: The mode in which to generate the schema.
+
Returns:
+ The JSON schema for the given model class.
+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.
+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.
Args:
+ obj: The object to validate.
+ strict: Whether to enforce types strictly.
+ 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.
+Validate the given object with string data against the Pydantic model.
+
Args:
+ obj: The object containing string data to validate.
+ strict: Whether to enforce types strictly.
+ context: Extra variables to pass to the validator.
Args:
+ include: Optional set or mapping specifying which fields to include in the copied model.
+ exclude: Optional set or mapping specifying which fields to exclude in the copied model.
+ update: Optional dictionary of field-value pairs to override field values in the copied model.
+ deep: If True, the values of fields that are Pydantic models will be deep-copied.
+
+Returns:
+ A copy of the model with included, excluded and updated fields as specified.
+
+
+#### dict
+
+```python3
+def dict(
+ self,
+ *,
+ include: 'IncEx | None' = None,
+ exclude: 'IncEx | None' = None,
+ by_alias: 'bool' = False,
+ exclude_unset: 'bool' = False,
+ exclude_defaults: 'bool' = False,
+ exclude_none: 'bool' = False
+) -> 'Dict[str, Any]'
+
Args:
+ update: Values to change/add in the new model. Note: the data is not validated
+ before creating the new model. You should trust this data.
+ deep: Set to True to make a deep copy of the model.
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
Args:
+ mode: The mode in which to_python should run.
+ If mode is 'json', the output will only contain JSON serializable types.
+ If mode is 'python', the output may contain non-JSON-serializable Python objects.
+ include: A set of fields to include in the output.
+ exclude: A set of fields to exclude from the output.
+ context: Additional context to pass to the serializer.
+ by_alias: Whether to use the field's alias in the dictionary key if defined.
+ exclude_unset: Whether to exclude fields that have not been explicitly set.
+ exclude_defaults: Whether to exclude fields that are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A dictionary representation of the model.
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.
+ exclude: Field(s) to exclude from the JSON output.
+ context: Additional context to pass to the serializer.
+ 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 are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A JSON string representation of the model.
+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.
+
Attributes:
+ class_vars: The names of the class variables defined on the model.
+ private_attributes: Metadata about the private attributes of the model.
+ signature: The synthesized __init__ [Signature][inspect.Signature] of the model.
+
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The core schema of the model.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+ This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+ __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
+__pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
+__pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.
+
+__pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
+__pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.
+
+__pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
+ is set to `'allow'`.
+__pydantic_fields_set__: The names of fields explicitly set during instantiation.
+__pydantic_private__: Values of private attributes set on the model instance.
+
+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.
+
!!! note
+ model_construct() generally respects the model_config.extra setting on the provided model.
+ That is, if model_config.extra == 'allow', then all extra passed values are added to the model instance's __dict__
+ and __pydantic_extra__ fields. If model_config.extra == 'ignore' (the default), then all extra passed values are ignored.
+ Because no validation is performed with a call to model_construct(), having model_config.extra == 'forbid' does not result in
+ an error if extra values are passed, but they will be ignored.
+
Args:
+ _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
+ this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute.
+ Otherwise, the field names from the values argument will be used.
+ values: Trusted or pre-validated data dictionary.
+
Returns:
+ A new instance of the Model class with validated data.
Args:
+ by_alias: Whether to use attribute aliases or not.
+ ref_template: The reference template.
+ schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+ GenerateJsonSchema with your desired modifications
+ mode: The mode in which to generate the schema.
+
Returns:
+ The JSON schema for the given model class.
+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.
+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.
Args:
+ obj: The object to validate.
+ strict: Whether to enforce types strictly.
+ 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.
+Validate the given object with string data against the Pydantic model.
+
Args:
+ obj: The object containing string data to validate.
+ strict: Whether to enforce types strictly.
+ context: Extra variables to pass to the validator.
Args:
+ include: Optional set or mapping specifying which fields to include in the copied model.
+ exclude: Optional set or mapping specifying which fields to exclude in the copied model.
+ update: Optional dictionary of field-value pairs to override field values in the copied model.
+ deep: If True, the values of fields that are Pydantic models will be deep-copied.
+
+Returns:
+ A copy of the model with included, excluded and updated fields as specified.
+
+
+#### dict
+
+```python3
+def dict(
+ self,
+ *,
+ include: 'IncEx | None' = None,
+ exclude: 'IncEx | None' = None,
+ by_alias: 'bool' = False,
+ exclude_unset: 'bool' = False,
+ exclude_defaults: 'bool' = False,
+ exclude_none: 'bool' = False
+) -> 'Dict[str, Any]'
+
Args:
+ update: Values to change/add in the new model. Note: the data is not validated
+ before creating the new model. You should trust this data.
+ deep: Set to True to make a deep copy of the model.
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
Args:
+ mode: The mode in which to_python should run.
+ If mode is 'json', the output will only contain JSON serializable types.
+ If mode is 'python', the output may contain non-JSON-serializable Python objects.
+ include: A set of fields to include in the output.
+ exclude: A set of fields to exclude from the output.
+ context: Additional context to pass to the serializer.
+ by_alias: Whether to use the field's alias in the dictionary key if defined.
+ exclude_unset: Whether to exclude fields that have not been explicitly set.
+ exclude_defaults: Whether to exclude fields that are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A dictionary representation of the model.
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.
+ exclude: Field(s) to exclude from the JSON output.
+ context: Additional context to pass to the serializer.
+ 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 are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A JSON string representation of the model.
+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.
+
DatasetConfig
+
classDatasetConfig(
+ /,
+ **data:'Any'
+)
+
+
Model for dataset configuration settings.
+
Fields:
+- private (bool): Make dataset private. By default False, public is recommended.
+- subnational (bool): Make it true if the dataset doesn't cover the nation/country.
+- update_frequency (str): Update frequency to be added on uploads.
+- dataset_title (str): Dataset title that appears at the top of the page.
+- dataset_prefix (str): Dataset prefix to be appended before the category name. Ignored if iso3 is supplied.
+- dataset_locations (List[str]): Valid dataset locations iso3.
+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.
+
!!! note
+ model_construct() generally respects the model_config.extra setting on the provided model.
+ That is, if model_config.extra == 'allow', then all extra passed values are added to the model instance's __dict__
+ and __pydantic_extra__ fields. If model_config.extra == 'ignore' (the default), then all extra passed values are ignored.
+ Because no validation is performed with a call to model_construct(), having model_config.extra == 'forbid' does not result in
+ an error if extra values are passed, but they will be ignored.
+
Args:
+ _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
+ this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute.
+ Otherwise, the field names from the values argument will be used.
+ values: Trusted or pre-validated data dictionary.
+
Returns:
+ A new instance of the Model class with validated data.
Args:
+ by_alias: Whether to use attribute aliases or not.
+ ref_template: The reference template.
+ schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+ GenerateJsonSchema with your desired modifications
+ mode: The mode in which to generate the schema.
+
Returns:
+ The JSON schema for the given model class.
+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.
+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.
Args:
+ obj: The object to validate.
+ strict: Whether to enforce types strictly.
+ 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.
+Validate the given object with string data against the Pydantic model.
+
Args:
+ obj: The object containing string data to validate.
+ strict: Whether to enforce types strictly.
+ context: Extra variables to pass to the validator.
Args:
+ include: Optional set or mapping specifying which fields to include in the copied model.
+ exclude: Optional set or mapping specifying which fields to exclude in the copied model.
+ update: Optional dictionary of field-value pairs to override field values in the copied model.
+ deep: If True, the values of fields that are Pydantic models will be deep-copied.
+
+Returns:
+ A copy of the model with included, excluded and updated fields as specified.
+
+
+#### dict
+
+```python3
+def dict(
+ self,
+ *,
+ include: 'IncEx | None' = None,
+ exclude: 'IncEx | None' = None,
+ by_alias: 'bool' = False,
+ exclude_unset: 'bool' = False,
+ exclude_defaults: 'bool' = False,
+ exclude_none: 'bool' = False
+) -> 'Dict[str, Any]'
+
Args:
+ update: Values to change/add in the new model. Note: the data is not validated
+ before creating the new model. You should trust this data.
+ deep: Set to True to make a deep copy of the model.
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
Args:
+ mode: The mode in which to_python should run.
+ If mode is 'json', the output will only contain JSON serializable types.
+ If mode is 'python', the output may contain non-JSON-serializable Python objects.
+ include: A set of fields to include in the output.
+ exclude: A set of fields to exclude from the output.
+ context: Additional context to pass to the serializer.
+ by_alias: Whether to use the field's alias in the dictionary key if defined.
+ exclude_unset: Whether to exclude fields that have not been explicitly set.
+ exclude_defaults: Whether to exclude fields that are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A dictionary representation of the model.
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.
+ exclude: Field(s) to exclude from the JSON output.
+ context: Additional context to pass to the serializer.
+ 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 are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A JSON string representation of the model.
+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.
+
Fields:
+- iso3 (Optional[str]): ISO3 Country Code.
+- dataset (Optional[DatasetConfig]): Dataset Configurations for HDX Upload.
+- meta (bool): Dumps Meta db in parquet format & HDX config JSON to S3.
+- hdx_upload (bool): Enable/Disable uploading the dataset to HDX.
+- categories (List[Dict[str, CategoryModel]]): List of dynamic categories.
+- geometry (Optional[Union[Polygon, MultiPolygon]]): Custom polygon geometry.
+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.
+
!!! note
+ model_construct() generally respects the model_config.extra setting on the provided model.
+ That is, if model_config.extra == 'allow', then all extra passed values are added to the model instance's __dict__
+ and __pydantic_extra__ fields. If model_config.extra == 'ignore' (the default), then all extra passed values are ignored.
+ Because no validation is performed with a call to model_construct(), having model_config.extra == 'forbid' does not result in
+ an error if extra values are passed, but they will be ignored.
+
Args:
+ _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
+ this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute.
+ Otherwise, the field names from the values argument will be used.
+ values: Trusted or pre-validated data dictionary.
+
Returns:
+ A new instance of the Model class with validated data.
Args:
+ by_alias: Whether to use attribute aliases or not.
+ ref_template: The reference template.
+ schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+ GenerateJsonSchema with your desired modifications
+ mode: The mode in which to generate the schema.
+
Returns:
+ The JSON schema for the given model class.
+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.
+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.
Args:
+ obj: The object to validate.
+ strict: Whether to enforce types strictly.
+ 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.
+Validate the given object with string data against the Pydantic model.
+
Args:
+ obj: The object containing string data to validate.
+ strict: Whether to enforce types strictly.
+ context: Extra variables to pass to the validator.
Args:
+ include: Optional set or mapping specifying which fields to include in the copied model.
+ exclude: Optional set or mapping specifying which fields to exclude in the copied model.
+ update: Optional dictionary of field-value pairs to override field values in the copied model.
+ deep: If True, the values of fields that are Pydantic models will be deep-copied.
+
+Returns:
+ A copy of the model with included, excluded and updated fields as specified.
+
+
+#### dict
+
+```python3
+def dict(
+ self,
+ *,
+ include: 'IncEx | None' = None,
+ exclude: 'IncEx | None' = None,
+ by_alias: 'bool' = False,
+ exclude_unset: 'bool' = False,
+ exclude_defaults: 'bool' = False,
+ exclude_none: 'bool' = False
+) -> 'Dict[str, Any]'
+
Args:
+ update: Values to change/add in the new model. Note: the data is not validated
+ before creating the new model. You should trust this data.
+ deep: Set to True to make a deep copy of the model.
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
Args:
+ mode: The mode in which to_python should run.
+ If mode is 'json', the output will only contain JSON serializable types.
+ If mode is 'python', the output may contain non-JSON-serializable Python objects.
+ include: A set of fields to include in the output.
+ exclude: A set of fields to exclude from the output.
+ context: Additional context to pass to the serializer.
+ by_alias: Whether to use the field's alias in the dictionary key if defined.
+ exclude_unset: Whether to exclude fields that have not been explicitly set.
+ exclude_defaults: Whether to exclude fields that are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A dictionary representation of the model.
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.
+ exclude: Field(s) to exclude from the JSON output.
+ context: Additional context to pass to the serializer.
+ 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 are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A JSON string representation of the model.
+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.
+
Attributes:
+ class_vars: The names of the class variables defined on the model.
+ private_attributes: Metadata about the private attributes of the model.
+ signature: The synthesized __init__ [Signature][inspect.Signature] of the model.
+
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The core schema of the model.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+ This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+ __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
+__pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
+__pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.
+
+__pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
+__pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.
+
+__pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
+ is set to `'allow'`.
+__pydantic_fields_set__: The names of fields explicitly set during instantiation.
+__pydantic_private__: Values of private attributes set on the model instance.
+
+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.
+
!!! note
+ model_construct() generally respects the model_config.extra setting on the provided model.
+ That is, if model_config.extra == 'allow', then all extra passed values are added to the model instance's __dict__
+ and __pydantic_extra__ fields. If model_config.extra == 'ignore' (the default), then all extra passed values are ignored.
+ Because no validation is performed with a call to model_construct(), having model_config.extra == 'forbid' does not result in
+ an error if extra values are passed, but they will be ignored.
+
Args:
+ _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
+ this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute.
+ Otherwise, the field names from the values argument will be used.
+ values: Trusted or pre-validated data dictionary.
+
Returns:
+ A new instance of the Model class with validated data.
Args:
+ by_alias: Whether to use attribute aliases or not.
+ ref_template: The reference template.
+ schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+ GenerateJsonSchema with your desired modifications
+ mode: The mode in which to generate the schema.
+
Returns:
+ The JSON schema for the given model class.
+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.
+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.
Args:
+ obj: The object to validate.
+ strict: Whether to enforce types strictly.
+ 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.
+Validate the given object with string data against the Pydantic model.
+
Args:
+ obj: The object containing string data to validate.
+ strict: Whether to enforce types strictly.
+ context: Extra variables to pass to the validator.
Args:
+ include: Optional set or mapping specifying which fields to include in the copied model.
+ exclude: Optional set or mapping specifying which fields to exclude in the copied model.
+ update: Optional dictionary of field-value pairs to override field values in the copied model.
+ deep: If True, the values of fields that are Pydantic models will be deep-copied.
+
+Returns:
+ A copy of the model with included, excluded and updated fields as specified.
+
+
+#### dict
+
+```python3
+def dict(
+ self,
+ *,
+ include: 'IncEx | None' = None,
+ exclude: 'IncEx | None' = None,
+ by_alias: 'bool' = False,
+ exclude_unset: 'bool' = False,
+ exclude_defaults: 'bool' = False,
+ exclude_none: 'bool' = False
+) -> 'Dict[str, Any]'
+
Args:
+ update: Values to change/add in the new model. Note: the data is not validated
+ before creating the new model. You should trust this data.
+ deep: Set to True to make a deep copy of the model.
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
Args:
+ mode: The mode in which to_python should run.
+ If mode is 'json', the output will only contain JSON serializable types.
+ If mode is 'python', the output may contain non-JSON-serializable Python objects.
+ include: A set of fields to include in the output.
+ exclude: A set of fields to exclude from the output.
+ context: Additional context to pass to the serializer.
+ by_alias: Whether to use the field's alias in the dictionary key if defined.
+ exclude_unset: Whether to exclude fields that have not been explicitly set.
+ exclude_defaults: Whether to exclude fields that are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A dictionary representation of the model.
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.
+ exclude: Field(s) to exclude from the JSON output.
+ context: Additional context to pass to the serializer.
+ 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 are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A JSON string representation of the model.
+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.
+
Fields:
+- tags (List[str]): List of tags for the HDX model.
+- caveats (str): Caveats/Warning for the Datasets.
+- notes (str): Extra notes to append in the notes section of HDX datasets.
+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.
+
!!! note
+ model_construct() generally respects the model_config.extra setting on the provided model.
+ That is, if model_config.extra == 'allow', then all extra passed values are added to the model instance's __dict__
+ and __pydantic_extra__ fields. If model_config.extra == 'ignore' (the default), then all extra passed values are ignored.
+ Because no validation is performed with a call to model_construct(), having model_config.extra == 'forbid' does not result in
+ an error if extra values are passed, but they will be ignored.
+
Args:
+ _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
+ this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute.
+ Otherwise, the field names from the values argument will be used.
+ values: Trusted or pre-validated data dictionary.
+
Returns:
+ A new instance of the Model class with validated data.
Args:
+ by_alias: Whether to use attribute aliases or not.
+ ref_template: The reference template.
+ schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+ GenerateJsonSchema with your desired modifications
+ mode: The mode in which to generate the schema.
+
Returns:
+ The JSON schema for the given model class.
+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.
+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.
Args:
+ obj: The object to validate.
+ strict: Whether to enforce types strictly.
+ 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.
+Validate the given object with string data against the Pydantic model.
+
Args:
+ obj: The object containing string data to validate.
+ strict: Whether to enforce types strictly.
+ context: Extra variables to pass to the validator.
Args:
+ include: Optional set or mapping specifying which fields to include in the copied model.
+ exclude: Optional set or mapping specifying which fields to exclude in the copied model.
+ update: Optional dictionary of field-value pairs to override field values in the copied model.
+ deep: If True, the values of fields that are Pydantic models will be deep-copied.
+
+Returns:
+ A copy of the model with included, excluded and updated fields as specified.
+
+
+#### dict
+
+```python3
+def dict(
+ self,
+ *,
+ include: 'IncEx | None' = None,
+ exclude: 'IncEx | None' = None,
+ by_alias: 'bool' = False,
+ exclude_unset: 'bool' = False,
+ exclude_defaults: 'bool' = False,
+ exclude_none: 'bool' = False
+) -> 'Dict[str, Any]'
+
Args:
+ update: Values to change/add in the new model. Note: the data is not validated
+ before creating the new model. You should trust this data.
+ deep: Set to True to make a deep copy of the model.
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
Args:
+ mode: The mode in which to_python should run.
+ If mode is 'json', the output will only contain JSON serializable types.
+ If mode is 'python', the output may contain non-JSON-serializable Python objects.
+ include: A set of fields to include in the output.
+ exclude: A set of fields to exclude from the output.
+ context: Additional context to pass to the serializer.
+ by_alias: Whether to use the field's alias in the dictionary key if defined.
+ exclude_unset: Whether to exclude fields that have not been explicitly set.
+ exclude_defaults: Whether to exclude fields that are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A dictionary representation of the model.
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.
+ exclude: Field(s) to exclude from the JSON output.
+ context: Additional context to pass to the serializer.
+ 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 are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A JSON string representation of the model.
+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.
+
JoinFilterType
+
classJoinFilterType(
+ *args,
+ **kwds
+)
+
+
Create a collection of name/value pairs.
+
Example enumeration:
+
+
+
+
class Color(Enum):
+... RED = 1
+... BLUE = 2
+... GREEN = 3
+
+
+
+
Access them by:
+
+
attribute access::
+
+
+
+
+
Color.RED
+
+
+
+
+
+
value lookup:
+
+
+
+
+
Color(1)
+
+
+
+
+
+
name lookup:
+
+
+
+
+
Color['RED']
+
+
+
+
+
Enumerations can be iterated over, and know how many members they have:
+
+
+
+
len(Color)
+3
+
list(Color)
+[, , ]
+
+
+
+
Methods can be added to enumerations, and members can have their own
+attributes -- see the documentation for details.
Attributes:
+ class_vars: The names of the class variables defined on the model.
+ private_attributes: Metadata about the private attributes of the model.
+ signature: The synthesized __init__ [Signature][inspect.Signature] of the model.
+
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The core schema of the model.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+ This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+ __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
+__pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
+__pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.
+
+__pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
+__pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.
+
+__pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
+ is set to `'allow'`.
+__pydantic_fields_set__: The names of fields explicitly set during instantiation.
+__pydantic_private__: Values of private attributes set on the model instance.
+
+
Ancestors (in MRO)
+
+
src.validation.models.RawDataCurrentParamsBase
+
src.validation.models.BaseModel
+
pydantic.main.BaseModel
+
src.validation.models.GeometryValidatorMixin
+
+
Class variables
+
Config
+
+
model_computed_fields
+
+
model_config
+
+
model_fields
+
+
Static methods
+
check_bind_option
+
defcheck_bind_option(
+ value,
+ values
+)
+
+Checks if cloud optimized output format or geoJSON is selected along with bind to zip file
+
+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.
+
!!! note
+ model_construct() generally respects the model_config.extra setting on the provided model.
+ That is, if model_config.extra == 'allow', then all extra passed values are added to the model instance's __dict__
+ and __pydantic_extra__ fields. If model_config.extra == 'ignore' (the default), then all extra passed values are ignored.
+ Because no validation is performed with a call to model_construct(), having model_config.extra == 'forbid' does not result in
+ an error if extra values are passed, but they will be ignored.
+
Args:
+ _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
+ this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute.
+ Otherwise, the field names from the values argument will be used.
+ values: Trusted or pre-validated data dictionary.
+
Returns:
+ A new instance of the Model class with validated data.
Args:
+ by_alias: Whether to use attribute aliases or not.
+ ref_template: The reference template.
+ schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+ GenerateJsonSchema with your desired modifications
+ mode: The mode in which to generate the schema.
+
Returns:
+ The JSON schema for the given model class.
+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.
+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.
Args:
+ obj: The object to validate.
+ strict: Whether to enforce types strictly.
+ 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.
+Validate the given object with string data against the Pydantic model.
+
Args:
+ obj: The object containing string data to validate.
+ strict: Whether to enforce types strictly.
+ context: Extra variables to pass to the validator.
Args:
+ include: Optional set or mapping specifying which fields to include in the copied model.
+ exclude: Optional set or mapping specifying which fields to exclude in the copied model.
+ update: Optional dictionary of field-value pairs to override field values in the copied model.
+ deep: If True, the values of fields that are Pydantic models will be deep-copied.
+
+Returns:
+ A copy of the model with included, excluded and updated fields as specified.
+
+
+#### dict
+
+```python3
+def dict(
+ self,
+ *,
+ include: 'IncEx | None' = None,
+ exclude: 'IncEx | None' = None,
+ by_alias: 'bool' = False,
+ exclude_unset: 'bool' = False,
+ exclude_defaults: 'bool' = False,
+ exclude_none: 'bool' = False
+) -> 'Dict[str, Any]'
+
Args:
+ update: Values to change/add in the new model. Note: the data is not validated
+ before creating the new model. You should trust this data.
+ deep: Set to True to make a deep copy of the model.
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
Args:
+ mode: The mode in which to_python should run.
+ If mode is 'json', the output will only contain JSON serializable types.
+ If mode is 'python', the output may contain non-JSON-serializable Python objects.
+ include: A set of fields to include in the output.
+ exclude: A set of fields to exclude from the output.
+ context: Additional context to pass to the serializer.
+ by_alias: Whether to use the field's alias in the dictionary key if defined.
+ exclude_unset: Whether to exclude fields that have not been explicitly set.
+ exclude_defaults: Whether to exclude fields that are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A dictionary representation of the model.
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.
+ exclude: Field(s) to exclude from the JSON output.
+ context: Additional context to pass to the serializer.
+ 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 are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A JSON string representation of the model.
+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.
+
Attributes:
+ class_vars: The names of the class variables defined on the model.
+ private_attributes: Metadata about the private attributes of the model.
+ signature: The synthesized __init__ [Signature][inspect.Signature] of the model.
+
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The core schema of the model.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+ This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+ __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
+__pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
+__pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.
+
+__pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
+__pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.
+
+__pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
+ is set to `'allow'`.
+__pydantic_fields_set__: The names of fields explicitly set during instantiation.
+__pydantic_private__: Values of private attributes set on the model instance.
+
+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.
+
!!! note
+ model_construct() generally respects the model_config.extra setting on the provided model.
+ That is, if model_config.extra == 'allow', then all extra passed values are added to the model instance's __dict__
+ and __pydantic_extra__ fields. If model_config.extra == 'ignore' (the default), then all extra passed values are ignored.
+ Because no validation is performed with a call to model_construct(), having model_config.extra == 'forbid' does not result in
+ an error if extra values are passed, but they will be ignored.
+
Args:
+ _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
+ this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute.
+ Otherwise, the field names from the values argument will be used.
+ values: Trusted or pre-validated data dictionary.
+
Returns:
+ A new instance of the Model class with validated data.
Args:
+ by_alias: Whether to use attribute aliases or not.
+ ref_template: The reference template.
+ schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+ GenerateJsonSchema with your desired modifications
+ mode: The mode in which to generate the schema.
+
Returns:
+ The JSON schema for the given model class.
+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.
+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.
Args:
+ obj: The object to validate.
+ strict: Whether to enforce types strictly.
+ 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.
+Validate the given object with string data against the Pydantic model.
+
Args:
+ obj: The object containing string data to validate.
+ strict: Whether to enforce types strictly.
+ context: Extra variables to pass to the validator.
Args:
+ include: Optional set or mapping specifying which fields to include in the copied model.
+ exclude: Optional set or mapping specifying which fields to exclude in the copied model.
+ update: Optional dictionary of field-value pairs to override field values in the copied model.
+ deep: If True, the values of fields that are Pydantic models will be deep-copied.
+
+Returns:
+ A copy of the model with included, excluded and updated fields as specified.
+
+
+#### dict
+
+```python3
+def dict(
+ self,
+ *,
+ include: 'IncEx | None' = None,
+ exclude: 'IncEx | None' = None,
+ by_alias: 'bool' = False,
+ exclude_unset: 'bool' = False,
+ exclude_defaults: 'bool' = False,
+ exclude_none: 'bool' = False
+) -> 'Dict[str, Any]'
+
Args:
+ update: Values to change/add in the new model. Note: the data is not validated
+ before creating the new model. You should trust this data.
+ deep: Set to True to make a deep copy of the model.
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
Args:
+ mode: The mode in which to_python should run.
+ If mode is 'json', the output will only contain JSON serializable types.
+ If mode is 'python', the output may contain non-JSON-serializable Python objects.
+ include: A set of fields to include in the output.
+ exclude: A set of fields to exclude from the output.
+ context: Additional context to pass to the serializer.
+ by_alias: Whether to use the field's alias in the dictionary key if defined.
+ exclude_unset: Whether to exclude fields that have not been explicitly set.
+ exclude_defaults: Whether to exclude fields that are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A dictionary representation of the model.
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.
+ exclude: Field(s) to exclude from the JSON output.
+ context: Additional context to pass to the serializer.
+ 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 are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A JSON string representation of the model.
+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.
+
RawDataOutputType
+
classRawDataOutputType(
+ *args,
+ **kwds
+)
+
+
Create a collection of name/value pairs.
+
Example enumeration:
+
+
+
+
class Color(Enum):
+... RED = 1
+... BLUE = 2
+... GREEN = 3
+
+
+
+
Access them by:
+
+
attribute access::
+
+
+
+
+
Color.RED
+
+
+
+
+
+
value lookup:
+
+
+
+
+
Color(1)
+
+
+
+
+
+
name lookup:
+
+
+
+
+
Color['RED']
+
+
+
+
+
Enumerations can be iterated over, and know how many members they have:
+
+
+
+
len(Color)
+3
+
list(Color)
+[, , ]
+
+
+
+
Methods can be added to enumerations, and members can have their own
+attributes -- see the documentation for details.
Attributes:
+ class_vars: The names of the class variables defined on the model.
+ private_attributes: Metadata about the private attributes of the model.
+ signature: The synthesized __init__ [Signature][inspect.Signature] of the model.
+
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The core schema of the model.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+ This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+ __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
+__pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
+__pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.
+
+__pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
+__pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.
+
+__pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
+ is set to `'allow'`.
+__pydantic_fields_set__: The names of fields explicitly set during instantiation.
+__pydantic_private__: Values of private attributes set on the model instance.
+
+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.
+
!!! note
+ model_construct() generally respects the model_config.extra setting on the provided model.
+ That is, if model_config.extra == 'allow', then all extra passed values are added to the model instance's __dict__
+ and __pydantic_extra__ fields. If model_config.extra == 'ignore' (the default), then all extra passed values are ignored.
+ Because no validation is performed with a call to model_construct(), having model_config.extra == 'forbid' does not result in
+ an error if extra values are passed, but they will be ignored.
+
Args:
+ _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
+ this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute.
+ Otherwise, the field names from the values argument will be used.
+ values: Trusted or pre-validated data dictionary.
+
Returns:
+ A new instance of the Model class with validated data.
Args:
+ by_alias: Whether to use attribute aliases or not.
+ ref_template: The reference template.
+ schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+ GenerateJsonSchema with your desired modifications
+ mode: The mode in which to generate the schema.
+
Returns:
+ The JSON schema for the given model class.
+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.
+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.
Args:
+ obj: The object to validate.
+ strict: Whether to enforce types strictly.
+ 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.
+Validate the given object with string data against the Pydantic model.
+
Args:
+ obj: The object containing string data to validate.
+ strict: Whether to enforce types strictly.
+ context: Extra variables to pass to the validator.
Args:
+ include: Optional set or mapping specifying which fields to include in the copied model.
+ exclude: Optional set or mapping specifying which fields to exclude in the copied model.
+ update: Optional dictionary of field-value pairs to override field values in the copied model.
+ deep: If True, the values of fields that are Pydantic models will be deep-copied.
+
+Returns:
+ A copy of the model with included, excluded and updated fields as specified.
+
+
+#### dict
+
+```python3
+def dict(
+ self,
+ *,
+ include: 'IncEx | None' = None,
+ exclude: 'IncEx | None' = None,
+ by_alias: 'bool' = False,
+ exclude_unset: 'bool' = False,
+ exclude_defaults: 'bool' = False,
+ exclude_none: 'bool' = False
+) -> 'Dict[str, Any]'
+
Args:
+ update: Values to change/add in the new model. Note: the data is not validated
+ before creating the new model. You should trust this data.
+ deep: Set to True to make a deep copy of the model.
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
Args:
+ mode: The mode in which to_python should run.
+ If mode is 'json', the output will only contain JSON serializable types.
+ If mode is 'python', the output may contain non-JSON-serializable Python objects.
+ include: A set of fields to include in the output.
+ exclude: A set of fields to exclude from the output.
+ context: Additional context to pass to the serializer.
+ by_alias: Whether to use the field's alias in the dictionary key if defined.
+ exclude_unset: Whether to exclude fields that have not been explicitly set.
+ exclude_defaults: Whether to exclude fields that are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A dictionary representation of the model.
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.
+ exclude: Field(s) to exclude from the JSON output.
+ context: Additional context to pass to the serializer.
+ 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 are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A JSON string representation of the model.
+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.
+
Attributes:
+ class_vars: The names of the class variables defined on the model.
+ private_attributes: Metadata about the private attributes of the model.
+ signature: The synthesized __init__ [Signature][inspect.Signature] of the model.
+
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The core schema of the model.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+ This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+ __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
+__pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
+__pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.
+
+__pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
+__pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.
+
+__pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
+ is set to `'allow'`.
+__pydantic_fields_set__: The names of fields explicitly set during instantiation.
+__pydantic_private__: Values of private attributes set on the model instance.
+
+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.
+
!!! note
+ model_construct() generally respects the model_config.extra setting on the provided model.
+ That is, if model_config.extra == 'allow', then all extra passed values are added to the model instance's __dict__
+ and __pydantic_extra__ fields. If model_config.extra == 'ignore' (the default), then all extra passed values are ignored.
+ Because no validation is performed with a call to model_construct(), having model_config.extra == 'forbid' does not result in
+ an error if extra values are passed, but they will be ignored.
+
Args:
+ _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
+ this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute.
+ Otherwise, the field names from the values argument will be used.
+ values: Trusted or pre-validated data dictionary.
+
Returns:
+ A new instance of the Model class with validated data.
Args:
+ by_alias: Whether to use attribute aliases or not.
+ ref_template: The reference template.
+ schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+ GenerateJsonSchema with your desired modifications
+ mode: The mode in which to generate the schema.
+
Returns:
+ The JSON schema for the given model class.
+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.
+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.
Args:
+ obj: The object to validate.
+ strict: Whether to enforce types strictly.
+ 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.
+Validate the given object with string data against the Pydantic model.
+
Args:
+ obj: The object containing string data to validate.
+ strict: Whether to enforce types strictly.
+ context: Extra variables to pass to the validator.
Args:
+ include: Optional set or mapping specifying which fields to include in the copied model.
+ exclude: Optional set or mapping specifying which fields to exclude in the copied model.
+ update: Optional dictionary of field-value pairs to override field values in the copied model.
+ deep: If True, the values of fields that are Pydantic models will be deep-copied.
+
+Returns:
+ A copy of the model with included, excluded and updated fields as specified.
+
+
+#### dict
+
+```python3
+def dict(
+ self,
+ *,
+ include: 'IncEx | None' = None,
+ exclude: 'IncEx | None' = None,
+ by_alias: 'bool' = False,
+ exclude_unset: 'bool' = False,
+ exclude_defaults: 'bool' = False,
+ exclude_none: 'bool' = False
+) -> 'Dict[str, Any]'
+
Args:
+ update: Values to change/add in the new model. Note: the data is not validated
+ before creating the new model. You should trust this data.
+ deep: Set to True to make a deep copy of the model.
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
Args:
+ mode: The mode in which to_python should run.
+ If mode is 'json', the output will only contain JSON serializable types.
+ If mode is 'python', the output may contain non-JSON-serializable Python objects.
+ include: A set of fields to include in the output.
+ exclude: A set of fields to exclude from the output.
+ context: Additional context to pass to the serializer.
+ by_alias: Whether to use the field's alias in the dictionary key if defined.
+ exclude_unset: Whether to exclude fields that have not been explicitly set.
+ exclude_defaults: Whether to exclude fields that are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A dictionary representation of the model.
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.
+ exclude: Field(s) to exclude from the JSON output.
+ context: Additional context to pass to the serializer.
+ 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 are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A JSON string representation of the model.
+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.
+
Attributes:
+ class_vars: The names of the class variables defined on the model.
+ private_attributes: Metadata about the private attributes of the model.
+ signature: The synthesized __init__ [Signature][inspect.Signature] of the model.
+
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The core schema of the model.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+ This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+ __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
+__pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
+__pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.
+
+__pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
+__pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.
+
+__pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
+ is set to `'allow'`.
+__pydantic_fields_set__: The names of fields explicitly set during instantiation.
+__pydantic_private__: Values of private attributes set on the model instance.
+
+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.
+
!!! note
+ model_construct() generally respects the model_config.extra setting on the provided model.
+ That is, if model_config.extra == 'allow', then all extra passed values are added to the model instance's __dict__
+ and __pydantic_extra__ fields. If model_config.extra == 'ignore' (the default), then all extra passed values are ignored.
+ Because no validation is performed with a call to model_construct(), having model_config.extra == 'forbid' does not result in
+ an error if extra values are passed, but they will be ignored.
+
Args:
+ _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
+ this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute.
+ Otherwise, the field names from the values argument will be used.
+ values: Trusted or pre-validated data dictionary.
+
Returns:
+ A new instance of the Model class with validated data.
Args:
+ by_alias: Whether to use attribute aliases or not.
+ ref_template: The reference template.
+ schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+ GenerateJsonSchema with your desired modifications
+ mode: The mode in which to generate the schema.
+
Returns:
+ The JSON schema for the given model class.
+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.
+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.
Args:
+ obj: The object to validate.
+ strict: Whether to enforce types strictly.
+ 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.
+Validate the given object with string data against the Pydantic model.
+
Args:
+ obj: The object containing string data to validate.
+ strict: Whether to enforce types strictly.
+ context: Extra variables to pass to the validator.
Args:
+ include: Optional set or mapping specifying which fields to include in the copied model.
+ exclude: Optional set or mapping specifying which fields to exclude in the copied model.
+ update: Optional dictionary of field-value pairs to override field values in the copied model.
+ deep: If True, the values of fields that are Pydantic models will be deep-copied.
+
+Returns:
+ A copy of the model with included, excluded and updated fields as specified.
+
+
+#### dict
+
+```python3
+def dict(
+ self,
+ *,
+ include: 'IncEx | None' = None,
+ exclude: 'IncEx | None' = None,
+ by_alias: 'bool' = False,
+ exclude_unset: 'bool' = False,
+ exclude_defaults: 'bool' = False,
+ exclude_none: 'bool' = False
+) -> 'Dict[str, Any]'
+
Args:
+ update: Values to change/add in the new model. Note: the data is not validated
+ before creating the new model. You should trust this data.
+ deep: Set to True to make a deep copy of the model.
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
Args:
+ mode: The mode in which to_python should run.
+ If mode is 'json', the output will only contain JSON serializable types.
+ If mode is 'python', the output may contain non-JSON-serializable Python objects.
+ include: A set of fields to include in the output.
+ exclude: A set of fields to exclude from the output.
+ context: Additional context to pass to the serializer.
+ by_alias: Whether to use the field's alias in the dictionary key if defined.
+ exclude_unset: Whether to exclude fields that have not been explicitly set.
+ exclude_defaults: Whether to exclude fields that are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A dictionary representation of the model.
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.
+ exclude: Field(s) to exclude from the JSON output.
+ context: Additional context to pass to the serializer.
+ 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 are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A JSON string representation of the model.
+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.
+
Attributes:
+ class_vars: The names of the class variables defined on the model.
+ private_attributes: Metadata about the private attributes of the model.
+ signature: The synthesized __init__ [Signature][inspect.Signature] of the model.
+
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The core schema of the model.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+ This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+ __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
+__pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
+__pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.
+
+__pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
+__pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.
+
+__pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
+ is set to `'allow'`.
+__pydantic_fields_set__: The names of fields explicitly set during instantiation.
+__pydantic_private__: Values of private attributes set on the model instance.
+
+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.
+
!!! note
+ model_construct() generally respects the model_config.extra setting on the provided model.
+ That is, if model_config.extra == 'allow', then all extra passed values are added to the model instance's __dict__
+ and __pydantic_extra__ fields. If model_config.extra == 'ignore' (the default), then all extra passed values are ignored.
+ Because no validation is performed with a call to model_construct(), having model_config.extra == 'forbid' does not result in
+ an error if extra values are passed, but they will be ignored.
+
Args:
+ _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
+ this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute.
+ Otherwise, the field names from the values argument will be used.
+ values: Trusted or pre-validated data dictionary.
+
Returns:
+ A new instance of the Model class with validated data.
Args:
+ by_alias: Whether to use attribute aliases or not.
+ ref_template: The reference template.
+ schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+ GenerateJsonSchema with your desired modifications
+ mode: The mode in which to generate the schema.
+
Returns:
+ The JSON schema for the given model class.
+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.
+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.
Args:
+ obj: The object to validate.
+ strict: Whether to enforce types strictly.
+ 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.
+Validate the given object with string data against the Pydantic model.
+
Args:
+ obj: The object containing string data to validate.
+ strict: Whether to enforce types strictly.
+ context: Extra variables to pass to the validator.
Args:
+ include: Optional set or mapping specifying which fields to include in the copied model.
+ exclude: Optional set or mapping specifying which fields to exclude in the copied model.
+ update: Optional dictionary of field-value pairs to override field values in the copied model.
+ deep: If True, the values of fields that are Pydantic models will be deep-copied.
+
+Returns:
+ A copy of the model with included, excluded and updated fields as specified.
+
+
+#### dict
+
+```python3
+def dict(
+ self,
+ *,
+ include: 'IncEx | None' = None,
+ exclude: 'IncEx | None' = None,
+ by_alias: 'bool' = False,
+ exclude_unset: 'bool' = False,
+ exclude_defaults: 'bool' = False,
+ exclude_none: 'bool' = False
+) -> 'Dict[str, Any]'
+
Args:
+ update: Values to change/add in the new model. Note: the data is not validated
+ before creating the new model. You should trust this data.
+ deep: Set to True to make a deep copy of the model.
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
Args:
+ mode: The mode in which to_python should run.
+ If mode is 'json', the output will only contain JSON serializable types.
+ If mode is 'python', the output may contain non-JSON-serializable Python objects.
+ include: A set of fields to include in the output.
+ exclude: A set of fields to exclude from the output.
+ context: Additional context to pass to the serializer.
+ by_alias: Whether to use the field's alias in the dictionary key if defined.
+ exclude_unset: Whether to exclude fields that have not been explicitly set.
+ exclude_defaults: Whether to exclude fields that are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A dictionary representation of the model.
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.
+ exclude: Field(s) to exclude from the JSON output.
+ context: Additional context to pass to the serializer.
+ 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 are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A JSON string representation of the model.
+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.
+
Attributes:
+ class_vars: The names of the class variables defined on the model.
+ private_attributes: Metadata about the private attributes of the model.
+ signature: The synthesized __init__ [Signature][inspect.Signature] of the model.
+
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The core schema of the model.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+ This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+ __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
+__pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
+__pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.
+
+__pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
+__pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.
+
+__pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
+ is set to `'allow'`.
+__pydantic_fields_set__: The names of fields explicitly set during instantiation.
+__pydantic_private__: Values of private attributes set on the model instance.
+
+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.
+
!!! note
+ model_construct() generally respects the model_config.extra setting on the provided model.
+ That is, if model_config.extra == 'allow', then all extra passed values are added to the model instance's __dict__
+ and __pydantic_extra__ fields. If model_config.extra == 'ignore' (the default), then all extra passed values are ignored.
+ Because no validation is performed with a call to model_construct(), having model_config.extra == 'forbid' does not result in
+ an error if extra values are passed, but they will be ignored.
+
Args:
+ _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
+ this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute.
+ Otherwise, the field names from the values argument will be used.
+ values: Trusted or pre-validated data dictionary.
+
Returns:
+ A new instance of the Model class with validated data.
Args:
+ by_alias: Whether to use attribute aliases or not.
+ ref_template: The reference template.
+ schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+ GenerateJsonSchema with your desired modifications
+ mode: The mode in which to generate the schema.
+
Returns:
+ The JSON schema for the given model class.
+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.
+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.
Args:
+ obj: The object to validate.
+ strict: Whether to enforce types strictly.
+ 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.
+Validate the given object with string data against the Pydantic model.
+
Args:
+ obj: The object containing string data to validate.
+ strict: Whether to enforce types strictly.
+ context: Extra variables to pass to the validator.
Args:
+ include: Optional set or mapping specifying which fields to include in the copied model.
+ exclude: Optional set or mapping specifying which fields to exclude in the copied model.
+ update: Optional dictionary of field-value pairs to override field values in the copied model.
+ deep: If True, the values of fields that are Pydantic models will be deep-copied.
+
+Returns:
+ A copy of the model with included, excluded and updated fields as specified.
+
+
+#### dict
+
+```python3
+def dict(
+ self,
+ *,
+ include: 'IncEx | None' = None,
+ exclude: 'IncEx | None' = None,
+ by_alias: 'bool' = False,
+ exclude_unset: 'bool' = False,
+ exclude_defaults: 'bool' = False,
+ exclude_none: 'bool' = False
+) -> 'Dict[str, Any]'
+
Args:
+ update: Values to change/add in the new model. Note: the data is not validated
+ before creating the new model. You should trust this data.
+ deep: Set to True to make a deep copy of the model.
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
Args:
+ mode: The mode in which to_python should run.
+ If mode is 'json', the output will only contain JSON serializable types.
+ If mode is 'python', the output may contain non-JSON-serializable Python objects.
+ include: A set of fields to include in the output.
+ exclude: A set of fields to exclude from the output.
+ context: Additional context to pass to the serializer.
+ by_alias: Whether to use the field's alias in the dictionary key if defined.
+ exclude_unset: Whether to exclude fields that have not been explicitly set.
+ exclude_defaults: Whether to exclude fields that are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A dictionary representation of the model.
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.
+ exclude: Field(s) to exclude from the JSON output.
+ context: Additional context to pass to the serializer.
+ 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 are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A JSON string representation of the model.
+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.
+
Attributes:
+ class_vars: The names of the class variables defined on the model.
+ private_attributes: Metadata about the private attributes of the model.
+ signature: The synthesized __init__ [Signature][inspect.Signature] of the model.
+
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The core schema of the model.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+ This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+ __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
+__pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
+__pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.
+
+__pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
+__pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.
+
+__pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
+ is set to `'allow'`.
+__pydantic_fields_set__: The names of fields explicitly set during instantiation.
+__pydantic_private__: Values of private attributes set on the model instance.
+
+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.
+
!!! note
+ model_construct() generally respects the model_config.extra setting on the provided model.
+ That is, if model_config.extra == 'allow', then all extra passed values are added to the model instance's __dict__
+ and __pydantic_extra__ fields. If model_config.extra == 'ignore' (the default), then all extra passed values are ignored.
+ Because no validation is performed with a call to model_construct(), having model_config.extra == 'forbid' does not result in
+ an error if extra values are passed, but they will be ignored.
+
Args:
+ _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
+ this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute.
+ Otherwise, the field names from the values argument will be used.
+ values: Trusted or pre-validated data dictionary.
+
Returns:
+ A new instance of the Model class with validated data.
Args:
+ by_alias: Whether to use attribute aliases or not.
+ ref_template: The reference template.
+ schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+ GenerateJsonSchema with your desired modifications
+ mode: The mode in which to generate the schema.
+
Returns:
+ The JSON schema for the given model class.
+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.
+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.
Args:
+ obj: The object to validate.
+ strict: Whether to enforce types strictly.
+ 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.
+Validate the given object with string data against the Pydantic model.
+
Args:
+ obj: The object containing string data to validate.
+ strict: Whether to enforce types strictly.
+ context: Extra variables to pass to the validator.
Args:
+ include: Optional set or mapping specifying which fields to include in the copied model.
+ exclude: Optional set or mapping specifying which fields to exclude in the copied model.
+ update: Optional dictionary of field-value pairs to override field values in the copied model.
+ deep: If True, the values of fields that are Pydantic models will be deep-copied.
+
+Returns:
+ A copy of the model with included, excluded and updated fields as specified.
+
+
+#### dict
+
+```python3
+def dict(
+ self,
+ *,
+ include: 'IncEx | None' = None,
+ exclude: 'IncEx | None' = None,
+ by_alias: 'bool' = False,
+ exclude_unset: 'bool' = False,
+ exclude_defaults: 'bool' = False,
+ exclude_none: 'bool' = False
+) -> 'Dict[str, Any]'
+
Args:
+ update: Values to change/add in the new model. Note: the data is not validated
+ before creating the new model. You should trust this data.
+ deep: Set to True to make a deep copy of the model.
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
Args:
+ mode: The mode in which to_python should run.
+ If mode is 'json', the output will only contain JSON serializable types.
+ If mode is 'python', the output may contain non-JSON-serializable Python objects.
+ include: A set of fields to include in the output.
+ exclude: A set of fields to exclude from the output.
+ context: Additional context to pass to the serializer.
+ by_alias: Whether to use the field's alias in the dictionary key if defined.
+ exclude_unset: Whether to exclude fields that have not been explicitly set.
+ exclude_defaults: Whether to exclude fields that are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A dictionary representation of the model.
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.
+ exclude: Field(s) to exclude from the JSON output.
+ context: Additional context to pass to the serializer.
+ 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 are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A JSON string representation of the model.
+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.
+
SupportedFilters
+
classSupportedFilters(
+ *args,
+ **kwds
+)
+
+
Create a collection of name/value pairs.
+
Example enumeration:
+
+
+
+
class Color(Enum):
+... RED = 1
+... BLUE = 2
+... GREEN = 3
+
+
+
+
Access them by:
+
+
attribute access::
+
+
+
+
+
Color.RED
+
+
+
+
+
+
value lookup:
+
+
+
+
+
Color(1)
+
+
+
+
+
+
name lookup:
+
+
+
+
+
Color['RED']
+
+
+
+
+
Enumerations can be iterated over, and know how many members they have:
+
+
+
+
len(Color)
+3
+
list(Color)
+[, , ]
+
+
+
+
Methods can be added to enumerations, and members can have their own
+attributes -- see the documentation for details.
Attributes:
+ class_vars: The names of the class variables defined on the model.
+ private_attributes: Metadata about the private attributes of the model.
+ signature: The synthesized __init__ [Signature][inspect.Signature] of the model.
+
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The core schema of the model.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+ This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+ __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a [`RootModel`][pydantic.root_model.RootModel].
+__pydantic_serializer__: The `pydantic-core` `SchemaSerializer` used to dump instances of the model.
+__pydantic_validator__: The `pydantic-core` `SchemaValidator` used to validate instances of the model.
+
+__pydantic_fields__: A dictionary of field names and their corresponding [`FieldInfo`][pydantic.fields.FieldInfo] objects.
+__pydantic_computed_fields__: A dictionary of computed field names and their corresponding [`ComputedFieldInfo`][pydantic.fields.ComputedFieldInfo] objects.
+
+__pydantic_extra__: A dictionary containing extra values, if [`extra`][pydantic.config.ConfigDict.extra]
+ is set to `'allow'`.
+__pydantic_fields_set__: The names of fields explicitly set during instantiation.
+__pydantic_private__: Values of private attributes set on the model instance.
+
+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.
+
!!! note
+ model_construct() generally respects the model_config.extra setting on the provided model.
+ That is, if model_config.extra == 'allow', then all extra passed values are added to the model instance's __dict__
+ and __pydantic_extra__ fields. If model_config.extra == 'ignore' (the default), then all extra passed values are ignored.
+ Because no validation is performed with a call to model_construct(), having model_config.extra == 'forbid' does not result in
+ an error if extra values are passed, but they will be ignored.
+
Args:
+ _fields_set: A set of field names that were originally explicitly set during instantiation. If provided,
+ this is directly used for the [model_fields_set][pydantic.BaseModel.model_fields_set] attribute.
+ Otherwise, the field names from the values argument will be used.
+ values: Trusted or pre-validated data dictionary.
+
Returns:
+ A new instance of the Model class with validated data.
Args:
+ by_alias: Whether to use attribute aliases or not.
+ ref_template: The reference template.
+ schema_generator: To override the logic used to generate the JSON schema, as a subclass of
+ GenerateJsonSchema with your desired modifications
+ mode: The mode in which to generate the schema.
+
Returns:
+ The JSON schema for the given model class.
+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.
+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.
Args:
+ obj: The object to validate.
+ strict: Whether to enforce types strictly.
+ 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.
+Validate the given object with string data against the Pydantic model.
+
Args:
+ obj: The object containing string data to validate.
+ strict: Whether to enforce types strictly.
+ context: Extra variables to pass to the validator.
Args:
+ include: Optional set or mapping specifying which fields to include in the copied model.
+ exclude: Optional set or mapping specifying which fields to exclude in the copied model.
+ update: Optional dictionary of field-value pairs to override field values in the copied model.
+ deep: If True, the values of fields that are Pydantic models will be deep-copied.
+
+Returns:
+ A copy of the model with included, excluded and updated fields as specified.
+
+
+#### dict
+
+```python3
+def dict(
+ self,
+ *,
+ include: 'IncEx | None' = None,
+ exclude: 'IncEx | None' = None,
+ by_alias: 'bool' = False,
+ exclude_unset: 'bool' = False,
+ exclude_defaults: 'bool' = False,
+ exclude_none: 'bool' = False
+) -> 'Dict[str, Any]'
+
Args:
+ update: Values to change/add in the new model. Note: the data is not validated
+ before creating the new model. You should trust this data.
+ deep: Set to True to make a deep copy of the model.
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
Args:
+ mode: The mode in which to_python should run.
+ If mode is 'json', the output will only contain JSON serializable types.
+ If mode is 'python', the output may contain non-JSON-serializable Python objects.
+ include: A set of fields to include in the output.
+ exclude: A set of fields to exclude from the output.
+ context: Additional context to pass to the serializer.
+ by_alias: Whether to use the field's alias in the dictionary key if defined.
+ exclude_unset: Whether to exclude fields that have not been explicitly set.
+ exclude_defaults: Whether to exclude fields that are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A dictionary representation of the model.
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.
+ exclude: Field(s) to exclude from the JSON output.
+ context: Additional context to pass to the serializer.
+ 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 are set to their default value.
+ exclude_none: Whether to exclude fields that have a value of None.
+ round_trip: If True, dumped values should be valid as input for non-idempotent types such as Json[T].
+ warnings: How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors,
+ "error" raises a [PydanticSerializationError][pydantic_core.PydanticSerializationError].
+ serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
+
Returns:
+ A JSON string representation of the model.
+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.
+
+
+
+
+
+
+
+
\n )\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { h } from \"~/utilities\"\n\nimport { renderTooltip } from \"../tooltip\"\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Render an annotation\n *\n * @param id - Annotation identifier\n * @param prefix - Tooltip identifier prefix\n *\n * @returns Element\n */\nexport function renderAnnotation(\n id: string | number, prefix?: string\n): HTMLElement {\n prefix = prefix ? `${prefix}_annotation_${id}` : undefined\n\n /* Render tooltip with anchor, if given */\n if (prefix) {\n const anchor = prefix ? `#${prefix}` : undefined\n return (\n \n )\n } else {\n return (\n \n )\n }\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { translation } from \"~/_\"\nimport { h } from \"~/utilities\"\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Render a 'copy-to-clipboard' button\n *\n * @param id - Unique identifier\n *\n * @returns Element\n */\nexport function renderClipboardButton(id: string): HTMLElement {\n return (\n code`}\n >\n )\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { ComponentChild } from \"preact\"\n\nimport { configuration, feature, translation } from \"~/_\"\nimport {\n SearchDocument,\n SearchMetadata,\n SearchResultItem\n} from \"~/integrations/search\"\nimport { h, truncate } from \"~/utilities\"\n\n/* ----------------------------------------------------------------------------\n * Helper types\n * ------------------------------------------------------------------------- */\n\n/**\n * Render flag\n */\nconst enum Flag {\n TEASER = 1, /* Render teaser */\n PARENT = 2 /* Render as parent */\n}\n\n/* ----------------------------------------------------------------------------\n * Helper function\n * ------------------------------------------------------------------------- */\n\n/**\n * Render a search document\n *\n * @param document - Search document\n * @param flag - Render flags\n *\n * @returns Element\n */\nfunction renderSearchDocument(\n document: SearchDocument & SearchMetadata, flag: Flag\n): HTMLElement {\n const parent = flag & Flag.PARENT\n const teaser = flag & Flag.TEASER\n\n /* Render missing query terms */\n const missing = Object.keys(document.terms)\n .filter(key => !document.terms[key])\n .reduce((list, key) => [\n ...list, {key}, \" \"\n ], [])\n .slice(0, -1)\n\n /* Assemble query string for highlighting */\n const url = new URL(document.location)\n if (feature(\"search.highlight\"))\n url.searchParams.set(\"h\", Object.entries(document.terms)\n .filter(([, match]) => match)\n .reduce((highlight, [value]) => `${highlight} ${value}`.trim(), \"\")\n )\n\n /* Render article or section, depending on flags */\n const { tags } = configuration()\n return (\n \n \n {parent > 0 && }\n
\n }\n \n \n )\n}\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Render a search result\n *\n * @param result - Search result\n *\n * @returns Element\n */\nexport function renderSearchResultItem(\n result: SearchResultItem\n): HTMLElement {\n const threshold = result[0].score\n const docs = [...result]\n\n /* Find and extract parent article */\n const parent = docs.findIndex(doc => !doc.location.includes(\"#\"))\n const [article] = docs.splice(parent, 1)\n\n /* Determine last index above threshold */\n let index = docs.findIndex(doc => doc.score < threshold)\n if (index === -1)\n index = docs.length\n\n /* Partition sections */\n const best = docs.slice(0, index)\n const more = docs.slice(index)\n\n /* Render children */\n const children = [\n renderSearchDocument(article, Flag.PARENT | +(!parent && index === 0)),\n ...best.map(section => renderSearchDocument(section, Flag.TEASER)),\n ...more.length ? [\n \n \n {more.length > 0 && more.length === 1\n ? translation(\"search.result.more.one\")\n : translation(\"search.result.more.other\", more.length)\n }\n \n {...more.map(section => renderSearchDocument(section, Flag.TEASER))}\n \n ] : []\n ]\n\n /* Render search result */\n return (\n
\n {children}\n
\n )\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { SourceFacts } from \"~/components\"\nimport { h, round } from \"~/utilities\"\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Render repository facts\n *\n * @param facts - Repository facts\n *\n * @returns Element\n */\nexport function renderSourceFacts(facts: SourceFacts): HTMLElement {\n return (\n
\n {typeof value === \"number\" ? round(value) : value}\n
\n ))}\n
\n )\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { h } from \"~/utilities\"\n\n/* ----------------------------------------------------------------------------\n * Helper types\n * ------------------------------------------------------------------------- */\n\n/**\n * Tabbed control type\n */\ntype TabbedControlType =\n | \"prev\"\n | \"next\"\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Render control for content tabs\n *\n * @param type - Control type\n *\n * @returns Element\n */\nexport function renderTabbedControl(\n type: TabbedControlType\n): HTMLElement {\n const classes = `tabbed-control tabbed-control--${type}`\n return (\n
\n \n
\n )\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { h } from \"~/utilities\"\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Render a table inside a wrapper to improve scrolling on mobile\n *\n * @param table - Table element\n *\n * @returns Element\n */\nexport function renderTable(table: HTMLElement): HTMLElement {\n return (\n
\n
\n {table}\n
\n
\n )\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { configuration, translation } from \"~/_\"\nimport { h } from \"~/utilities\"\n\n/* ----------------------------------------------------------------------------\n * Types\n * ------------------------------------------------------------------------- */\n\n/**\n * Version\n */\nexport interface Version {\n version: string /* Version identifier */\n title: string /* Version title */\n aliases: string[] /* Version aliases */\n}\n\n/* ----------------------------------------------------------------------------\n * Helper functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Render a version\n *\n * @param version - Version\n *\n * @returns Element\n */\nfunction renderVersion(version: Version): HTMLElement {\n const config = configuration()\n\n /* Ensure trailing slash - see https://bit.ly/3rL5u3f */\n const url = new URL(`../${version.version}/`, config.base)\n return (\n
\n )\n}\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Render a version selector\n *\n * @param versions - Versions\n * @param active - Active version\n *\n * @returns Element\n */\nexport function renderVersionSelector(\n versions: Version[], active: Version\n): HTMLElement {\n return (\n
\n \n {active.title}\n \n
\n {versions.map(renderVersion)}\n
\n
\n )\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport {\n Observable,\n Subject,\n animationFrameScheduler,\n auditTime,\n combineLatest,\n debounceTime,\n defer,\n delay,\n filter,\n finalize,\n fromEvent,\n map,\n merge,\n switchMap,\n take,\n takeLast,\n takeUntil,\n tap,\n throttleTime,\n withLatestFrom\n} from \"rxjs\"\n\nimport {\n ElementOffset,\n getActiveElement,\n getElementSize,\n watchElementContentOffset,\n watchElementFocus,\n watchElementOffset,\n watchElementVisibility\n} from \"~/browser\"\n\nimport { Component } from \"../../../_\"\n\n/* ----------------------------------------------------------------------------\n * Types\n * ------------------------------------------------------------------------- */\n\n/**\n * Annotation\n */\nexport interface Annotation {\n active: boolean /* Annotation is active */\n offset: ElementOffset /* Annotation offset */\n}\n\n/* ----------------------------------------------------------------------------\n * Helper types\n * ------------------------------------------------------------------------- */\n\n/**\n * Mount options\n */\ninterface MountOptions {\n target$: Observable /* Location target observable */\n}\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Watch annotation\n *\n * @param el - Annotation element\n * @param container - Containing element\n *\n * @returns Annotation observable\n */\nexport function watchAnnotation(\n el: HTMLElement, container: HTMLElement\n): Observable {\n const offset$ = defer(() => combineLatest([\n watchElementOffset(el),\n watchElementContentOffset(container)\n ]))\n .pipe(\n map(([{ x, y }, scroll]): ElementOffset => {\n const { width, height } = getElementSize(el)\n return ({\n x: x - scroll.x + width / 2,\n y: y - scroll.y + height / 2\n })\n })\n )\n\n /* Actively watch annotation on focus */\n return watchElementFocus(el)\n .pipe(\n switchMap(active => offset$\n .pipe(\n map(offset => ({ active, offset })),\n take(+!active || Infinity)\n )\n )\n )\n}\n\n/**\n * Mount annotation\n *\n * @param el - Annotation element\n * @param container - Containing element\n * @param options - Options\n *\n * @returns Annotation component observable\n */\nexport function mountAnnotation(\n el: HTMLElement, container: HTMLElement, { target$ }: MountOptions\n): Observable> {\n const [tooltip, index] = Array.from(el.children)\n\n /* Mount component on subscription */\n return defer(() => {\n const push$ = new Subject()\n const done$ = push$.pipe(takeLast(1))\n push$.subscribe({\n\n /* Handle emission */\n next({ offset }) {\n el.style.setProperty(\"--md-tooltip-x\", `${offset.x}px`)\n el.style.setProperty(\"--md-tooltip-y\", `${offset.y}px`)\n },\n\n /* Handle complete */\n complete() {\n el.style.removeProperty(\"--md-tooltip-x\")\n el.style.removeProperty(\"--md-tooltip-y\")\n }\n })\n\n /* Start animation only when annotation is visible */\n watchElementVisibility(el)\n .pipe(\n takeUntil(done$)\n )\n .subscribe(visible => {\n el.toggleAttribute(\"data-md-visible\", visible)\n })\n\n /* Toggle tooltip presence to mitigate empty lines when copying */\n merge(\n push$.pipe(filter(({ active }) => active)),\n push$.pipe(debounceTime(250), filter(({ active }) => !active))\n )\n .subscribe({\n\n /* Handle emission */\n next({ active }) {\n if (active)\n el.prepend(tooltip)\n else\n tooltip.remove()\n },\n\n /* Handle complete */\n complete() {\n el.prepend(tooltip)\n }\n })\n\n /* Toggle tooltip visibility */\n push$\n .pipe(\n auditTime(16, animationFrameScheduler)\n )\n .subscribe(({ active }) => {\n tooltip.classList.toggle(\"md-tooltip--active\", active)\n })\n\n /* Track relative origin of tooltip */\n push$\n .pipe(\n throttleTime(125, animationFrameScheduler),\n filter(() => !!el.offsetParent),\n map(() => el.offsetParent!.getBoundingClientRect()),\n map(({ x }) => x)\n )\n .subscribe({\n\n /* Handle emission */\n next(origin) {\n if (origin)\n el.style.setProperty(\"--md-tooltip-0\", `${-origin}px`)\n else\n el.style.removeProperty(\"--md-tooltip-0\")\n },\n\n /* Handle complete */\n complete() {\n el.style.removeProperty(\"--md-tooltip-0\")\n }\n })\n\n /* Allow to copy link without scrolling to anchor */\n fromEvent(index, \"click\")\n .pipe(\n takeUntil(done$),\n filter(ev => !(ev.metaKey || ev.ctrlKey))\n )\n .subscribe(ev => ev.preventDefault())\n\n /* Allow to open link in new tab or blur on close */\n fromEvent(index, \"mousedown\")\n .pipe(\n takeUntil(done$),\n withLatestFrom(push$)\n )\n .subscribe(([ev, { active }]) => {\n\n /* Open in new tab */\n if (ev.button !== 0 || ev.metaKey || ev.ctrlKey) {\n ev.preventDefault()\n\n /* Close annotation */\n } else if (active) {\n ev.preventDefault()\n\n /* Focus parent annotation, if any */\n const parent = el.parentElement!.closest(\".md-annotation\")\n if (parent instanceof HTMLElement)\n parent.focus()\n else\n getActiveElement()?.blur()\n }\n })\n\n /* Open and focus annotation on location target */\n target$\n .pipe(\n takeUntil(done$),\n filter(target => target === tooltip),\n delay(125)\n )\n .subscribe(() => el.focus())\n\n /* Create and return component */\n return watchAnnotation(el, container)\n .pipe(\n tap(state => push$.next(state)),\n finalize(() => push$.complete()),\n map(state => ({ ref: el, ...state }))\n )\n })\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport {\n EMPTY,\n Observable,\n Subject,\n defer,\n finalize,\n merge,\n share,\n takeLast,\n takeUntil\n} from \"rxjs\"\n\nimport {\n getElement,\n getElements,\n getOptionalElement\n} from \"~/browser\"\nimport { renderAnnotation } from \"~/templates\"\n\nimport { Component } from \"../../../_\"\nimport {\n Annotation,\n mountAnnotation\n} from \"../_\"\n\n/* ----------------------------------------------------------------------------\n * Helper types\n * ------------------------------------------------------------------------- */\n\n/**\n * Mount options\n */\ninterface MountOptions {\n target$: Observable /* Location target observable */\n print$: Observable /* Media print observable */\n}\n\n/* ----------------------------------------------------------------------------\n * Helper functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Find all annotation markers in the given code block\n *\n * @param container - Containing element\n *\n * @returns Annotation markers\n */\nfunction findAnnotationMarkers(container: HTMLElement): Text[] {\n const markers: Text[] = []\n for (const el of getElements(\".c, .c1, .cm\", container)) {\n const nodes: Text[] = []\n\n /* Find all text nodes in current element */\n const it = document.createNodeIterator(el, NodeFilter.SHOW_TEXT)\n for (let node = it.nextNode(); node; node = it.nextNode())\n nodes.push(node as Text)\n\n /* Find all markers in each text node */\n for (let text of nodes) {\n let match: RegExpExecArray | null\n\n /* Split text at marker and add to list */\n while ((match = /(\\(\\d+\\))(!)?/.exec(text.textContent!))) {\n const [, id, force] = match\n if (typeof force === \"undefined\") {\n const marker = text.splitText(match.index)\n text = marker.splitText(id.length)\n markers.push(marker)\n\n /* Replace entire text with marker */\n } else {\n text.textContent = id\n markers.push(text)\n break\n }\n }\n }\n }\n return markers\n}\n\n/**\n * Swap the child nodes of two elements\n *\n * @param source - Source element\n * @param target - Target element\n */\nfunction swap(source: HTMLElement, target: HTMLElement): void {\n target.append(...Array.from(source.childNodes))\n}\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Mount annotation list\n *\n * This function analyzes the containing code block and checks for markers\n * referring to elements in the given annotation list. If no markers are found,\n * the list is left untouched. Otherwise, list elements are rendered as\n * annotations inside the code block.\n *\n * @param el - Annotation list element\n * @param container - Containing element\n * @param options - Options\n *\n * @returns Annotation component observable\n */\nexport function mountAnnotationList(\n el: HTMLElement, container: HTMLElement, { target$, print$ }: MountOptions\n): Observable> {\n\n /* Compute prefix for tooltip anchors */\n const parent = container.closest(\"[id]\")\n const prefix = parent?.id\n\n /* Find and replace all markers with empty annotations */\n const annotations = new Map()\n for (const marker of findAnnotationMarkers(container)) {\n const [, id] = marker.textContent!.match(/\\((\\d+)\\)/)!\n if (getOptionalElement(`li:nth-child(${id})`, el)) {\n annotations.set(id, renderAnnotation(id, prefix))\n marker.replaceWith(annotations.get(id)!)\n }\n }\n\n /* Keep list if there are no annotations to render */\n if (annotations.size === 0)\n return EMPTY\n\n /* Mount component on subscription */\n return defer(() => {\n const done$ = new Subject()\n\n /* Retrieve container pairs for swapping */\n const pairs: [HTMLElement, HTMLElement][] = []\n for (const [id, annotation] of annotations)\n pairs.push([\n getElement(\".md-typeset\", annotation),\n getElement(`li:nth-child(${id})`, el)\n ])\n\n /* Handle print mode - see https://bit.ly/3rgPdpt */\n print$\n .pipe(\n takeUntil(done$.pipe(takeLast(1)))\n )\n .subscribe(active => {\n el.hidden = !active\n\n /* Show annotations in code block or list (print) */\n for (const [inner, child] of pairs)\n if (!active)\n swap(child, inner)\n else\n swap(inner, child)\n })\n\n /* Create and return component */\n return merge(...[...annotations]\n .map(([, annotation]) => (\n mountAnnotation(annotation, container, { target$ })\n ))\n )\n .pipe(\n finalize(() => done$.complete()),\n share()\n )\n })\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport {\n Observable,\n map,\n of,\n shareReplay,\n tap\n} from \"rxjs\"\n\nimport { watchScript } from \"~/browser\"\nimport { h } from \"~/utilities\"\n\nimport { Component } from \"../../../_\"\n\nimport themeCSS from \"./index.css\"\n\n/* ----------------------------------------------------------------------------\n * Types\n * ------------------------------------------------------------------------- */\n\n/**\n * Mermaid diagram\n */\nexport interface Mermaid {}\n\n/* ----------------------------------------------------------------------------\n * Data\n * ------------------------------------------------------------------------- */\n\n/**\n * Mermaid instance observable\n */\nlet mermaid$: Observable\n\n/**\n * Global sequence number for diagrams\n */\nlet sequence = 0\n\n/* ----------------------------------------------------------------------------\n * Helper functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Fetch Mermaid script\n *\n * @returns Mermaid scripts observable\n */\nfunction fetchScripts(): Observable {\n return typeof mermaid === \"undefined\" || mermaid instanceof Element\n ? watchScript(\"https://unpkg.com/mermaid@9.1.7/dist/mermaid.min.js\")\n : of(undefined)\n}\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Mount Mermaid diagram\n *\n * @param el - Code block element\n *\n * @returns Mermaid diagram component observable\n */\nexport function mountMermaid(\n el: HTMLElement\n): Observable> {\n el.classList.remove(\"mermaid\") // Hack: mitigate https://bit.ly/3CiN6Du\n mermaid$ ||= fetchScripts()\n .pipe(\n tap(() => mermaid.initialize({\n startOnLoad: false,\n themeCSS,\n sequence: {\n actorFontSize: \"16px\", // Hack: mitigate https://bit.ly/3y0NEi3\n messageFontSize: \"16px\",\n noteFontSize: \"16px\"\n }\n })),\n map(() => undefined),\n shareReplay(1)\n )\n\n /* Render diagram */\n mermaid$.subscribe(() => {\n el.classList.add(\"mermaid\") // Hack: mitigate https://bit.ly/3CiN6Du\n const id = `__mermaid_${sequence++}`\n const host = h(\"div\", { class: \"mermaid\" })\n mermaid.mermaidAPI.render(id, el.textContent, (svg: string) => {\n\n /* Create a shadow root and inject diagram */\n const shadow = host.attachShadow({ mode: \"closed\" })\n shadow.innerHTML = svg\n\n /* Replace code block with diagram */\n el.replaceWith(host)\n })\n })\n\n /* Create and return component */\n return mermaid$\n .pipe(\n map(() => ({ ref: el }))\n )\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport {\n Observable,\n Subject,\n defer,\n filter,\n finalize,\n map,\n merge,\n tap\n} from \"rxjs\"\n\nimport { Component } from \"../../_\"\n\n/* ----------------------------------------------------------------------------\n * Types\n * ------------------------------------------------------------------------- */\n\n/**\n * Details\n */\nexport interface Details {\n action: \"open\" | \"close\" /* Details state */\n reveal?: boolean /* Details is revealed */\n}\n\n/* ----------------------------------------------------------------------------\n * Helper types\n * ------------------------------------------------------------------------- */\n\n/**\n * Watch options\n */\ninterface WatchOptions {\n target$: Observable /* Location target observable */\n print$: Observable /* Media print observable */\n}\n\n/**\n * Mount options\n */\ninterface MountOptions {\n target$: Observable /* Location target observable */\n print$: Observable /* Media print observable */\n}\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Watch details\n *\n * @param el - Details element\n * @param options - Options\n *\n * @returns Details observable\n */\nexport function watchDetails(\n el: HTMLDetailsElement, { target$, print$ }: WatchOptions\n): Observable {\n let open = true\n return merge(\n\n /* Open and focus details on location target */\n target$\n .pipe(\n map(target => target.closest(\"details:not([open])\")!),\n filter(details => el === details),\n map(() => ({\n action: \"open\", reveal: true\n }) as Details)\n ),\n\n /* Open details on print and close afterwards */\n print$\n .pipe(\n filter(active => active || !open),\n tap(() => open = el.open),\n map(active => ({\n action: active ? \"open\" : \"close\"\n }) as Details)\n )\n )\n}\n\n/**\n * Mount details\n *\n * This function ensures that `details` tags are opened on anchor jumps and\n * prior to printing, so the whole content of the page is visible.\n *\n * @param el - Details element\n * @param options - Options\n *\n * @returns Details component observable\n */\nexport function mountDetails(\n el: HTMLDetailsElement, options: MountOptions\n): Observable> {\n return defer(() => {\n const push$ = new Subject()\n push$.subscribe(({ action, reveal }) => {\n el.toggleAttribute(\"open\", action === \"open\")\n if (reveal)\n el.scrollIntoView()\n })\n\n /* Create and return component */\n return watchDetails(el, options)\n .pipe(\n tap(state => push$.next(state)),\n finalize(() => push$.complete()),\n map(state => ({ ref: el, ...state }))\n )\n })\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { Observable, of } from \"rxjs\"\n\nimport { renderTable } from \"~/templates\"\nimport { h } from \"~/utilities\"\n\nimport { Component } from \"../../_\"\n\n/* ----------------------------------------------------------------------------\n * Types\n * ------------------------------------------------------------------------- */\n\n/**\n * Data table\n */\nexport interface DataTable {}\n\n/* ----------------------------------------------------------------------------\n * Data\n * ------------------------------------------------------------------------- */\n\n/**\n * Sentinel for replacement\n */\nconst sentinel = h(\"table\")\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Mount data table\n *\n * This function wraps a data table in another scrollable container, so it can\n * be smoothly scrolled on smaller screen sizes and won't break the layout.\n *\n * @param el - Data table element\n *\n * @returns Data table component observable\n */\nexport function mountDataTable(\n el: HTMLElement\n): Observable> {\n el.replaceWith(sentinel)\n sentinel.replaceWith(renderTable(el))\n\n /* Create and return component */\n return of({ ref: el })\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport {\n Observable,\n Subject,\n animationFrameScheduler,\n asyncScheduler,\n auditTime,\n combineLatest,\n defer,\n finalize,\n fromEvent,\n map,\n merge,\n skip,\n startWith,\n subscribeOn,\n takeLast,\n takeUntil,\n tap,\n withLatestFrom\n} from \"rxjs\"\n\nimport { feature } from \"~/_\"\nimport {\n Viewport,\n getElement,\n getElementContentOffset,\n getElementContentSize,\n getElementOffset,\n getElementSize,\n getElements,\n watchElementContentOffset,\n watchElementSize\n} from \"~/browser\"\nimport { renderTabbedControl } from \"~/templates\"\n\nimport { Component } from \"../../_\"\n\n/* ----------------------------------------------------------------------------\n * Types\n * ------------------------------------------------------------------------- */\n\n/**\n * Content tabs\n */\nexport interface ContentTabs {\n active: HTMLLabelElement /* Active tab label */\n}\n\n/* ----------------------------------------------------------------------------\n * Helper types\n * ------------------------------------------------------------------------- */\n\n/**\n * Mount options\n */\ninterface MountOptions {\n viewport$: Observable /* Viewport observable */\n}\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Watch content tabs\n *\n * @param el - Content tabs element\n *\n * @returns Content tabs observable\n */\nexport function watchContentTabs(\n el: HTMLElement\n): Observable {\n const inputs = getElements(\":scope > input\", el)\n const initial = inputs.find(input => input.checked) || inputs[0]\n return merge(...inputs.map(input => fromEvent(input, \"change\")\n .pipe(\n map(() => getElement(`label[for=\"${input.id}\"]`))\n )\n ))\n .pipe(\n startWith(getElement(`label[for=\"${initial.id}\"]`)),\n map(active => ({ active }))\n )\n}\n\n/**\n * Mount content tabs\n *\n * This function scrolls the active tab into view. While this functionality is\n * provided by browsers as part of `scrollInfoView`, browsers will always also\n * scroll the vertical axis, which we do not want. Thus, we decided to provide\n * this functionality ourselves.\n *\n * @param el - Content tabs element\n * @param options - Options\n *\n * @returns Content tabs component observable\n */\nexport function mountContentTabs(\n el: HTMLElement, { viewport$ }: MountOptions\n): Observable> {\n\n /* Render content tab previous button for pagination */\n const prev = renderTabbedControl(\"prev\")\n el.append(prev)\n\n /* Render content tab next button for pagination */\n const next = renderTabbedControl(\"next\")\n el.append(next)\n\n /* Mount component on subscription */\n const container = getElement(\".tabbed-labels\", el)\n return defer(() => {\n const push$ = new Subject()\n const done$ = push$.pipe(takeLast(1))\n combineLatest([push$, watchElementSize(el)])\n .pipe(\n auditTime(1, animationFrameScheduler),\n takeUntil(done$)\n )\n .subscribe({\n\n /* Handle emission */\n next([{ active }, size]) {\n const offset = getElementOffset(active)\n const { width } = getElementSize(active)\n\n /* Set tab indicator offset and width */\n el.style.setProperty(\"--md-indicator-x\", `${offset.x}px`)\n el.style.setProperty(\"--md-indicator-width\", `${width}px`)\n\n /* Scroll container to active content tab */\n const content = getElementContentOffset(container)\n if (\n offset.x < content.x ||\n offset.x + width > content.x + size.width\n )\n container.scrollTo({\n left: Math.max(0, offset.x - 16),\n behavior: \"smooth\"\n })\n },\n\n /* Handle complete */\n complete() {\n el.style.removeProperty(\"--md-indicator-x\")\n el.style.removeProperty(\"--md-indicator-width\")\n }\n })\n\n /* Hide content tab buttons on borders */\n combineLatest([\n watchElementContentOffset(container),\n watchElementSize(container)\n ])\n .pipe(\n takeUntil(done$)\n )\n .subscribe(([offset, size]) => {\n const content = getElementContentSize(container)\n prev.hidden = offset.x < 16\n next.hidden = offset.x > content.width - size.width - 16\n })\n\n /* Paginate content tab container on click */\n merge(\n fromEvent(prev, \"click\").pipe(map(() => -1)),\n fromEvent(next, \"click\").pipe(map(() => +1))\n )\n .pipe(\n takeUntil(done$)\n )\n .subscribe(direction => {\n const { width } = getElementSize(container)\n container.scrollBy({\n left: width * direction,\n behavior: \"smooth\"\n })\n })\n\n /* Set up linking of content tabs, if enabled */\n if (feature(\"content.tabs.link\"))\n push$.pipe(\n skip(1),\n withLatestFrom(viewport$)\n )\n .subscribe(([{ active }, { offset }]) => {\n const tab = active.innerText.trim()\n if (active.hasAttribute(\"data-md-switching\")) {\n active.removeAttribute(\"data-md-switching\")\n\n /* Determine viewport offset of active tab */\n } else {\n const y = el.offsetTop - offset.y\n\n /* Passively activate other tabs */\n for (const set of getElements(\"[data-tabs]\"))\n for (const input of getElements(\n \":scope > input\", set\n )) {\n const label = getElement(`label[for=\"${input.id}\"]`)\n if (\n label !== active &&\n label.innerText.trim() === tab\n ) {\n label.setAttribute(\"data-md-switching\", \"\")\n input.click()\n break\n }\n }\n\n /* Bring active tab into view */\n window.scrollTo({\n top: el.offsetTop - y\n })\n\n /* Persist active tabs in local storage */\n const tabs = __md_get(\"__tabs\") || []\n __md_set(\"__tabs\", [...new Set([tab, ...tabs])])\n }\n })\n\n /* Create and return component */\n return watchContentTabs(el)\n .pipe(\n tap(state => push$.next(state)),\n finalize(() => push$.complete()),\n map(state => ({ ref: el, ...state }))\n )\n })\n .pipe(\n subscribeOn(asyncScheduler)\n )\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport { Observable, merge } from \"rxjs\"\n\nimport { Viewport, getElements } from \"~/browser\"\n\nimport { Component } from \"../../_\"\nimport { Annotation } from \"../annotation\"\nimport {\n CodeBlock,\n Mermaid,\n mountCodeBlock,\n mountMermaid\n} from \"../code\"\nimport {\n Details,\n mountDetails\n} from \"../details\"\nimport {\n DataTable,\n mountDataTable\n} from \"../table\"\nimport {\n ContentTabs,\n mountContentTabs\n} from \"../tabs\"\n\n/* ----------------------------------------------------------------------------\n * Types\n * ------------------------------------------------------------------------- */\n\n/**\n * Content\n */\nexport type Content =\n | Annotation\n | ContentTabs\n | CodeBlock\n | Mermaid\n | DataTable\n | Details\n\n/* ----------------------------------------------------------------------------\n * Helper types\n * ------------------------------------------------------------------------- */\n\n/**\n * Mount options\n */\ninterface MountOptions {\n viewport$: Observable /* Viewport observable */\n target$: Observable /* Location target observable */\n print$: Observable /* Media print observable */\n}\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Mount content\n *\n * This function mounts all components that are found in the content of the\n * actual article, including code blocks, data tables and details.\n *\n * @param el - Content element\n * @param options - Options\n *\n * @returns Content component observable\n */\nexport function mountContent(\n el: HTMLElement, { viewport$, target$, print$ }: MountOptions\n): Observable> {\n return merge(\n\n /* Code blocks */\n ...getElements(\"pre:not(.mermaid) > code\", el)\n .map(child => mountCodeBlock(child, { target$, print$ })),\n\n /* Mermaid diagrams */\n ...getElements(\"pre.mermaid\", el)\n .map(child => mountMermaid(child)),\n\n /* Data tables */\n ...getElements(\"table:not([class])\", el)\n .map(child => mountDataTable(child)),\n\n /* Details */\n ...getElements(\"details\", el)\n .map(child => mountDetails(child, { target$, print$ })),\n\n /* Content tabs */\n ...getElements(\"[data-tabs]\", el)\n .map(child => mountContentTabs(child, { viewport$ }))\n )\n}\n", "/*\n * Copyright (c) 2016-2022 Martin Donath \n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n\nimport {\n Observable,\n Subject,\n defer,\n delay,\n finalize,\n map,\n merge,\n of,\n switchMap,\n tap\n} from \"rxjs\"\n\nimport { getElement } from \"~/browser\"\n\nimport { Component } from \"../_\"\n\n/* ----------------------------------------------------------------------------\n * Types\n * ------------------------------------------------------------------------- */\n\n/**\n * Dialog\n */\nexport interface Dialog {\n message: string /* Dialog message */\n active: boolean /* Dialog is active */\n}\n\n/* ----------------------------------------------------------------------------\n * Helper types\n * ------------------------------------------------------------------------- */\n\n/**\n * Watch options\n */\ninterface WatchOptions {\n alert$: Subject /* Alert subject */\n}\n\n/**\n * Mount options\n */\ninterface MountOptions {\n alert$: Subject /* Alert subject */\n}\n\n/* ----------------------------------------------------------------------------\n * Functions\n * ------------------------------------------------------------------------- */\n\n/**\n * Watch dialog\n *\n * @param _el - Dialog element\n * @param options - Options\n *\n * @returns Dialog observable\n */\nexport function watchDialog(\n _el: HTMLElement, { alert$ }: WatchOptions\n): Observable