spacy API Reference
Full documentation for spacy (3.8.14)
spacy.Any
Python Library Documentation: class Any in module typing class Any(builtins.object) | Any(*args, **kwargs) | | Special type indicating an unconstrained type. | | - Any is compatible with every type. | - Any assumed to have all methods. | - All values assumed to be instances of Any. | | Note that all the above statements are true from the point of view of | static type checkers. At runtime, Any should not be used with instance | checks. | | Static methods defined here: | | __new__(cls, *args, **kwargs) | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | __dict__ | dictionary for instance variables | | __weakref__ | list of weak references to the object
spacy.Config
Python Library Documentation: class Config in module confection._config
class Config(builtins.dict)
| Config(data: "Optional[Union[Dict[str, Any], 'Config']]" = None, *, is_interpolated: 'Optional[bool]' = None, section_order: 'Optional[List[str]]' = None) -> 'None'
|
| Dict subclass to save TOML-style configuration format from/to string, file
| or bytes.
|
| Method resolution order:
| Config
| builtins.dict
| builtins.object
|
| Methods defined here:
|
| __init__(self, data: "Optional[Union[Dict[str, Any], 'Config']]" = None, *, is_interpolated: 'Optional[bool]' = None, section_order: 'Optional[List[str]]' = None) -> 'None'
| Initialize a new Config object with optional data.
|
| copy(self) -> 'Self'
| Deepcopy the config.
|
| fill_defaults(self, schema) -> 'Self'
| Fill in missing values from schema defaults and remove extra
| fields if the schema forbids them. Modifies in place and returns self.
|
| from_bytes(self, bytes_data: 'bytes', *, interpolate: 'bool' = True, overrides: 'Dict[str, Any]' = {}) -> 'Self'
| Load the config from a byte string.
|
| from_disk(self, path: 'Union[str, Path]', *, interpolate: 'bool' = True, overrides: 'Dict[str, Any]' = {}) -> 'Self'
| Load config from a file.
|
| from_str(self, text: 'str', *, interpolate: 'bool' = True, overrides: 'Dict[str, Any]' = {}, schema=None) -> 'Self'
| Load the config from a string.
|
| interpolate(self) -> 'Self'
| Interpolate (resolve var references) a config.
|
| Returns a copy of the object.
|
| merge(self, updates: "Union[Dict[str, Any], 'Config']", remove_extra: 'bool' = False) -> 'Self'
| Deep merge the config with updates, using current as defaults.
|
| to_bytes(self, *, interpolate: 'bool' = True) -> 'bytes'
| Serialize the config to a byte string.
|
| to_disk(self, path: 'Union[str, Path]', *, interpolate: 'bool' = True) -> 'None'
| Serialize the config to a file.
|
| to_str(self, *, interpolate: 'bool' = True) -> 'str'
| Write the config to a string.
|
| validate(self, schema) -> 'Self'
| Validate the config against a schema. Raises ConfigValidationError
| if validation fails.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'is_interpolated': 'bool'}
|
| __slotnames__ = []
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.dict:
|
| __contains__(self, key, /)
| True if the dictionary has the specified key, else False.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __ior__(self, value, /)
| Return self|=value.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __or__(self, value, /)
| Return self|value.
|
| __repr__(self, /)
| Return repr(self).
|
| __reversed__(self, /)
| Return a reverse iterator over the dict keys.
|
| __ror__(self, value, /)
| Return value|self.
|
| __setitem__(self, key, value, /)
| Set self[key] to value.
|
| __sizeof__(...)
| D.__sizeof__() -> size of D in memory, in bytes
|
| clear(...)
| D.clear() -> None. Remove all items from D.
|
| get(self, key, default=None, /)
| Return the value for key if key is in the dictionary, else default.
|
| items(...)
| D.items() -> a set-like object providing a view on D's items
|
| keys(...)
| D.keys() -> a set-like object providing a view on D's keys
|
| pop(...)
| D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
|
| If the key is not found, return the default if given; otherwise,
| raise a KeyError.
|
| popitem(self, /)
| Remove and return a (key, value) pair as a 2-tuple.
|
| Pairs are returned in LIFO (last-in, first-out) order.
| Raises KeyError if the dict is empty.
|
| setdefault(self, key, default=None, /)
| Insert key with a value of default if key is not in the dictionary.
|
| Return the value for key if key is in the dictionary, else default.
|
| update(...)
| D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
| If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
| If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
| In either case, this is followed by: for k in F: D[k] = F[k]
|
| values(...)
| D.values() -> an object providing a view on D's values
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.dict:
|
| __class_getitem__(...)
| See PEP 585
|
| fromkeys(iterable, value=None, /)
| Create a new dictionary with keys from iterable and values set to value.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.dict:
|
| __new__(*args, **kwargs) class method of builtins.dict
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from builtins.dict:
|
| __hash__ = None
spacy.ConfigSchema
Python Library Documentation: class ConfigSchema in module spacy.schemas
class ConfigSchema(pydantic.main.BaseModel)
| ConfigSchema(*, training: spacy.schemas.ConfigSchemaTraining, nlp: spacy.schemas.ConfigSchemaNlp, pretraining: Union[spacy.schemas.ConfigSchemaPretrain, spacy.schemas.ConfigSchemaPretrainEmpty] = {}, components: Dict[str, Dict[str, Any]], corpora: Dict[str, Union[Callable[[spacy.language.Language, str], Iterable[spacy.training.example.Example]], confection._registry.Promise]], initialize: spacy.schemas.ConfigSchemaInit, **extra_data: Any) -> None
|
| Method resolution order:
| ConfigSchema
| pydantic.main.BaseModel
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'components': typing.Dict[str, typing.Dict[str, typ...
|
| __class_vars__ = set()
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'definitions': [{'cls': <class 'confection...
|
| __pydantic_custom_init__ = False
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {'components': FieldInfo(annotation=Dict[str, Di...
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = None
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="ConfigSchema", validat...
|
| __signature__ = <Signature (*, training: spacy.schemas.ConfigSch...mas...
|
| model_config = {'arbitrary_types_allowed': True, 'extra': 'allow'}
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __init__(self, /, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_args__(self) -> '_repr.ReprArgs'
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| 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(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]'
|
| json(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, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| 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.
|
| Returns:
| New model instance.
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| 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.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| from_orm(obj: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| 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.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| 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.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| 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.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_obj(obj: 'Any') -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {'components': FieldInfo(annotation=Dict[str, Dict[str,...
spacy.ConfigSchemaInit
Python Library Documentation: class ConfigSchemaInit in module spacy.schemas
class ConfigSchemaInit(pydantic.main.BaseModel)
| ConfigSchemaInit(*, vocab_data: Optional[Annotated[str, Strict(strict=True)]], lookups: Optional[spacy.lookups.Lookups], vectors: Optional[Annotated[str, Strict(strict=True)]], init_tok2vec: Optional[Annotated[str, Strict(strict=True)]], tokenizer: Dict[Annotated[str, Strict(strict=True)], Any], components: Dict[Annotated[str, Strict(strict=True)], Dict[Annotated[str, Strict(strict=True)], Any]], before_init: Optional[Callable[[spacy.language.Language], spacy.language.Language]], after_init: Optional[Callable[[spacy.language.Language], spacy.language.Language]]) -> None
|
| Method resolution order:
| ConfigSchemaInit
| pydantic.main.BaseModel
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'after_init': typing.Optional[typing.Callable[[Forw...
|
| __class_vars__ = set()
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'cls': <class 'spacy.schemas.ConfigSchemaI...
|
| __pydantic_custom_init__ = False
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {'after_init': FieldInfo(annotation=Union[Callab...
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = None
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="ConfigSchemaInit", val...
|
| __signature__ = <Signature (*, vocab_data: Optional[Annotated[st...ge....
|
| model_config = {'arbitrary_types_allowed': True, 'extra': 'forbid'}
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __init__(self, /, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_args__(self) -> '_repr.ReprArgs'
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| 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(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]'
|
| json(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, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| 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.
|
| Returns:
| New model instance.
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| 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.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| from_orm(obj: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| 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.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| 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.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| 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.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_obj(obj: 'Any') -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {'after_init': FieldInfo(annotation=Union[Callable[list...
spacy.ConfigSchemaNlp
Python Library Documentation: class ConfigSchemaNlp in module spacy.schemas
class ConfigSchemaNlp(pydantic.main.BaseModel)
| ConfigSchemaNlp(*, lang: Annotated[str, Strict(strict=True)], pipeline: List[Annotated[str, Strict(strict=True)]], disabled: List[Annotated[str, Strict(strict=True)]], tokenizer: Callable, before_creation: Optional[Callable[[Type[spacy.language.Language]], Type[spacy.language.Language]]], after_creation: Optional[Callable[[spacy.language.Language], spacy.language.Language]], after_pipeline_creation: Optional[Callable[[spacy.language.Language], spacy.language.Language]], batch_size: Optional[int], vectors: Callable) -> None
|
| Method resolution order:
| ConfigSchemaNlp
| pydantic.main.BaseModel
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'after_creation': typing.Optional[typing.Callable[[...
|
| __class_vars__ = set()
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'cls': <class 'spacy.schemas.ConfigSchemaN...
|
| __pydantic_custom_init__ = False
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {'after_creation': FieldInfo(annotation=Union[Ca...
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = None
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="ConfigSchemaNlp", vali...
|
| __signature__ = <Signature (*, lang: Annotated[str, Strict(stric..._si...
|
| model_config = {'arbitrary_types_allowed': True, 'extra': 'forbid'}
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __init__(self, /, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_args__(self) -> '_repr.ReprArgs'
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| 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(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]'
|
| json(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, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| 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.
|
| Returns:
| New model instance.
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| 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.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| from_orm(obj: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| 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.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| 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.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| 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.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_obj(obj: 'Any') -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {'after_creation': FieldInfo(annotation=Union[Callable[...
spacy.ConfigSchemaPretrain
Python Library Documentation: class ConfigSchemaPretrain in module spacy.schemas
class ConfigSchemaPretrain(pydantic.main.BaseModel)
| ConfigSchemaPretrain(*, max_epochs: Annotated[int, Strict(strict=True)], dropout: Annotated[float, Strict(strict=True)], n_save_every: Optional[Annotated[int, Strict(strict=True)]], n_save_epoch: Optional[Annotated[int, Strict(strict=True)]], optimizer: thinc.optimizers.Optimizer, corpus: Annotated[str, Strict(strict=True)], batcher: Union[Callable[[Iterable[~ItemT]], Iterable[List[~ItemT]]], confection._registry.Promise], component: str, layer: str, objective: Callable[[spacy.vocab.Vocab, thinc.model.Model], thinc.model.Model]) -> None
|
| Method resolution order:
| ConfigSchemaPretrain
| pydantic.main.BaseModel
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'batcher': typing.Union[typing.Callable[[typing.Ite...
|
| __class_vars__ = set()
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'cls': <class 'spacy.schemas.ConfigSchemaP...
|
| __pydantic_custom_init__ = False
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {'batcher': FieldInfo(annotation=Union[Callable[...
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = None
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="ConfigSchemaPretrain",...
|
| __signature__ = <Signature (*, max_epochs: Annotated[int, Strict... th...
|
| model_config = {'arbitrary_types_allowed': True, 'extra': 'forbid'}
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __init__(self, /, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_args__(self) -> '_repr.ReprArgs'
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| 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(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]'
|
| json(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, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| 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.
|
| Returns:
| New model instance.
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| 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.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| from_orm(obj: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| 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.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| 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.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| 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.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_obj(obj: 'Any') -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {'batcher': FieldInfo(annotation=Union[Callable[list, I...
spacy.ConfigSchemaTraining
Python Library Documentation: class ConfigSchemaTraining in module spacy.schemas
class ConfigSchemaTraining(pydantic.main.BaseModel)
| ConfigSchemaTraining(*, dev_corpus: Annotated[str, Strict(strict=True)], train_corpus: Annotated[str, Strict(strict=True)], batcher: Union[Callable[[Iterable[~ItemT]], Iterable[List[~ItemT]]], confection._registry.Promise], dropout: Annotated[float, Strict(strict=True)], patience: Annotated[int, Strict(strict=True)], max_epochs: Annotated[int, Strict(strict=True)], max_steps: Annotated[int, Strict(strict=True)], eval_frequency: Annotated[int, Strict(strict=True)], seed: Optional[Annotated[int, Strict(strict=True)]], gpu_allocator: Optional[Annotated[str, Strict(strict=True)]], accumulate_gradient: Annotated[int, Strict(strict=True)], score_weights: Dict[Annotated[str, Strict(strict=True)], Union[Annotated[int, Strict(strict=True)], Annotated[float, Strict(strict=True)], NoneType]], optimizer: thinc.optimizers.Optimizer, logger: Union[Callable[[spacy.language.Language], Tuple[Callable[[Dict[str, Any]], NoneType], Callable]], confection._registry.Promise], frozen_components: List[str], annotating_components: List[str], before_to_disk: Optional[Callable[[spacy.language.Language], spacy.language.Language]], before_update: Optional[Callable[[spacy.language.Language, Dict[str, Any]], NoneType]]) -> None
|
| Method resolution order:
| ConfigSchemaTraining
| pydantic.main.BaseModel
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'accumulate_gradient': typing.Annotated[int, Strict...
|
| __class_vars__ = set()
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'definitions': [{'cls': <class 'confection...
|
| __pydantic_custom_init__ = False
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {'accumulate_gradient': FieldInfo(annotation=int...
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = None
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="ConfigSchemaTraining",...
|
| __signature__ = <Signature (*, dev_corpus: Annotated[str, Strict...e.L...
|
| model_config = {'arbitrary_types_allowed': True, 'extra': 'forbid'}
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __init__(self, /, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_args__(self) -> '_repr.ReprArgs'
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| 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(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]'
|
| json(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, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| 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.
|
| Returns:
| New model instance.
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| 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.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| from_orm(obj: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| 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.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| 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.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| 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.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_obj(obj: 'Any') -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {'accumulate_gradient': FieldInfo(annotation=int, requi...
spacy.Dict
Python Library Documentation: _SpecialGenericAlias in module typing
Dict = typing.Dict
A generic version of dict.
spacy.Errors
Python Library Documentation: class Errors in module spacy.errors
class Errors(builtins.object)
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| E001 = "[E001] No component '{name}' found in pipeline. Available name...
|
| E002 = "[E002] Can't find factory for '{name}' for langu...r class com...
|
| E003 = '[E003] Not a valid pipeline component. Expected ... it correct...
|
| E004 = "[E004] Can't set up pipeline component: a factor...Existing fa...
|
| E005 = "[E005] Pipeline component '{name}' returned {ret...nt, maybe y...
|
| E006 = '[E006] Invalid constraints for adding pipeline c...onfiguratio...
|
| E007 = "[E007] '{name}' already exists in pipeline. Existing names: {o...
|
| E008 = "[E008] Can't restore disabled pipeline component...ipes` or af...
|
| E010 = '[E010] Word vectors set to length 0. This may be...info, see t...
|
| E011 = "[E011] Unknown operator: '{op}'. Options: {opts}"
|
| E012 = '[E012] Cannot add pattern for zero tokens to matcher.\nKey: {k...
|
| E016 = '[E016] MultitaskObjective target should be funct...r one of: d...
|
| E017 = '[E017] Can only add unicode or bytes. Got type: {value_type}'
|
| E018 = "[E018] Can't retrieve string for hash '{hash_val...rs to an is...
|
| E019 = "[E019] Can't create transition with unknown acti...ion IDs are...
|
| E022 = "[E022] Could not find a transition with the name '{name}' in t...
|
| E024 = '[E024] Could not find an optimal move to supervi...r details, ...
|
| E025 = '[E025] String is too long: {length} characters. Max is 2**30.'
|
| E026 = '[E026] Error accessing token at position {i}: out of bounds in...
|
| E027 = "[E027] Arguments `words` and `spaces` should be ... that the w...
|
| E028 = '[E028] `words` expects a list of unicode strings, but got byte...
|
| E029 = '[E029] `noun_chunks` requires the dependency par... the docume...
|
| E030 = '[E030] Sentence boundaries unset. You can add th...nce boundar...
|
| E031 = "[E031] Invalid token: empty string ('') at position {i}."
|
| E033 = '[E033] Cannot load into non-empty Doc of length {length}.'
|
| E035 = '[E035] Error creating span with start {start} and end {end} fo...
|
| E036 = "[E036] Error calculating span: Can't find a token starting at ...
|
| E037 = "[E037] Error calculating span: Can't find a token ending at ch...
|
| E039 = '[E039] Array bounds exceeded while searching for...ue here: ht...
|
| E040 = '[E040] Attempt to access token at {i}, max length {max_length}...
|
| E041 = '[E041] Invalid comparison operator: {op}. Likely a Cython bug?...
|
| E042 = '[E042] Error accessing `doc[{i}].nbor({j})`, for doc of length...
|
| E043 = '[E043] Refusing to write to token.sent_start if ...arsed, beca...
|
| E044 = '[E044] Invalid value for token.sent_start: {value}. Must be on...
|
| E045 = '[E045] Possibly infinite loop encountered while looking for {a...
|
| E046 = "[E046] Can't retrieve unregistered extension att...id you forg...
|
| E047 = "[E047] Can't assign a value to unregistered exte...id you forg...
|
| E048 = "[E048] Can't import language {lang} or any matching language f...
|
| E050 = "[E050] Can't find model '{name}'. It doesn't see...thon packag...
|
| E052 = "[E052] Can't find model directory: {path}"
|
| E053 = '[E053] Could not read {name} from {path}'
|
| E054 = "[E054] No valid '{setting}' setting found in model meta.json."
|
| E055 = '[E055] Invalid ORTH value in exception:\nKey: {key}\nOrths: {o...
|
| E056 = '[E056] Invalid tokenizer exception: ORTH values ... match orig...
|
| E057 = '[E057] Stepped slices not supported in Span objects. Try: `lis...
|
| E058 = '[E058] Could not retrieve vector for key {key}.'
|
| E059 = '[E059] One (and only one) keyword arg must be set. Got: {kwarg...
|
| E060 = '[E060] Cannot add new key to vectors: the table is full. Curre...
|
| E062 = '[E062] Cannot find empty bit for new lexical fla...`nlp.vocab....
|
| E063 = '[E063] Invalid value for `flag_id`: {value}. Flag IDs must be ...
|
| E064 = '[E064] Error fetching a Lexeme from the Vocab. W...: {string}\...
|
| E065 = "[E065] Only one of the vector table's width and ...e specified...
|
| E067 = "[E067] Invalid BILUO tag sequence: Got a tag sta...B' (beginni...
|
| E068 = "[E068] Invalid BILUO tag: '{tag}'."
|
| E071 = '[E071] Error creating lexeme: specified orth ID ...es not matc...
|
| E073 = '[E073] Cannot assign vector of length {new_lengt... clear the ...
|
| E074 = '[E074] Error interpreting compiled match pattern...o end with ...
|
| E079 = '[E079] Error computing states in beam: number of...) does not ...
|
| E080 = '[E080] Duplicate state found in beam: {key}.'
|
| E081 = '[E081] Error getting gradient in beam: number of...ist}) does ...
|
| E082 = '[E082] Error deprojectivizing parse: number of h...roj_heads})...
|
| E083 = '[E083] Error setting extension: only one of `def... optional `...
|
| E084 = '[E084] Error assigning label ID {label} to span: not in String...
|
| E085 = "[E085] Can't create lexeme for string '{string}'."
|
| E087 = '[E087] Unknown displaCy style: {style}.'
|
| E088 = '[E088] Text of length {length} exceeds maximum o...your inputs...
|
| E089 = "[E089] Extensions can't have a setter argument w.... Check the...
|
| E090 = "[E090] Extension '{name}' already exists on {obj...nsion, set ...
|
| E091 = '[E091] Invalid extension attribute {name}: expected callable o...
|
| E093 = '[E093] token.ent_iob values make invalid sequence: I without B...
|
| E094 = '[E094] Error reading line {line_num} in vectors file {loc}.'
|
| E095 = "[E095] Can't write to frozen dictionary. This is.... Are you w...
|
| E096 = '[E096] Invalid object passed to displaCy: Can on...r Span obje...
|
| E097 = '[E097] Invalid pattern: expected token pattern (...ts) or phra...
|
| E098 = '[E098] Invalid pattern: expected both RIGHT_ID and RIGHT_ATTRS...
|
| E099 = '[E099] Invalid pattern: the first node of patter...ode should ...
|
| E100 = '[E100] Nodes other than the anchor node should a...tain {requi...
|
| E1000 = '[E1000] The Chinese word segmenter is pkuseg but...\nnlp.toke...
|
| E1001 = "[E1001] Target token outside of matched span for...ffset '{in...
|
| E1002 = '[E1002] Span index out of range.'
|
| E1003 = "[E1003] Unsupported lemmatizer mode '{mode}'."
|
| E1004 = '[E1004] Missing lemmatizer table(s) found for le...t to call ...
|
| E1005 = "[E1005] Unable to set attribute '{attr}' in toke...ptions are...
|
| E1007 = "[E1007] Unsupported DependencyMatcher operator '{op}'."
|
| E1008 = '[E1008] Invalid pattern: each pattern should be ...oviding a ...
|
| E101 = '[E101] RIGHT_ID should be a new node and LEFT_ID...lready have...
|
| E1010 = '[E1010] Unable to set entity information for tok...ne span in...
|
| E1011 = "[E1011] Unsupported default '{default}' in `doc.set_ents`. Av...
|
| E1012 = '[E1012] Entity spans and blocked/missing/outside...vided to `...
|
| E1013 = '[E1013] Invalid morph: the MorphAnalysis must ha... value wit...
|
| E1014 = "[E1014] Error loading DocBin data. It doesn't lo...t it using...
|
| E1015 = "[E1015] Can't initialize model from config: no {...ion, run: ...
|
| E1016 = "[E1016] The operators 'OP': '?', '*', and '+' ar...h exactly ...
|
| E1017 = '[E1017] A Doc object requires both \'deps\' and \'h...acehold...
|
| E1018 = "[E1018] Knowledge base for component '{name}' is...el.set_kb`...
|
| E1019 = '[E1019] `noun_chunks` requires the pos tagging, ... the docum...
|
| E102 = "[E102] Can't merge non-disjoint spans. '{token}'...\nhttps://s...
|
| E1020 = '[E1020] No `epoch_resume` value specified and co...e from fil...
|
| E1021 = '[E1021] `pos` value "{pp}" is not a valid Univer...s tag. Non...
|
| E1022 = "[E1022] Words must be of type str or int, but input is of typ...
|
| E1023 = "[E1023] Couldn't read EntityRuler from the {path}. This file ...
|
| E1024 = "[E1024] A pattern with {attr_type} '{label}' is not present i...
|
| E1025 = "[E1025] Cannot intify the value '{value}' as an ...e only sup...
|
| E1026 = '[E1026] Edit tree has an invalid format:\n{errors}'
|
| E1027 = '[E1027] AlignmentArray only supports slicing with a step of 1...
|
| E1028 = '[E1028] AlignmentArray only supports indexing using an int or...
|
| E1029 = '[E1029] Edit tree cannot be applied to form.'
|
| E103 = "[E103] Trying to set conflicting doc.ents: '{spa...pping entit...
|
| E1030 = '[E1030] Edit tree identifier out of range.'
|
| E1031 = '[E1031] Could not find gold transition - see logs above.'
|
| E1032 = '[E1032] `{var}` should not be {forbidden}, but received {valu...
|
| E1033 = '[E1033] Dimension {name} invalid -- only nO, nF, nP'
|
| E1034 = '[E1034] Node index {i} out of bounds ({length})'
|
| E1035 = '[E1035] Token index {i} out of bounds ({length})'
|
| E1036 = '[E1036] Cannot index into NoneNode'
|
| E1037 = "[E1037] Invalid attribute value '{attr}'."
|
| E1038 = '[E1038] Invalid JSON input: {message}'
|
| E1039 = '[E1039] The {obj} start or end annotations (star... {end}) co...
|
| E1040 = '[E1040] Doc.from_json requires all tokens to hav...ns do not ...
|
| E1041 = '[E1041] Expected a string, Doc, or bytes as input, but got: {...
|
| E1042 = '[E1042] `enable={enable}` and `disable={disable}...ously not ...
|
| E1043 = '[E1043] Expected None or a value in range [{rang...d}] for en...
|
| E1044 = '[E1044] Expected `candidates_batch_size` to be >= 1, but got:...
|
| E1045 = "[E1045] Encountered {parent} subclass without `{...thod, make...
|
| E1046 = '[E1046] {cls_name} is an abstract class and cann...s default ...
|
| E1047 = '[E1047] `find_threshold()` only supports components with a `s...
|
| E1048 = "[E1048] Got '{unexpected}' as console progress b...pe, but ex...
|
| E1049 = '[E1049] No available port found for displaCy on ...ilable por...
|
| E1050 = '[E1050] Port {port} is already in use. Please sp...rt=True` t...
|
| E1051 = "[E1051] 'allow_overlap' can only be False when m...e is 1, bu...
|
| E1052 = '[E1052] Unable to copy spans: the character offs...ot align w...
|
| E1053 = "[E1053] Both 'min_length' and 'max_length' shoul...length': {...
|
| E1054 = '[E1054] The text, including whitespace, must mat...nce and pr...
|
| E1055 = "[E1055] The 'replace_listener' callback expects ...lbacks wit...
|
| E1056 = '[E1056] The `TextCatBOW` architecture expects a length of at ...
|
| E1057 = '[E1057] The `TextCatReduce` architecture must be...uce_last`,...
|
| E106 = "[E106] Can't find `doc._.{attr}` attribute specified in the un...
|
| E107 = '[E107] Value of custom attribute `{attr}` is not JSON-serializ...
|
| E109 = "[E109] Component '{name}' could not be run. Did you forget to ...
|
| E110 = '[E110] Invalid displaCy render wrapper. Expected callable, got...
|
| E111 = '[E111] Pickling a token is not supported, becaus...pickling th...
|
| E112 = '[E112] Pickling a span is not supported, because...c to conver...
|
| E115 = '[E115] All subtokens must have associated heads.'
|
| E117 = '[E117] The newly split tokens must match the tex...riginal tok...
|
| E118 = "[E118] The custom extension attribute '{attr}' i...ibute, use ...
|
| E119 = "[E119] Can't set custom extension attribute '{at...with a defa...
|
| E120 = "[E120] Can't set custom extension attributes dur...pping attri...
|
| E121 = "[E121] Can't bulk merge spans. Attribute length ...len} should...
|
| E122 = '[E122] Cannot find token to be split. Did it get merged?'
|
| E123 = '[E123] Cannot find head of token to be split. Did it get merge...
|
| E125 = '[E125] Unexpected value: {value}'
|
| E126 = "[E126] Unexpected matcher predicate: '{bad}'. Ex...ly a bug in...
|
| E130 = '[E130] You are running a narrow unicode build, w... Python and...
|
| E132 = '[E132] The vectors for entities and probabilitie..._length} an...
|
| E133 = "[E133] The sum of prior probabilities for alias '{alias}' shou...
|
| E134 = "[E134] Entity '{entity}' is not defined in the Knowledge Base....
|
| E139 = "[E139] Knowledge base for component '{name}' is empty."
|
| E140 = '[E140] The list of entities, prior probabilities and entity ve...
|
| E141 = '[E141] Entity vectors should be of length {required} instead o...
|
| E143 = "[E143] Labels for component '{name}' not initial... examples t...
|
| E145 = '[E145] Error reading `{param}` from input file.'
|
| E146 = '[E146] Could not access {path}.'
|
| E147 = '[E147] Unexpected error in the {method} function... issue: htt...
|
| E148 = '[E148] Expected {ents} KB identifiers but got {i...ity in `doc...
|
| E149 = '[E149] Error deserializing model. Check that the...ate the com...
|
| E150 = "[E150] The language of the `nlp` object and the ...me, but fou...
|
| E152 = '[E152] The attribute {attr} is not supported for..., EntityRul...
|
| E153 = '[E153] The value type {vtype} is not supported f..., EntityRul...
|
| E154 = '[E154] One of the attributes or values is not su..., PhraseMat...
|
| E155 = '[E155] The pipeline needs to include a {pipe} in...pipe())` in...
|
| E157 = "[E157] Can't render negative values for dependen...rt}, end: {...
|
| E158 = "[E158] Can't add table '{name}' to lookups because it already ...
|
| E159 = "[E159] Can't find table '{name}' in lookups. Available tables:...
|
| E160 = "[E160] Can't find language data file: {path}"
|
| E161 = '[E161] Found an internal inconsistency when pred... issue: htt...
|
| E163 = '[E163] cumsum was found to be unstable: its last element does ...
|
| E164 = '[E164] x is neither increasing nor decreasing: {x}.'
|
| E165 = '[E165] Only one class present in the gold labels...abel}. ROC ...
|
| E166 = '[E166] Can only merge DocBins with the same valu....\nCurrent ...
|
| E169 = "[E169] Can't find module: {module}"
|
| E170 = '[E170] Cannot apply transition {name}: invalid for the current...
|
| E171 = "[E171] Matcher.add received invalid 'on_match' c...t: expected...
|
| E175 = "[E175] Can't remove rule for unknown match pattern ID: {key}"
|
| E176 = "[E176] Alias '{alias}' is not defined in the Knowledge Base."
|
| E177 = '[E177] Ill-formed IOB input detected: {tag}'
|
| E178 = "[E178] Each pattern should be a list of dicts, b...t. For exam...
|
| E179 = "[E179] Invalid pattern. Expected a list of Doc o... list. For ...
|
| E180 = "[E180] Span attributes can't be declared as requ...ttributes) ...
|
| E181 = '[E181] Received invalid attributes for unknown o...rs}. Only D...
|
| E182 = '[E182] Received invalid attribute declaration: {...o define th...
|
| E183 = '[E183] Received invalid attribute declaration: {...attributes ...
|
| E184 = '[E184] Only attributes without underscores are s...utes are co...
|
| E185 = "[E185] Received invalid attribute in component a...ttr}`\nAttr...
|
| E187 = '[E187] Only unicode strings are supported as labels.'
|
| E189 = '[E189] Each argument to `Doc.__init__` should be of equal leng...
|
| E190 = '[E190] Token head out of range in `Doc.from_arra... index rath...
|
| E191 = '[E191] Invalid head: the head token must be from the same doc ...
|
| E192 = '[E192] Unable to resize vectors in place with cupy.'
|
| E193 = '[E193] Unable to resize vectors in place if the ...ame as the ...
|
| E194 = "[E194] Unable to aligned mismatched text '{text}' and words '{...
|
| E195 = '[E195] Matcher can be called on {good} only, got {got}.'
|
| E196 = '[E196] Refusing to write to `token.is_sent_end`....ies can onl...
|
| E197 = '[E197] Row out of bounds, unable to add row {row} for key {key...
|
| E198 = '[E198] Unable to return {n} most similar vectors...t vectors t...
|
| E199 = '[E199] Unable to merge 0-length span at `doc[{start}:{end}]`.'
|
| E200 = "[E200] Can't set {attr} from Span."
|
| E202 = "[E202] Unsupported {name} mode '{mode}'. Supported modes: {mod...
|
| E203 = "[E203] If the {name} embedding layer is not upda...ake sure to...
|
| E849 = '[E849] The vocab only supports {method} for vect...f type spac...
|
| E850 = '[E850] The PretrainVectors objective currently o...ts default ...
|
| E851 = "[E851] The 'textcat' component labels should only have values ...
|
| E853 = "[E853] Unsupported component factory name '{name... character ...
|
| E854 = "[E854] Unable to set doc.ents. Check that the 'ents_filter' do...
|
| E855 = '[E855] Invalid {obj}: {obj} is not from the same doc.'
|
| E856 = '[E856] Error accessing span at position {i}: out of bounds in ...
|
| E857 = "[E857] Entry '{name}' not found in edit tree lemmatizer labels...
|
| E858 = '[E858] The {mode} vector table does not support this operation...
|
| E859 = '[E859] The floret vector table cannot be modified.'
|
| E860 = "[E860] Can't truncate floret vectors."
|
| E861 = "[E861] No 'keys' should be provided when initializing floret v...
|
| E862 = "[E862] 'hash_count' must be between 1-4 for floret vectors."
|
| E863 = "[E863] 'maxn' must be greater than or equal to 'minn'."
|
| E864 = "[E864] The complete vector table 'data' is required to initial...
|
| E865 = '[E865] A SpanGroup is not functional after the c...is still av...
|
| E866 = "[E866] Expected a string or 'Doc' as input, but got: {type}."
|
| E867 = "[E867] The 'textcat' component requires at least...he 'textcat...
|
| E868 = '[E868] Found a conflicting gold annotation in a ...ld ents as ...
|
| E869 = "[E869] The notation '{label}' is not supported a...t_spans_key...
|
| E870 = "[E870] Could not serialize the DocBin because it... a director...
|
| E871 = '[E871] Error encountered in nlp.pipe with multiprocessing:\n\n...
|
| E872 = '[E872] Unable to copy tokenizer from base model ...ig "{curr_c...
|
| E873 = '[E873] Unable to merge a span from doc.spans wit... issue: htt...
|
| E874 = "[E874] Could not initialize the tok2vec model from component '...
|
| E875 = '[E875] To use the PretrainVectors objective, mak...se are defi...
|
| E879 = "[E879] Unexpected type for 'spans' data. Provide... be optiona...
|
| E884 = '[E884] The pipeline could not be initialized bec..., or initia...
|
| E885 = '[E885] entity_linker.set_kb received an invalid ...expected a ...
|
| E886 = "[E886] Can't replace {name} -> {tok2vec} listene...ath}' not f...
|
| E887 = "[E887] Can't replace {name} -> {tok2vec} listene...available l...
|
| E888 = "[E888] Can't replace listeners for '{name}' ({pi...isteners ma...
|
| E889 = "[E889] Can't replace '{tok2vec}' listeners of co...isteners ma...
|
| E890 = "[E890] Cannot add the alias '{alias}' to the Kno...e base. Eac...
|
| E891 = "[E891] Alias '{alias}' could not be added to the Knowledge bas...
|
| E892 = "[E892] Unknown function registry: '{name}'.\n\nAvailable names...
|
| E893 = "[E893] Could not find function '{name}' in funct...n your envi...
|
| E894 = "[E894] The 'noun_chunks' syntax iterator is not implemented fo...
|
| E895 = "[E895] The 'textcat' component received gold-sta...tead. Examp...
|
| E896 = "[E896] There was an error using the static vecto...alized, or ...
|
| E897 = "[E897] Field '{field}' should be a dot-notation ...ion in the ...
|
| E898 = "[E898] Can't serialize trainable pipe '{name}': ...`self.model...
|
| E899 = "[E899] Can't serialize trainable pipe '{name}': ...`self.vocab...
|
| E900 = '[E900] Could not run the full pipeline for evalu...nitialized ...
|
| E901 = '[E901] Failed to remove existing output director...the existin...
|
| E902 = '[E902] The sentence-per-line IOB/IOB2 file is no... delimiters...
|
| E903 = '[E903] The token-per-line NER file is not format... delimiters...
|
| E904 = '[E904] Cannot initialize StaticVectors layer: nO...th, after t...
|
| E905 = '[E905] Cannot initialize StaticVectors layer: nM...mension ref...
|
| E906 = "[E906] Unexpected `loss` value in pretraining ob...ive: '{foun...
|
| E908 = "[E908] Can't set `spaces` without `words` in `Doc.__init__`."
|
| E909 = '[E909] Expected {name} in parser internals. This is likely a b...
|
| E910 = "[E910] Encountered NaN value when computing loss for component...
|
| E911 = '[E911] Invalid feature: {feat}. Must be a token attribute.'
|
| E912 = "[E912] Failed to initialize lemmatizer. Missing ...ode}'. Requ...
|
| E913 = "[E913] Corpus path can't be None. Maybe you forg...e it in you...
|
| E914 = '[E914] Executing {name} callback failed. Expecte...t to return...
|
| E915 = "[E915] Can't use score '{name}' to calculate fin...g.score_wei...
|
| E916 = "[E916] Can't log score for '{name}' in table: not a valid scor...
|
| E917 = "[E917] Received invalid value {value} for `state...Parser: onl...
|
| E918 = '[E918] Received invalid value for vocab: {vocab}...acy.vocab.V...
|
| E919 = "[E919] A textcat `positive_label` '{pos_label}' ...n problem w...
|
| E920 = "[E920] The textcat's `positive_label` setting '{...during init...
|
| E921 = '[E921] The method `set_output` can only be calle... the output...
|
| E922 = "[E922] Component '{name}' has been initialized w...t dimension...
|
| E923 = "[E923] It looks like there is no proper sample d... you would ...
|
| E924 = "[E924] The '{name}' component does not seem to b... issue: htt...
|
| E925 = '[E925] Invalid color values for displaCy visuali...nary mappin...
|
| E926 = "[E926] It looks like you're trying to modify `nl... `nlp.disab...
|
| E927 = "[E927] Can't write to frozen list. Maybe you're ...a computed ...
|
| E928 = '[E928] An InMemoryLookupKB can only be serialize...but the pro...
|
| E929 = "[E929] Couldn't read InMemoryLookupKB from {loc}. The path doe...
|
| E930 = '[E930] Received invalid get_examples callback in...rns an iter...
|
| E931 = "[E931] Encountered {parent} subclass without `{p...thod, make ...
|
| E940 = '[E940] Found NaN values in scores.'
|
| E941 = '[E941] Can\'t find model \'{name}\'. It looks like ...del, use...
|
| E942 = '[E942] Executing `after_{name}` callback failed....t to return...
|
| E943 = '[E943] Executing `before_creation` callback fail...n or return...
|
| E944 = "[E944] Can't copy pipeline component '{name}' fr...t found in ...
|
| E945 = "[E945] Can't copy pipeline component '{name}' fr...ce. Expecte...
|
| E947 = "[E947] `Matcher.add` received invalid `greedy` a...d a string ...
|
| E948 = "[E948] `Matcher.add` received invalid 'patterns' argument: exp...
|
| E949 = '[E949] Unable to align tokens for the predicted ... with: {x}....
|
| E952 = "[E952] The section '{name}' is not a valid section in the prov...
|
| E953 = '[E953] Mismatched IDs received by the Tok2Vec listener: {id1} ...
|
| E954 = '[E954] The Tok2Vec listener did not receive any valid input fr...
|
| E955 = "[E955] Can't find table(s) {table} for language ... default lo...
|
| E956 = "[E956] Can't find component '{name}' in [compone...block in th...
|
| E957 = '[E957] Writing directly to `Language.factories` ...n component...
|
| E958 = '[E958] Language code defined in config ({bad_lan...ass with th...
|
| E959 = "[E959] Can't insert component {dir} index {idx}. Existing comp...
|
| E960 = "[E960] No config data found for component '{name}'. This is li...
|
| E961 = '[E961] Found non-serializable Python object in c...nitialize t...
|
| E962 = "[E962] Received incorrect {style} for pipe '{name}'. Expected ...
|
| E963 = "[E963] Can't read component info from `@Language...decorator}(...
|
| E964 = "[E964] The pipeline component factory for '{name...sed to iden...
|
| E965 = "[E965] It looks like you're using the `@Language...n, use the ...
|
| E966 = "[E966] `nlp.add_pipe` now takes the string name ...add_pipe('y...
|
| E967 = "[E967] No {meta} meta information found for '{name}'. This is ...
|
| E968 = "[E968] `nlp.replace_pipe` now takes the string n...en run `nlp...
|
| E969 = "[E969] Expected string values for field '{field}', but receive...
|
| E970 = "[E970] Can not execute command '{str_command}'. Do you have '{...
|
| E971 = '[E971] Found incompatible lengths in `Doc.from_a...or the arra...
|
| E972 = "[E972] `Example.__init__` got None for '{arg}'. Requires Doc."
|
| E973 = '[E973] Unexpected type for NER data'
|
| E974 = '[E974] Unknown {obj} attribute: {key}'
|
| E976 = '[E976] The method `Example.from_dict` expects a {type} as {n} ...
|
| E977 = '[E977] Can not compare a MorphAnalysis with a st... issue: htt...
|
| E978 = '[E978] The {name} method takes a list of Example objects, but ...
|
| E980 = '[E980] Each link annotation should refer to a di...identifier ...
|
| E981 = '[E981] The offsets of the annotations for `links` could not be...
|
| E982 = '[E982] The `Token.ent_iob` attribute should be an integer inde...
|
| E983 = "[E983] Invalid key(s) for '{dict}': {key}. Available keys: {ke...
|
| E984 = "[E984] Invalid component config for '{name}': co...ill copy th...
|
| E985 = "[E985] Can't load model from config file: no [nlp] section fou...
|
| E986 = '[E986] Could not create any training batches: ch...efined? Is ...
|
| E989 = '[E989] `nlp.update()` was called with two positi...objects, in...
|
| E991 = '[E991] The function `nlp.select_pipes` should be...hat specifi...
|
| E992 = '[E992] The function `select_pipes` was called wi...g for the `...
|
| E993 = "[E993] The config for the nlp object needs to in...'en' for En...
|
| E997 = "[E997] Tokenizer special cases are not allowed t... '{orth}' g...
|
| E999 = '[E999] Unable to merge the Doc objects because they do not all...
spacy.Example
Python Library Documentation: class Example in module spacy.training.example class Example(builtins.object) | Example(Doc predicted, Doc reference, alignment=None, *) | | Methods defined here: | | __init__(self, /, *args, **kwargs) | Initialize self. See help(type(self)) for accurate signature. | | __len__(self, /) | Return len(self). | | __reduce__ = __reduce_cython__(...) | Example.__reduce_cython__(self) | | __reduce_cython__(self) | Example.__reduce_cython__(self) | | __repr__(self, /) | Return repr(self). | | __setstate__ = __setstate_cython__(...) | Example.__setstate_cython__(self, __pyx_state) | | __setstate_cython__(self, __pyx_state) | Example.__setstate_cython__(self, __pyx_state) | | __str__(self, /) | Return str(self). | | copy(self) | Example.copy(self) | | get_aligned(self, field, as_string=False) | Example.get_aligned(self, field, as_string=False) | | Return an aligned array for a token attribute. | | get_aligned_ents_and_ner(self) | Example.get_aligned_ents_and_ner(self) | | get_aligned_ner(self) | Example.get_aligned_ner(self) | | get_aligned_parse(self, projectivize=True) | Example.get_aligned_parse(self, projectivize=True) | | get_aligned_sent_starts(self) | Example.get_aligned_sent_starts(self) | | Get list of SENT_START attributes aligned to the predicted tokenization. | If the reference does not have sentence starts, return a list of None values. | | get_aligned_spans_x2y(self, x_spans, allow_overlap=False) | Example.get_aligned_spans_x2y(self, x_spans, allow_overlap=False) | | get_aligned_spans_y2x(self, y_spans, allow_overlap=False) | Example.get_aligned_spans_y2x(self, y_spans, allow_overlap=False) | | get_matching_ents(self, check_label=True) | Example.get_matching_ents(self, check_label=True) | | Return entities that are shared between predicted and reference docs. | | If `check_label` is True, entities must have matching labels to be | kept. Otherwise only the character indices need to match. | | split_sents(self) | Example.split_sents(self) | | Split the token annotations into multiple Examples based on | sent_starts and return a list of the new Examples | | to_dict(self) | Example.to_dict(self) | | ---------------------------------------------------------------------- | Class methods defined here: | | from_dict(predicted, example_dict) | Example.from_dict(cls, Doc predicted, dict example_dict) | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Data descriptors defined here: | | alignment | | predicted | | reference | | text | | x | | y
spacy.Iterable
Python Library Documentation: _SpecialGenericAlias in module typing
Iterable = typing.Iterable
A generic version of collections.abc.Iterable.
spacy.Language
Python Library Documentation: class Language in module spacy.language
class Language(builtins.object)
| Language(vocab: Union[spacy.vocab.Vocab, bool] = True, *, max_length: int = 1000000, meta: Dict[str, Any] = {}, create_tokenizer: Optional[Callable[[ForwardRef('Language')], Callable[[str], spacy.tokens.doc.Doc]]] = None, create_vectors: Optional[Callable[[ForwardRef('Vocab')], spacy.vectors.BaseVectors]] = None, batch_size: int = 1000, **kwargs) -> None
|
| A text-processing pipeline. Usually you'll load this once per process,
| and pass the instance around your application.
|
| Defaults (class): Settings, data and factory methods for creating the `nlp`
| object and processing pipeline.
| lang (str): Two-letter ISO 639-1 or three-letter ISO 639-3 language codes, such as 'en' and 'eng'.
|
| DOCS: https://spacy.io/api/language
|
| Methods defined here:
|
| __call__(self, text: Union[str, spacy.tokens.doc.Doc], *, disable: Iterable[str] = [], component_cfg: Optional[Dict[str, Dict[str, Any]]] = None) -> spacy.tokens.doc.Doc
| Apply the pipeline to some text. The text can span multiple sentences,
| and can contain arbitrary whitespace. Alignment into the original string
| is preserved.
|
| text (Union[str, Doc]): If `str`, the text to be processed. If `Doc`,
| the doc will be passed directly to the pipeline, skipping
| `Language.make_doc`.
| disable (List[str]): Names of the pipeline components to disable.
| component_cfg (Dict[str, dict]): An optional dictionary with extra
| keyword arguments for specific components.
| RETURNS (Doc): A container for accessing the annotations.
|
| DOCS: https://spacy.io/api/language#call
|
| __init__(self, vocab: Union[spacy.vocab.Vocab, bool] = True, *, max_length: int = 1000000, meta: Dict[str, Any] = {}, create_tokenizer: Optional[Callable[[ForwardRef('Language')], Callable[[str], spacy.tokens.doc.Doc]]] = None, create_vectors: Optional[Callable[[ForwardRef('Vocab')], spacy.vectors.BaseVectors]] = None, batch_size: int = 1000, **kwargs) -> None
| Initialise a Language object.
|
| vocab (Vocab): A `Vocab` object. If `True`, a vocab is created.
| meta (dict): Custom meta data for the Language class. Is written to by
| models to add model meta data.
| max_length (int): Maximum number of characters in a single text. The
| current models may run out memory on extremely long texts, due to
| large internal allocations. You should segment these texts into
| meaningful units, e.g. paragraphs, subsections etc, before passing
| them to spaCy. Default maximum length is 1,000,000 charas (1mb). As
| a rule of thumb, if all pipeline components are enabled, spaCy's
| default models currently requires roughly 1GB of temporary memory per
| 100,000 characters in one text.
| create_tokenizer (Callable): Function that takes the nlp object and
| returns a tokenizer.
| batch_size (int): Default batch size for pipe and evaluate.
|
| DOCS: https://spacy.io/api/language#init
|
| add_pipe(self, factory_name: str, name: Optional[str] = None, *, before: Union[str, int, NoneType] = None, after: Union[str, int, NoneType] = None, first: Optional[bool] = None, last: Optional[bool] = None, source: Optional[ForwardRef('Language')] = None, config: Dict[str, Any] = {}, raw_config: Optional[confection._config.Config] = None, validate: bool = True) -> Callable[[spacy.tokens.doc.Doc], spacy.tokens.doc.Doc]
| Add a component to the processing pipeline. Valid components are
| callables that take a `Doc` object, modify it and return it. Only one
| of before/after/first/last can be set. Default behaviour is "last".
|
| factory_name (str): Name of the component factory.
| name (str): Name of pipeline component. Overwrites existing
| component.name attribute if available. If no name is set and
| the component exposes no name attribute, component.__name__ is
| used. An error is raised if a name already exists in the pipeline.
| before (Union[str, int]): Name or index of the component to insert new
| component directly before.
| after (Union[str, int]): Name or index of the component to insert new
| component directly after.
| first (bool): If True, insert component first in the pipeline.
| last (bool): If True, insert component last in the pipeline.
| source (Language): Optional loaded nlp object to copy the pipeline
| component from.
| config (Dict[str, Any]): Config parameters to use for this component.
| Will be merged with default config, if available.
| raw_config (Optional[Config]): Internals: the non-interpolated config.
| validate (bool): Whether to validate the component config against the
| arguments and types expected by the factory.
| RETURNS (Callable[[Doc], Doc]): The pipeline component.
|
| DOCS: https://spacy.io/api/language#add_pipe
|
| analyze_pipes(self, *, keys: List[str] = ['assigns', 'requires', 'scores', 'retokenizes'], pretty: bool = False) -> Optional[Dict[str, Any]]
| Analyze the current pipeline components, print a summary of what
| they assign or require and check that all requirements are met.
|
| keys (List[str]): The meta values to display in the table. Corresponds
| to values in FactoryMeta, defined by @Language.factory decorator.
| pretty (bool): Pretty-print the results.
| RETURNS (dict): The data.
|
| begin_training(self, get_examples: Optional[Callable[[], Iterable[spacy.training.example.Example]]] = None, *, sgd: Optional[thinc.optimizers.Optimizer] = None) -> thinc.optimizers.Optimizer
|
| create_optimizer(self)
| Create an optimizer, usually using the [training.optimizer] config.
|
| create_pipe(self, factory_name: str, name: Optional[str] = None, *, config: Dict[str, Any] = {}, raw_config: Optional[confection._config.Config] = None, validate: bool = True) -> Callable[[spacy.tokens.doc.Doc], spacy.tokens.doc.Doc]
| Create a pipeline component. Mostly used internally. To create and
| add a component to the pipeline, you can use nlp.add_pipe.
|
| factory_name (str): Name of component factory.
| name (Optional[str]): Optional name to assign to component instance.
| Defaults to factory name if not set.
| config (Dict[str, Any]): Config parameters to use for this component.
| Will be merged with default config, if available.
| raw_config (Optional[Config]): Internals: the non-interpolated config.
| validate (bool): Whether to validate the component config against the
| arguments and types expected by the factory.
| RETURNS (Callable[[Doc], Doc]): The pipeline component.
|
| DOCS: https://spacy.io/api/language#create_pipe
|
| create_pipe_from_source(self, source_name: str, source: 'Language', *, name: str) -> Tuple[Callable[[spacy.tokens.doc.Doc], spacy.tokens.doc.Doc], str]
| Create a pipeline component by copying it from an existing model.
|
| source_name (str): Name of the component in the source pipeline.
| source (Language): The source nlp object to copy from.
| name (str): Optional alternative name to use in current pipeline.
| RETURNS (Tuple[Callable[[Doc], Doc], str]): The component and its factory name.
|
| disable_pipe(self, name: str) -> None
| Disable a pipeline component. The component will still exist on
| the nlp object, but it won't be run as part of the pipeline. Does
| nothing if the component is already disabled.
|
| name (str): The name of the component to disable.
|
| disable_pipes(self, *names) -> 'DisabledPipes'
| Disable one or more pipeline components. If used as a context
| manager, the pipeline will be restored to the initial state at the end
| of the block. Otherwise, a DisabledPipes object is returned, that has
| a `.restore()` method you can use to undo your changes.
|
| This method has been deprecated since 3.0
|
| enable_pipe(self, name: str) -> None
| Enable a previously disabled pipeline component so it's run as part
| of the pipeline. Does nothing if the component is already enabled.
|
| name (str): The name of the component to enable.
|
| evaluate(self, examples: Iterable[spacy.training.example.Example], *, batch_size: Optional[int] = None, scorer: Optional[spacy.scorer.Scorer] = None, component_cfg: Optional[Dict[str, Dict[str, Any]]] = None, scorer_cfg: Optional[Dict[str, Any]] = None, per_component: bool = False) -> Dict[str, Any]
| Evaluate a model's pipeline components.
|
| examples (Iterable[Example]): `Example` objects.
| batch_size (Optional[int]): Batch size to use.
| scorer (Optional[Scorer]): Scorer to use. If not passed in, a new one
| will be created.
| component_cfg (dict): An optional dictionary with extra keyword
| arguments for specific components.
| scorer_cfg (dict): An optional dictionary with extra keyword arguments
| for the scorer.
| per_component (bool): Whether to return the scores keyed by component
| name. Defaults to False.
|
| RETURNS (Scorer): The scorer containing the evaluation results.
|
| DOCS: https://spacy.io/api/language#evaluate
|
| from_bytes(self, bytes_data: bytes, *, exclude: Iterable[str] = []) -> 'Language'
| Load state from a binary string.
|
| bytes_data (bytes): The data to load from.
| exclude (Iterable[str]): Names of components or serialization fields to exclude.
| RETURNS (Language): The `Language` object.
|
| DOCS: https://spacy.io/api/language#from_bytes
|
| from_disk(self, path: Union[str, pathlib.Path], *, exclude: Iterable[str] = [], overrides: Dict[str, Any] = {}) -> 'Language'
| Loads state from a directory. Modifies the object in place and
| returns it. If the saved `Language` object contains a model, the
| model will be loaded.
|
| path (str / Path): A path to a directory.
| exclude (Iterable[str]): Names of components or serialization fields to exclude.
| RETURNS (Language): The modified `Language` object.
|
| DOCS: https://spacy.io/api/language#from_disk
|
| get_pipe(self, name: str) -> Callable[[spacy.tokens.doc.Doc], spacy.tokens.doc.Doc]
| Get a pipeline component for a given component name.
|
| name (str): Name of pipeline component to get.
| RETURNS (callable): The pipeline component.
|
| DOCS: https://spacy.io/api/language#get_pipe
|
| get_pipe_config(self, name: str) -> confection._config.Config
| Get the config used to create a pipeline component.
|
| name (str): The component name.
| RETURNS (Config): The config used to create the pipeline component.
|
| get_pipe_meta(self, name: str) -> 'FactoryMeta'
| Get the meta information for a given component name.
|
| name (str): The component name.
| RETURNS (FactoryMeta): The meta for the given component name.
|
| has_pipe(self, name: str) -> bool
| Check if a component name is present in the pipeline. Equivalent to
| `name in nlp.pipe_names`.
|
| name (str): Name of the component.
| RETURNS (bool): Whether a component of the name exists in the pipeline.
|
| DOCS: https://spacy.io/api/language#has_pipe
|
| initialize(self, get_examples: Optional[Callable[[], Iterable[spacy.training.example.Example]]] = None, *, sgd: Optional[thinc.optimizers.Optimizer] = None) -> thinc.optimizers.Optimizer
| Initialize the pipe for training, using data examples if available.
|
| get_examples (Callable[[], Iterable[Example]]): Optional function that
| returns gold-standard Example objects.
| sgd (Optional[Optimizer]): An optimizer to use for updates. If not
| provided, will be created using the .create_optimizer() method.
| RETURNS (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/language#initialize
|
| make_doc(self, text: str) -> spacy.tokens.doc.Doc
| Turn a text into a Doc object.
|
| text (str): The text to process.
| RETURNS (Doc): The processed doc.
|
| memory_zone(self, mem: Optional[cymem.cymem.Pool] = None) -> Iterator[cymem.cymem.Pool]
| Begin a block where all resources allocated during the block will
| be freed at the end of it. If a resources was created within the
| memory zone block, accessing it outside the block is invalid.
| Behaviour of this invalid access is undefined. Memory zones should
| not be nested.
|
| The memory zone is helpful for services that need to process large
| volumes of text with a defined memory budget.
|
| Example
| -------
| >>> with nlp.memory_zone():
| ... for doc in nlp.pipe(texts):
| ... process_my_doc(doc)
| >>> # use_doc(doc) <-- Invalid: doc was allocated in the memory zone
|
| pipe(self, texts: Union[Iterable[Union[str, spacy.tokens.doc.Doc]], Iterable[Tuple[Union[str, spacy.tokens.doc.Doc], ~_AnyContext]]], *, as_tuples: bool = False, batch_size: Optional[int] = None, disable: Iterable[str] = [], component_cfg: Optional[Dict[str, Dict[str, Any]]] = None, n_process: int = 1) -> Union[Iterator[spacy.tokens.doc.Doc], Iterator[Tuple[spacy.tokens.doc.Doc, ~_AnyContext]]]
| Process texts as a stream, and yield `Doc` objects in order.
|
| texts (Iterable[Union[str, Doc]]): A sequence of texts or docs to
| process.
| as_tuples (bool): If set to True, inputs should be a sequence of
| (text, context) tuples. Output will then be a sequence of
| (doc, context) tuples. Defaults to False.
| batch_size (Optional[int]): The number of texts to buffer.
| disable (List[str]): Names of the pipeline components to disable.
| component_cfg (Dict[str, Dict]): An optional dictionary with extra keyword
| arguments for specific components.
| n_process (int): Number of processors to process texts. If -1, set `multiprocessing.cpu_count()`.
| YIELDS (Doc): Documents in the order of the original text.
|
| DOCS: https://spacy.io/api/language#pipe
|
| rehearse(self, examples: Iterable[spacy.training.example.Example], *, sgd: Optional[thinc.optimizers.Optimizer] = None, losses: Optional[Dict[str, float]] = None, component_cfg: Optional[Dict[str, Dict[str, Any]]] = None, exclude: Iterable[str] = []) -> Dict[str, float]
| Make a "rehearsal" update to the models in the pipeline, to prevent
| forgetting. Rehearsal updates run an initial copy of the model over some
| data, and update the model so its current predictions are more like the
| initial ones. This is useful for keeping a pretrained model on-track,
| even if you're updating it with a smaller set of examples.
|
| examples (Iterable[Example]): A batch of `Example` objects.
| sgd (Optional[Optimizer]): An optimizer.
| component_cfg (Dict[str, Dict]): Config parameters for specific pipeline
| components, keyed by component name.
| exclude (Iterable[str]): Names of components that shouldn't be updated.
| RETURNS (dict): Results from the update.
|
| EXAMPLE:
| >>> raw_text_batches = minibatch(raw_texts)
| >>> for labelled_batch in minibatch(examples):
| >>> nlp.update(labelled_batch)
| >>> raw_batch = [Example.from_dict(nlp.make_doc(text), {}) for text in next(raw_text_batches)]
| >>> nlp.rehearse(raw_batch)
|
| DOCS: https://spacy.io/api/language#rehearse
|
| remove_pipe(self, name: str) -> Tuple[str, Callable[[spacy.tokens.doc.Doc], spacy.tokens.doc.Doc]]
| Remove a component from the pipeline.
|
| name (str): Name of the component to remove.
| RETURNS (Tuple[str, Callable[[Doc], Doc]]): A `(name, component)` tuple of the removed component.
|
| DOCS: https://spacy.io/api/language#remove_pipe
|
| rename_pipe(self, old_name: str, new_name: str) -> None
| Rename a pipeline component.
|
| old_name (str): Name of the component to rename.
| new_name (str): New name of the component.
|
| DOCS: https://spacy.io/api/language#rename_pipe
|
| replace_listeners(self, tok2vec_name: str, pipe_name: str, listeners: Iterable[str]) -> None
| Find listener layers (connecting to a token-to-vector embedding
| component) of a given pipeline component model and replace
| them with a standalone copy of the token-to-vector layer. This can be
| useful when training a pipeline with components sourced from an existing
| pipeline: if multiple components (e.g. tagger, parser, NER) listen to
| the same tok2vec component, but some of them are frozen and not updated,
| their performance may degrade significantly as the tok2vec component is
| updated with new data. To prevent this, listeners can be replaced with
| a standalone tok2vec layer that is owned by the component and doesn't
| change if the component isn't updated.
|
| tok2vec_name (str): Name of the token-to-vector component, typically
| "tok2vec" or "transformer".
| pipe_name (str): Name of pipeline component to replace listeners for.
| listeners (Iterable[str]): The paths to the listeners, relative to the
| component config, e.g. ["model.tok2vec"]. Typically, implementations
| will only connect to one tok2vec component, [model.tok2vec], but in
| theory, custom models can use multiple listeners. The value here can
| either be an empty list to not replace any listeners, or a complete
| (!) list of the paths to all listener layers used by the model.
|
| DOCS: https://spacy.io/api/language#replace_listeners
|
| replace_pipe(self, name: str, factory_name: str, *, config: Dict[str, Any] = {}, validate: bool = True) -> Callable[[spacy.tokens.doc.Doc], spacy.tokens.doc.Doc]
| Replace a component in the pipeline.
|
| name (str): Name of the component to replace.
| factory_name (str): Factory name of replacement component.
| config (Optional[Dict[str, Any]]): Config parameters to use for this
| component. Will be merged with default config, if available.
| validate (bool): Whether to validate the component config against the
| arguments and types expected by the factory.
| RETURNS (Callable[[Doc], Doc]): The new pipeline component.
|
| DOCS: https://spacy.io/api/language#replace_pipe
|
| resume_training(self, *, sgd: Optional[thinc.optimizers.Optimizer] = None) -> thinc.optimizers.Optimizer
| Continue training a pretrained model.
|
| Create and return an optimizer, and initialize "rehearsal" for any pipeline
| component that has a .rehearse() method. Rehearsal is used to prevent
| models from "forgetting" their initialized "knowledge". To perform
| rehearsal, collect samples of text you want the models to retain performance
| on, and call nlp.rehearse() with a batch of Example objects.
|
| RETURNS (Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/language#resume_training
|
| select_pipes(self, *, disable: Union[str, Iterable[str], NoneType] = None, enable: Union[str, Iterable[str], NoneType] = None) -> 'DisabledPipes'
| Disable one or more pipeline components. If used as a context
| manager, the pipeline will be restored to the initial state at the end
| of the block. Otherwise, a DisabledPipes object is returned, that has
| a `.restore()` method you can use to undo your changes.
|
| disable (str or iterable): The name(s) of the pipes to disable
| enable (str or iterable): The name(s) of the pipes to enable - all others will be disabled
|
| DOCS: https://spacy.io/api/language#select_pipes
|
| set_error_handler(self, error_handler: Callable[[str, Callable[[spacy.tokens.doc.Doc], spacy.tokens.doc.Doc], List[spacy.tokens.doc.Doc], Exception], NoReturn])
| Set an error handler object for all the components in the pipeline
| that implement a set_error_handler function.
|
| error_handler (Callable[[str, Callable[[Doc], Doc], List[Doc], Exception], NoReturn]):
| Function that deals with a failing batch of documents. This callable
| function should take in the component's name, the component itself,
| the offending batch of documents, and the exception that was thrown.
| DOCS: https://spacy.io/api/language#set_error_handler
|
| to_bytes(self, *, exclude: Iterable[str] = []) -> bytes
| Serialize the current state to a binary string.
|
| exclude (Iterable[str]): Names of components or serialization fields to exclude.
| RETURNS (bytes): The serialized form of the `Language` object.
|
| DOCS: https://spacy.io/api/language#to_bytes
|
| to_disk(self, path: Union[str, pathlib.Path], *, exclude: Iterable[str] = []) -> None
| Save the current state to a directory. If a model is loaded, this
| will include the model.
|
| path (str / Path): Path to a directory, which will be created if
| it doesn't exist.
| exclude (Iterable[str]): Names of components or serialization fields to exclude.
|
| DOCS: https://spacy.io/api/language#to_disk
|
| update(self, examples: Iterable[spacy.training.example.Example], _: Optional[Any] = None, *, drop: float = 0.0, sgd: Optional[thinc.optimizers.Optimizer] = None, losses: Optional[Dict[str, float]] = None, component_cfg: Optional[Dict[str, Dict[str, Any]]] = None, exclude: Iterable[str] = [], annotates: Iterable[str] = [])
| Update the models in the pipeline.
|
| examples (Iterable[Example]): A batch of examples
| _: Should not be set - serves to catch backwards-incompatible scripts.
| drop (float): The dropout rate.
| sgd (Optimizer): An optimizer.
| losses (Dict[str, float]): Dictionary to update with the loss, keyed by
| component.
| component_cfg (Dict[str, Dict]): Config parameters for specific pipeline
| components, keyed by component name.
| exclude (Iterable[str]): Names of components that shouldn't be updated.
| annotates (Iterable[str]): Names of components that should set
| annotations on the predicted examples after updating.
| RETURNS (Dict[str, float]): The updated losses dictionary
|
| DOCS: https://spacy.io/api/language#update
|
| use_params(self, params: Optional[dict])
| Replace weights of models in the pipeline with those provided in the
| params dictionary. Can be used as a contextmanager, in which case,
| models go back to their original weights after the block.
|
| params (dict): A dictionary of parameters keyed by model ID.
|
| EXAMPLE:
| >>> with nlp.use_params(optimizer.averages):
| >>> nlp.to_disk("/tmp/checkpoint")
|
| DOCS: https://spacy.io/api/language#use_params
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| component(name: str, *, assigns: Iterable[str] = [], requires: Iterable[str] = [], retokenizes: bool = False, func: Optional[Callable[[spacy.tokens.doc.Doc], spacy.tokens.doc.Doc]] = None) -> Callable[..., Any]
| Register a new pipeline component. Can be used for stateless function
| components that don't require a separate factory. Can be used as a
| decorator on a function or classmethod, or called as a function with the
| factory provided as the func keyword argument. To create a component and
| add it to the pipeline, you can use nlp.add_pipe(name).
|
| name (str): The name of the component factory.
| assigns (Iterable[str]): Doc/Token attributes assigned by this component,
| e.g. "token.ent_id". Used for pipeline analysis.
| requires (Iterable[str]): Doc/Token attributes required by this component,
| e.g. "token.ent_id". Used for pipeline analysis.
| retokenizes (bool): Whether the component changes the tokenization.
| Used for pipeline analysis.
| func (Optional[Callable[[Doc], Doc]): Factory function if not used as a decorator.
|
| DOCS: https://spacy.io/api/language#component
|
| factory(name: str, *, default_config: Dict[str, Any] = {}, assigns: Iterable[str] = [], requires: Iterable[str] = [], retokenizes: bool = False, default_score_weights: Dict[str, Optional[float]] = {}, func: Optional[Callable] = None) -> Callable
| Register a new pipeline component factory. Can be used as a decorator
| on a function or classmethod, or called as a function with the factory
| provided as the func keyword argument. To create a component and add
| it to the pipeline, you can use nlp.add_pipe(name).
|
| name (str): The name of the component factory.
| default_config (Dict[str, Any]): Default configuration, describing the
| default values of the factory arguments.
| assigns (Iterable[str]): Doc/Token attributes assigned by this component,
| e.g. "token.ent_id". Used for pipeline analysis.
| requires (Iterable[str]): Doc/Token attributes required by this component,
| e.g. "token.ent_id". Used for pipeline analysis.
| retokenizes (bool): Whether the component changes the tokenization.
| Used for pipeline analysis.
| default_score_weights (Dict[str, Optional[float]]): The scores to report during
| training, and their default weight towards the final score used to
| select the best model. Weights should sum to 1.0 per component and
| will be combined and normalized for the whole pipeline. If None,
| the score won't be shown in the logs or be weighted.
| func (Optional[Callable]): Factory function if not used as a decorator.
|
| DOCS: https://spacy.io/api/language#factory
|
| from_config(config: Union[Dict[str, Any], confection._config.Config] = {}, *, vocab: Union[spacy.vocab.Vocab, bool] = True, disable: Union[str, Iterable[str]] = [], enable: Union[str, Iterable[str]] = [], exclude: Union[str, Iterable[str]] = [], meta: Dict[str, Any] = {}, auto_fill: bool = True, validate: bool = True) -> 'Language'
| Create the nlp object from a loaded config. Will set up the tokenizer
| and language data, add pipeline components etc. If no config is provided,
| the default config of the given language is used.
|
| config (Dict[str, Any] / Config): The loaded config.
| vocab (Vocab): A Vocab object. If True, a vocab is created.
| disable (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to disable.
| Disabled pipes will be loaded but they won't be run unless you
| explicitly enable them by calling nlp.enable_pipe.
| enable (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to enable. All other
| pipes will be disabled (and can be enabled using `nlp.enable_pipe`).
| exclude (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to exclude.
| Excluded components won't be loaded.
| meta (Dict[str, Any]): Meta overrides for nlp.meta.
| auto_fill (bool): Automatically fill in missing values in config based
| on defaults and function argument annotations.
| validate (bool): Validate the component config and arguments against
| the types expected by the factory.
| RETURNS (Language): The initialized Language class.
|
| DOCS: https://spacy.io/api/language#from_config
|
| get_factory_meta(name: str) -> 'FactoryMeta'
| Get the meta information for a given factory name.
|
| name (str): The component factory name.
| RETURNS (FactoryMeta): The meta for the given factory name.
|
| get_factory_name(name: str) -> str
| Get the internal factory name based on the language subclass.
|
| name (str): The factory name.
| RETURNS (str): The internal factory name.
|
| has_factory(name: str) -> bool
| RETURNS (bool): Whether a factory of that name is registered.
|
| set_factory_meta(name: str, value: 'FactoryMeta') -> None
| Set the meta information for a given factory name.
|
| name (str): The component factory name.
| value (FactoryMeta): The meta to set.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| component_names
| Get the names of the available pipeline components. Includes all
| active and inactive pipeline components.
|
| RETURNS (List[str]): List of component name strings, in order.
|
| components
| Get all (name, component) tuples in the pipeline, including the
| currently disabled components.
|
| disabled
| Get the names of all disabled components.
|
| RETURNS (List[str]): The disabled components.
|
| factory_names
| Get names of all available factories.
|
| RETURNS (List[str]): The factory names.
|
| path
|
| pipe_factories
| Get the component factories for the available pipeline components.
|
| RETURNS (Dict[str, str]): Factory names, keyed by component names.
|
| pipe_labels
| Get the labels set by the pipeline components, if available (if
| the component exposes a labels property and the labels are not
| hidden).
|
| RETURNS (Dict[str, List[str]]): Labels keyed by component name.
|
| pipe_names
| Get names of available active pipeline components.
|
| RETURNS (List[str]): List of component name strings, in order.
|
| pipeline
| The processing pipeline consisting of (name, component) tuples. The
| components are called on the Doc in order as it passes through the
| pipeline.
|
| RETURNS (List[Tuple[str, Callable[[Doc], Doc]]]): The pipeline.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| config
| Trainable config for the current language instance. Includes the
| current pipeline components, as well as default training config.
|
| RETURNS (thinc.api.Config): The config.
|
| DOCS: https://spacy.io/api/language#config
|
| meta
| Custom meta data of the language class. If a model is loaded, this
| includes details from the model's meta.json.
|
| RETURNS (Dict[str, Any]): The meta.
|
| DOCS: https://spacy.io/api/language#meta
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| Defaults = <class 'spacy.language.BaseDefaults'>
| Language data defaults, available via Language.Defaults. Can be
| overwritten by language subclasses by defining their own subclasses of
| Language.Defaults.
|
|
| __annotations__ = {'_factory_meta': typing.Dict[str, ForwardRef('Facto...
|
| default_config = {'paths': {'train': None, 'dev': None, 'vectors'...s'...
|
| factories = {'merge_noun_chunks': <function Language.compone...ent.<lo...
|
| lang = None
spacy.Path
Python Library Documentation: class Path in module pathlib
class Path(PurePath)
| Path(*args, **kwargs)
|
| PurePath subclass that can make system calls.
|
| Path represents a filesystem path but unlike PurePath, also offers
| methods to do system calls on path objects. Depending on your system,
| instantiating a Path will return either a PosixPath or a WindowsPath
| object. You can also instantiate a PosixPath or WindowsPath directly,
| but cannot instantiate a WindowsPath on a POSIX system or vice versa.
|
| Method resolution order:
| Path
| PurePath
| builtins.object
|
| Methods defined here:
|
| __enter__(self)
|
| __exit__(self, t, v, tb)
|
| __init__(self, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| absolute(self)
| Return an absolute version of this path by prepending the current
| working directory. No normalization or symlink resolution is performed.
|
| Use resolve() to get the canonical path to a file.
|
| chmod(self, mode, *, follow_symlinks=True)
| Change the permissions of the path, like os.chmod().
|
| exists(self, *, follow_symlinks=True)
| Whether this path exists.
|
| This method normally follows symlinks; to check whether a symlink exists,
| add the argument follow_symlinks=False.
|
| expanduser(self)
| Return a new path with expanded ~ and ~user constructs
| (as returned by os.path.expanduser)
|
| glob(self, pattern, *, case_sensitive=None)
| Iterate over this subtree and yield all existing files (of any
| kind, including directories) matching the given relative pattern.
|
| group(self)
| Return the group name of the file gid.
|
| hardlink_to(self, target)
| Make this path a hard link pointing to the same file as *target*.
|
| Note the order of arguments (self, target) is the reverse of os.link's.
|
| is_block_device(self)
| Whether this path is a block device.
|
| is_char_device(self)
| Whether this path is a character device.
|
| is_dir(self)
| Whether this path is a directory.
|
| is_fifo(self)
| Whether this path is a FIFO.
|
| is_file(self)
| Whether this path is a regular file (also True for symlinks pointing
| to regular files).
|
| is_junction(self)
| Whether this path is a junction.
|
| is_mount(self)
| Check if this path is a mount point
|
| is_socket(self)
| Whether this path is a socket.
|
| is_symlink(self)
| Whether this path is a symbolic link.
|
| iterdir(self)
| Yield path objects of the directory contents.
|
| The children are yielded in arbitrary order, and the
| special entries '.' and '..' are not included.
|
| lchmod(self, mode)
| Like chmod(), except if the path points to a symlink, the symlink's
| permissions are changed, rather than its target's.
|
| lstat(self)
| Like stat(), except if the path points to a symlink, the symlink's
| status information is returned, rather than its target's.
|
| mkdir(self, mode=511, parents=False, exist_ok=False)
| Create a new directory at this given path.
|
| open(self, mode='r', buffering=-1, encoding=None, errors=None, newline=None)
| Open the file pointed to by this path and return a file object, as
| the built-in open() function does.
|
| owner(self)
| Return the login name of the file owner.
|
| read_bytes(self)
| Open the file in bytes mode, read it, and close the file.
|
| read_text(self, encoding=None, errors=None)
| Open the file in text mode, read it, and close the file.
|
| readlink(self)
| Return the path to which the symbolic link points.
|
| rename(self, target)
| Rename this path to the target path.
|
| The target path may be absolute or relative. Relative paths are
| interpreted relative to the current working directory, *not* the
| directory of the Path object.
|
| Returns the new Path instance pointing to the target path.
|
| replace(self, target)
| Rename this path to the target path, overwriting if that path exists.
|
| The target path may be absolute or relative. Relative paths are
| interpreted relative to the current working directory, *not* the
| directory of the Path object.
|
| Returns the new Path instance pointing to the target path.
|
| resolve(self, strict=False)
| Make the path absolute, resolving all symlinks on the way and also
| normalizing it.
|
| rglob(self, pattern, *, case_sensitive=None)
| Recursively yield all existing files (of any kind, including
| directories) matching the given relative pattern, anywhere in
| this subtree.
|
| rmdir(self)
| Remove this directory. The directory must be empty.
|
| samefile(self, other_path)
| Return whether other_path is the same or not as this file
| (as returned by os.path.samefile()).
|
| stat(self, *, follow_symlinks=True)
| Return the result of the stat() system call on this path, like
| os.stat() does.
|
| symlink_to(self, target, target_is_directory=False)
| Make this path a symlink pointing to the target path.
| Note the order of arguments (link, target) is the reverse of os.symlink.
|
| touch(self, mode=438, exist_ok=True)
| Create this file with the given access mode, if it doesn't exist.
|
| unlink(self, missing_ok=False)
| Remove this file or link.
| If the path is a directory, use rmdir() instead.
|
| walk(self, top_down=True, on_error=None, follow_symlinks=False)
| Walk the directory tree from this directory, similar to os.walk().
|
| write_bytes(self, data)
| Open the file in bytes mode, write to it, and close the file.
|
| write_text(self, data, encoding=None, errors=None, newline=None)
| Open the file in text mode, write to it, and close the file.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| cwd()
| Return a new path pointing to the current working directory.
|
| home()
| Return a new path pointing to the user's home directory (as
| returned by os.path.expanduser('~')).
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(cls, *args, **kwargs)
| Construct a PurePath from one or several strings and or existing
| PurePath objects. The strings and path objects are combined so as
| to yield a canonicalized path, which is incorporated into the
| new PurePath object.
|
| ----------------------------------------------------------------------
| Methods inherited from PurePath:
|
| __bytes__(self)
| Return the bytes representation of the path. This is only
| recommended to use under Unix.
|
| __eq__(self, other)
| Return self==value.
|
| __fspath__(self)
|
| __ge__(self, other)
| Return self>=value.
|
| __gt__(self, other)
| Return self>value.
|
| __hash__(self)
| Return hash(self).
|
| __le__(self, other)
| Return self<=value.
|
| __lt__(self, other)
| Return self<value.
|
| __reduce__(self)
| Helper for pickle.
|
| __repr__(self)
| Return repr(self).
|
| __rtruediv__(self, key)
|
| __str__(self)
| Return the string representation of the path, suitable for
| passing to system calls.
|
| __truediv__(self, key)
|
| as_posix(self)
| Return the string representation of the path with forward (/)
| slashes.
|
| as_uri(self)
| Return the path as a 'file' URI.
|
| is_absolute(self)
| True if the path is absolute (has both a root and, if applicable,
| a drive).
|
| is_relative_to(self, other, /, *_deprecated)
| Return True if the path is relative to another path or False.
|
| is_reserved(self)
| Return True if the path contains one of the special names reserved
| by the system, if any.
|
| joinpath(self, *pathsegments)
| Combine this path with one or several arguments, and return a
| new path representing either a subpath (if all arguments are relative
| paths) or a totally different path (if one of the arguments is
| anchored).
|
| match(self, path_pattern, *, case_sensitive=None)
| Return True if this path matches the given pattern.
|
| relative_to(self, other, /, *_deprecated, walk_up=False)
| Return the relative path to another path identified by the passed
| arguments. If the operation is not possible (because this is not
| related to the other path), raise ValueError.
|
| The *walk_up* parameter controls whether ``..`` may be used to resolve
| the path.
|
| with_name(self, name)
| Return a new path with the file name changed.
|
| with_segments(self, *pathsegments)
| Construct a new path object from any number of path-like objects.
| Subclasses may override this method to customize how new path objects
| are created from methods like `iterdir()`.
|
| with_stem(self, stem)
| Return a new path with the stem changed.
|
| with_suffix(self, suffix)
| Return a new path with the file suffix changed. If the path
| has no suffix, add given suffix. If the given suffix is an empty
| string, remove the suffix from the path.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from PurePath:
|
| anchor
| The concatenation of the drive and root, or ''.
|
| drive
| The drive prefix (letter or UNC path), if any.
|
| name
| The final path component, if any.
|
| parent
| The logical parent of the path.
|
| parents
| A sequence of this path's logical parents.
|
| parts
| An object providing sequence-like access to the
| components in the filesystem path.
|
| root
| The root of the path, if any.
|
| stem
| The final path component, minus its last suffix.
|
| suffix
| The final component's last suffix, if any.
|
| This includes the leading period. For example: '.txt'
|
| suffixes
| A list of the final component's suffixes, if any.
|
| These include the leading periods. For example: ['.tar', '.gz']
spacy.REGISTRY_POPULATED
Python Library Documentation: bool object class bool(int) | bool(x) -> bool | | Returns True when the argument x is true, False otherwise. | The builtins True and False are the only two instances of the class bool. | The class bool is a subclass of the class int, and cannot be subclassed. | | Method resolution order: | bool | int | object | | Methods defined here: | | __and__(self, value, /) | Return self&value. | | __invert__(self, /) | ~self | | __or__(self, value, /) | Return self|value. | | __rand__(self, value, /) | Return value&self. | | __repr__(self, /) | Return repr(self). | | __ror__(self, value, /) | Return value|self. | | __rxor__(self, value, /) | Return value^self. | | __xor__(self, value, /) | Return self^value. | | ---------------------------------------------------------------------- | Static methods defined here: | | __new__(*args, **kwargs) | Create and return a new object. See help(type) for accurate signature. | | ---------------------------------------------------------------------- | Methods inherited from int: | | __abs__(self, /) | abs(self) | | __add__(self, value, /) | Return self+value. | | __bool__(self, /) | True if self else False | | __ceil__(...) | Ceiling of an Integral returns itself. | | __divmod__(self, value, /) | Return divmod(self, value). | | __eq__(self, value, /) | Return self==value. | | __float__(self, /) | float(self) | | __floor__(...) | Flooring an Integral returns itself. | | __floordiv__(self, value, /) | Return self//value. | | __format__(self, format_spec, /) | Convert to a string according to format_spec. | | __ge__(self, value, /) | Return self>=value. | | __getattribute__(self, name, /) | Return getattr(self, name). | | __getnewargs__(self, /) | | __gt__(self, value, /) | Return self>value. | | __hash__(self, /) | Return hash(self). | | __index__(self, /) | Return self converted to an integer, if self is suitable for use as an index into a list. | | __int__(self, /) | int(self) | | __le__(self, value, /) | Return self<=value. | | __lshift__(self, value, /) | Return self<<value. | | __lt__(self, value, /) | Return self<value. | | __mod__(self, value, /) | Return self%value. | | __mul__(self, value, /) | Return self*value. | | __ne__(self, value, /) | Return self!=value. | | __neg__(self, /) | -self | | __pos__(self, /) | +self | | __pow__(self, value, mod=None, /) | Return pow(self, value, mod). | | __radd__(self, value, /) | Return value+self. | | __rdivmod__(self, value, /) | Return divmod(value, self). | | __rfloordiv__(self, value, /) | Return value//self. | | __rlshift__(self, value, /) | Return value<<self. | | __rmod__(self, value, /) | Return value%self. | | __rmul__(self, value, /) | Return value*self. | | __round__(...) | Rounding an Integral returns itself. | | Rounding with an ndigits argument also returns an integer. | | __rpow__(self, value, mod=None, /) | Return pow(value, self, mod). | | __rrshift__(self, value, /) | Return value>>self. | | __rshift__(self, value, /) | Return self>>value. | | __rsub__(self, value, /) | Return value-self. | | __rtruediv__(self, value, /) | Return value/self. | | __sizeof__(self, /) | Returns size in memory, in bytes. | | __sub__(self, value, /) | Return self-value. | | __truediv__(self, value, /) | Return self/value. | | __trunc__(...) | Truncating an Integral returns itself. | | as_integer_ratio(self, /) | Return a pair of integers, whose ratio is equal to the original int. | | The ratio is in lowest terms and has a positive denominator. | | >>> (10).as_integer_ratio() | (10, 1) | >>> (-10).as_integer_ratio() | (-10, 1) | >>> (0).as_integer_ratio() | (0, 1) | | bit_count(self, /) | Number of ones in the binary representation of the absolute value of self. | | Also known as the population count. | | >>> bin(13) | '0b1101' | >>> (13).bit_count() | 3 | | bit_length(self, /) | Number of bits necessary to represent self in binary. | | >>> bin(37) | '0b100101' | >>> (37).bit_length() | 6 | | conjugate(...) | Returns self, the complex conjugate of any int. | | is_integer(self, /) | Returns True. Exists for duck type compatibility with float.is_integer. | | to_bytes(self, /, length=1, byteorder='big', *, signed=False) | Return an array of bytes representing an integer. | | length | Length of bytes object to use. An OverflowError is raised if the | integer is not representable with the given number of bytes. Default | is length 1. | byteorder | The byte order used to represent the integer. If byteorder is 'big', | the most significant byte is at the beginning of the byte array. If | byteorder is 'little', the most significant byte is at the end of the | byte array. To request the native byte order of the host system, use | `sys.byteorder' as the byte order value. Default is to use 'big'. | signed | Determines whether two's complement is used to represent the integer. | If signed is False and a negative integer is given, an OverflowError | is raised. | | ---------------------------------------------------------------------- | Class methods inherited from int: | | from_bytes(bytes, byteorder='big', *, signed=False) | Return the integer represented by the given array of bytes. | | bytes | Holds the array of bytes to convert. The argument must either | support the buffer protocol or be an iterable object producing bytes. | Bytes and bytearray are examples of built-in objects that support the | buffer protocol. | byteorder | The byte order used to represent the integer. If byteorder is 'big', | the most significant byte is at the beginning of the byte array. If | byteorder is 'little', the most significant byte is at the end of the | byte array. To request the native byte order of the host system, use | `sys.byteorder' as the byte order value. Default is to use 'big'. | signed | Indicates whether two's complement is used to represent the integer. | | ---------------------------------------------------------------------- | Data descriptors inherited from int: | | denominator | the denominator of a rational number in lowest terms | | imag | the imaginary part of a complex number | | numerator | the numerator of a rational number in lowest terms | | real | the real part of a complex number
spacy.Union
Python Library Documentation: _SpecialForm in module typing
Union = typing.Union
Union type; Union[X, Y] means either X or Y.
On Python 3.10 and higher, the | operator
can also be used to denote unions;
X | Y means the same thing to the type checker as Union[X, Y].
To define a union, use e.g. Union[int, str]. Details:
- The arguments must be types and there must be at least one.
- None as an argument is a special case and is replaced by
type(None).
- Unions of unions are flattened, e.g.::
assert Union[Union[int, str], float] == Union[int, str, float]
- Unions of a single argument vanish, e.g.::
assert Union[int] == int # The constructor actually returns int
- Redundant arguments are skipped, e.g.::
assert Union[int, str, int] == Union[int, str]
- When comparing unions, the argument order is ignored, e.g.::
assert Union[int, str] == Union[str, int]
- You cannot subclass or instantiate a union.
- You can use Optional[X] as a shorthand for Union[X, None].
spacy.Vocab
Python Library Documentation: class Vocab in module spacy.vocab
class Vocab(builtins.object)
| Vocab(lex_attr_getters=None, strings=tuple(), lookups=None, oov_prob=-20., vectors_name=None, writing_system={}, get_noun_chunks=None, **deprecated_kwargs)
|
| A look-up table that allows you to access `Lexeme` objects. The `Vocab`
| instance also provides access to the `StringStore`, and owns underlying
| C-data that is shared between `Doc` objects.
|
| DOCS: https://spacy.io/api/vocab
|
| Methods defined here:
|
| __contains__(...)
| Vocab.__contains__(self, key)
|
| Check whether the string or int key has an entry in the vocabulary.
|
| string (str): The ID string.
| RETURNS (bool) Whether the string has an entry in the vocabulary.
|
| DOCS: https://spacy.io/api/vocab#contains
|
| __getitem__(...)
| Vocab.__getitem__(self, id_or_string)
|
| Retrieve a lexeme, given an int ID or a unicode string. If a
| previously unseen unicode string is given, a new lexeme is created and
| stored.
|
| id_or_string (int or str): The integer ID of a word, or its unicode
| string. If `int >= Lexicon.size`, `IndexError` is raised. If
| `id_or_string` is neither an int nor a unicode string, `ValueError`
| is raised.
| RETURNS (Lexeme): The lexeme indicated by the given ID.
|
| EXAMPLE:
| >>> apple = nlp.vocab.strings["apple"]
| >>> assert nlp.vocab[apple] == nlp.vocab[u"apple"]
|
| DOCS: https://spacy.io/api/vocab#getitem
|
| __init__(...)
| Create the vocabulary.
|
| lex_attr_getters (dict): A dictionary mapping attribute IDs to
| functions to compute them. Defaults to `None`.
| strings (StringStore): StringStore that maps strings to integers, and
| vice versa.
| lookups (Lookups): Container for large lookup tables and dictionaries.
| oov_prob (float): Default OOV probability.
| vectors_name (str): Optional name to identify the vectors table.
| get_noun_chunks (Optional[Callable[[Union[Doc, Span], Iterator[Tuple[int, int, int]]]]]):
| A function that yields base noun phrases used for Doc.noun_chunks.
|
| __iter__(...)
| Vocab.__iter__(self)
|
| Iterate over the lexemes in the vocabulary.
|
| YIELDS (Lexeme): An entry in the vocabulary.
|
| DOCS: https://spacy.io/api/vocab#iter
|
| __len__(...)
| Vocab.__len__(self)
|
| The current number of lexemes stored.
|
| RETURNS (int): The current number of lexemes stored.
|
| __reduce__ = __reduce_cython__(...)
| Vocab.__reduce_cython__(self)
|
| __reduce_cython__(self)
| Vocab.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| Vocab.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| Vocab.__setstate_cython__(self, __pyx_state)
|
| add_flag(self, flag_getter, flag_id=-1)
| Vocab.add_flag(self, flag_getter, int flag_id=-1)
|
| Set a new boolean flag to words in the vocabulary.
|
| The flag_getter function will be called over the words currently in the
| vocab, and then applied to new words as they occur. You'll then be able
| to access the flag value on each token using token.check_flag(flag_id).
| See also: `Lexeme.set_flag`, `Lexeme.check_flag`, `Token.set_flag`,
| `Token.check_flag`.
|
| flag_getter (callable): A function `f(str) -> bool`, to get the
| flag value.
| flag_id (int): An integer between 1 and 63 (inclusive), specifying
| the bit at which the flag will be stored. If -1, the lowest
| available bit will be chosen.
| RETURNS (int): The integer ID by which the flag value can be checked.
|
| DOCS: https://spacy.io/api/vocab#add_flag
|
| deduplicate_vectors(self)
| Vocab.deduplicate_vectors(self)
|
| from_bytes(self, bytes_data, *, exclude=())
| Vocab.from_bytes(self, bytes_data, *, exclude=tuple())
|
| Load state from a binary string.
|
| bytes_data (bytes): The data to load from.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (Vocab): The `Vocab` object.
|
| DOCS: https://spacy.io/api/vocab#from_bytes
|
| from_disk(self, path, *, exclude=())
| Vocab.from_disk(self, path, *, exclude=tuple())
|
| Loads state from a directory. Modifies the object in place and
| returns it.
|
| path (str or Path): A path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (Vocab): The modified `Vocab` object.
|
| DOCS: https://spacy.io/api/vocab#to_disk
|
| get_vector(self, orth)
| Vocab.get_vector(self, orth)
|
| Retrieve a vector for a word in the vocabulary. Words can be looked
| up by string or int ID. If the current vectors do not contain an entry
| for the word, a 0-vector with the same number of dimensions as the
| current vectors is returned.
|
| orth (int / unicode): The hash value of a word, or its unicode string.
| RETURNS (numpy.ndarray or cupy.ndarray): A word vector. Size
| and shape determined by the `vocab.vectors` instance. Usually, a
| numpy ndarray of shape (300,) and dtype float32.
|
| DOCS: https://spacy.io/api/vocab#get_vector
|
| has_vector(self, orth)
| Vocab.has_vector(self, orth)
|
| Check whether a word has a vector. Returns False if no vectors have
| been loaded. Words can be looked up by string or int ID.
|
| orth (int / str): The word.
| RETURNS (bool): Whether the word has a vector.
|
| DOCS: https://spacy.io/api/vocab#has_vector
|
| memory_zone(self, mem: 'Optional[Pool]' = None) -> 'Iterator[Pool]'
| Vocab.memory_zone(self, mem: Optional[Pool] = None) -> Iterator[Pool]
|
| Begin a block where resources allocated during the block will
| be freed at the end of it. If a resources was created within the
| memory zone block, accessing it outside the block is invalid.
| Behaviour of this invalid access is undefined. Memory zones should
| not be nested.
|
| The memory zone is helpful for services that need to process large
| volumes of text with a defined memory budget.
|
| prune_vectors(self, nr_row, batch_size=1024)
| Vocab.prune_vectors(self, nr_row, batch_size=1024)
|
| Reduce the current vector table to `nr_row` unique entries. Words
| mapped to the discarded vectors will be remapped to the closest vector
| among those remaining.
|
| For example, suppose the original table had vectors for the words:
| ['sat', 'cat', 'feline', 'reclined']. If we prune the vector table to
| two rows, we would discard the vectors for 'feline' and 'reclined'.
| These words would then be remapped to the closest remaining vector
| -- so "feline" would have the same vector as "cat", and "reclined"
| would have the same vector as "sat".
|
| The similarities are judged by cosine. The original vectors may
| be large, so the cosines are calculated in minibatches, to reduce
| memory usage.
|
| nr_row (int): The number of rows to keep in the vector table.
| batch_size (int): Batch of vectors for calculating the similarities.
| Larger batch sizes might be faster, while temporarily requiring
| more memory.
| RETURNS (dict): A dictionary keyed by removed words mapped to
| `(string, score)` tuples, where `string` is the entry the removed
| word was mapped to, and `score` the similarity score between the
| two words.
|
| DOCS: https://spacy.io/api/vocab#prune_vectors
|
| reset_vectors(self, *, width=None, shape=None)
| Vocab.reset_vectors(self, *, width=None, shape=None)
|
| Drop the current vector table. Because all vectors must be the same
| width, you have to call this to change the size of the vectors.
|
| set_vector(self, orth, vector)
| Vocab.set_vector(self, orth, vector)
|
| Set a vector for a word in the vocabulary. Words can be referenced
| by string or int ID.
|
| orth (int / str): The word.
| vector (numpy.ndarray or cupy.nadarry[ndim=1, dtype='float32']): The vector to set.
|
| DOCS: https://spacy.io/api/vocab#set_vector
|
| to_bytes(self, *, exclude=())
| Vocab.to_bytes(self, *, exclude=tuple())
|
| Serialize the current state to a binary string.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (bytes): The serialized form of the `Vocab` object.
|
| DOCS: https://spacy.io/api/vocab#to_bytes
|
| to_disk(self, path, *, exclude=())
| Vocab.to_disk(self, path, *, exclude=tuple())
|
| Save the current state to a directory.
|
| path (str or Path): A path to a directory, which will be created if
| it doesn't exist.
| exclude (Iterable[str]): String names of serialization fields to exclude.
|
| DOCS: https://spacy.io/api/vocab#to_disk
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| cfg
| cfg: object
|
| get_noun_chunks
| get_noun_chunks: object
|
| in_memory_zone
| Vocab.in_memory_zone: bool
|
| lang
|
| length
|
| lex_attr_getters
| lex_attr_getters: object
|
| lookups
|
| morphology
| morphology: spacy.morphology.Morphology
|
| strings
|
| vectors
|
| vectors_length
|
| writing_system
| writing_system: object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __pyx_vtable__ = <capsule object NULL>
spacy.about
Python Library Documentation: module spacy.about in spacy
NAME
spacy.about - # fmt: off
DATA
__compatibility__ = 'https://raw.githubusercontent.com/explosion/spacy...
__download_url__ = 'https://github.com/explosion/spacy-models/releases...
__title__ = 'spacy'
VERSION
3.8.14
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\about.py
spacy.attrs
Python Library Documentation: module spacy.attrs in spacy
NAME
spacy.attrs
FUNCTIONS
intify_attr(name)
intify_attr(name)
Normalize an attribute name, converting it to int.
stringy_attr (string): Attribute string name. Can also be int (will then be left unchanged)
RETURNS (int): int representation of the attribute, or None if it couldn't be converted.
intify_attrs(stringy_attrs, strings_map=None, _do_deprecated=False)
intify_attrs(stringy_attrs, strings_map=None, _do_deprecated=False)
Normalize a dictionary of attributes, converting them to ints.
stringy_attrs (dict): Dictionary keyed by attribute string names. Values
can be ints or strings.
strings_map (StringStore): Defaults to None. If provided, encodes string
values into ints.
RETURNS (dict): Attributes dictionary with keys and optionally values
converted to ints.
DATA
0
DEP = 76
ENT_ID = 454
ENT_IOB = 77
ENT_KB_ID = 452
ENT_TYPE = 78
FLAG19 = 19
FLAG20 = 20
FLAG21 = 21
FLAG22 = 22
FLAG23 = 23
FLAG24 = 24
FLAG25 = 25
FLAG26 = 26
FLAG27 = 27
FLAG28 = 28
FLAG29 = 29
FLAG30 = 30
FLAG31 = 31
FLAG32 = 32
FLAG33 = 33
FLAG34 = 34
FLAG35 = 35
FLAG36 = 36
FLAG37 = 37
FLAG38 = 38
FLAG39 = 39
FLAG40 = 40
FLAG41 = 41
FLAG42 = 42
FLAG43 = 43
FLAG44 = 44
FLAG45 = 45
FLAG46 = 46
FLAG47 = 47
FLAG48 = 48
FLAG49 = 49
FLAG50 = 50
FLAG51 = 51
FLAG52 = 52
FLAG53 = 53
FLAG54 = 54
FLAG55 = 55
FLAG56 = 56
FLAG57 = 57
FLAG58 = 58
FLAG59 = 59
FLAG60 = 60
FLAG61 = 61
FLAG62 = 62
FLAG63 = 63
HEAD = 79
ID = 64
IDS = {'': 0, 'DEP': 76, 'ENT_ID': 454, 'ENT_IOB': 77, 'ENT_KB_ID': 45...
IDX = 455
IOB_STRINGS = ('', 'I', 'O', 'B')
IS_ALPHA = 1
IS_ASCII = 2
IS_BRACKET = 14
IS_CURRENCY = 18
IS_DIGIT = 3
IS_LEFT_PUNCT = 16
IS_LOWER = 4
IS_OOV_DEPRECATED = 13
IS_PUNCT = 5
IS_QUOTE = 15
IS_RIGHT_PUNCT = 17
IS_SPACE = 6
IS_STOP = 12
IS_TITLE = 7
IS_UPPER = 8
LANG = 83
LEMMA = 73
LENGTH = 71
LIKE_EMAIL = 11
LIKE_NUM = 10
LIKE_URL = 9
LOWER = 66
MORPH = 453
NAMES = ['', 'IS_ALPHA', 'IS_ASCII', 'IS_DIGIT', 'IS_LOWER', 'IS_PUNCT...
NORM = 67
ORTH = 65
POS = 74
PREFIX = 69
SENT_START = 80
SHAPE = 68
SPACY = 81
SUFFIX = 70
TAG = 75
__test__ = {}
key = 'IDX'
value = 455
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\attrs.cp312-win_amd64.pyd
spacy.blank
Python Library Documentation: function blank in module spacy
blank(name: str, *, vocab: Union[spacy.vocab.Vocab, bool] = True, config: Union[Dict[str, Any], confection._config.Config] = {}, meta: Dict[str, Any] = {}) -> spacy.language.Language
Create a blank nlp object for a given language code.
name (str): The language code, e.g. "en".
vocab (Vocab): A Vocab object. If True, a vocab is created.
config (Dict[str, Any] / Config): Optional config overrides.
meta (Dict[str, Any]): Overrides for nlp.meta.
RETURNS (Language): The nlp object.
spacy.cli
Python Library Documentation: package spacy.cli in spacy
NAME
spacy.cli
PACKAGE CONTENTS
_util
apply
assemble
benchmark_speed
convert
debug_config
debug_data
debug_diff
debug_model
download
evaluate
find_function
find_threshold
info
init_config
init_pipeline
package
pretrain
profile
project (package)
train
validate
SUBMODULES
download_module
FUNCTIONS
link(*args, **kwargs)
As of spaCy v3.0, symlinks like "en" are not supported anymore. You can load trained
pipeline packages using their full names or from a directory path.
DATA
app = <typer.main.Typer object>
msg = <wasabi.printer.Printer object>
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\cli\__init__.py
spacy.compat
Python Library Documentation: module spacy.compat in spacy
NAME
spacy.compat - Helpers for Python and platform compatibility.
DATA
CudaStream = None
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
cupy = None
is_linux = False
is_osx = False
is_windows = True
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\compat.py
spacy.displacy
Python Library Documentation: package spacy.displacy in spacy
NAME
spacy.displacy - spaCy's built in visualization suite for dependencies and named entities.
DESCRIPTION
DOCS: https://spacy.io/api/top-level#displacy
USAGE: https://spacy.io/usage/visualizers
PACKAGE CONTENTS
render
templates
FUNCTIONS
app(environ, start_response)
get_doc_settings(doc: spacy.tokens.doc.Doc) -> Dict[str, Any]
parse_deps(orig_doc: Union[spacy.tokens.doc.Doc, spacy.tokens.span.Span], options: Dict[str, Any] = {}) -> Dict[str, Any]
Generate dependency parse in {'words': [], 'arcs': []} format.
orig_doc (Union[Doc, Span]): Document to parse.
options (Dict[str, Any]): Dependency parse specific visualisation options.
RETURNS (dict): Generated dependency parse keyed by words and arcs.
parse_ents(doc: spacy.tokens.doc.Doc, options: Dict[str, Any] = {}) -> Dict[str, Any]
Generate named entities in [{start: i, end: i, label: 'label'}] format.
doc (Doc): Document to parse.
options (Dict[str, Any]): NER-specific visualisation options.
RETURNS (dict): Generated entities keyed by text (original text) and ents.
parse_spans(doc: spacy.tokens.doc.Doc, options: Dict[str, Any] = {}) -> Dict[str, Any]
Generate spans in [{start_token: i, end_token: i, label: 'label'}] format.
doc (Doc): Document to parse.
options (Dict[str, any]): Span-specific visualisation options.
RETURNS (dict): Generated span types keyed by text (original text) and spans.
render(docs: Union[Iterable[Union[spacy.tokens.doc.Doc, spacy.tokens.span.Span, dict]], spacy.tokens.doc.Doc, spacy.tokens.span.Span, dict], style: str = 'dep', page: bool = False, minify: bool = False, jupyter: Optional[bool] = None, options: Dict[str, Any] = {}, manual: bool = False) -> str
Render displaCy visualisation.
docs (Union[Iterable[Union[Doc, Span, dict]], Doc, Span, dict]]): Document(s) to visualise.
a 'dict' is only allowed here when 'manual' is set to True
style (str): Visualisation style, 'dep' or 'ent'.
page (bool): Render markup as full HTML page.
minify (bool): Minify HTML markup.
jupyter (bool): Override Jupyter auto-detection.
options (dict): Visualiser-specific options, e.g. colors.
manual (bool): Don't parse `Doc` and instead expect a dict/list of dicts.
RETURNS (str): Rendered SVG or HTML markup.
DOCS: https://spacy.io/api/top-level#displacy.render
USAGE: https://spacy.io/usage/visualizers
serve(docs: Union[Iterable[spacy.tokens.doc.Doc], spacy.tokens.doc.Doc], style: str = 'dep', page: bool = True, minify: bool = False, options: Dict[str, Any] = {}, manual: bool = False, port: int = 5000, host: str = '0.0.0.0', auto_select_port: bool = False) -> None
Serve displaCy visualisation.
docs (list or Doc): Document(s) to visualise.
style (str): Visualisation style, 'dep' or 'ent'.
page (bool): Render markup as full HTML page.
minify (bool): Minify HTML markup.
options (dict): Visualiser-specific options, e.g. colors.
manual (bool): Don't parse `Doc` and instead expect a dict/list of dicts.
port (int): Port to serve visualisation.
host (str): Host to serve visualisation.
auto_select_port (bool): Automatically select a port if the specified port is in use.
DOCS: https://spacy.io/api/top-level#displacy.serve
USAGE: https://spacy.io/usage/visualizers
set_render_wrapper(func: Callable[[str], str]) -> None
Set an optional wrapper function that is called around the generated
HTML markup on displacy.render. This can be used to allow integration into
other platforms, similar to Jupyter Notebooks that require functions to be
called around the HTML. It can also be used to implement custom callbacks
on render, or to embed the visualization in a custom page.
func (callable): Function to call around markup before rendering it. Needs
to take one argument, the HTML markup, and should return the desired
output of displacy.render.
DATA
Callable = typing.Callable
Deprecated alias to collections.abc.Callable.
Callable[[int], str] signifies a function that takes a single
parameter of type int and returns a str.
The subscription syntax must always be used with exactly two
values: the argument list and the return type.
The argument list must be a list of types, a ParamSpec,
Concatenate or ellipsis. The return type must be a single type.
There is no syntax to indicate optional or keyword arguments;
such function types are rarely used as callback types.
Dict = typing.Dict
A generic version of dict.
Iterable = typing.Iterable
A generic version of collections.abc.Iterable.
Optional = typing.Optional
Optional[X] is equivalent to Union[X, None].
RENDER_WRAPPER = None
Union = typing.Union
Union type; Union[X, Y] means either X or Y.
On Python 3.10 and higher, the | operator
can also be used to denote unions;
X | Y means the same thing to the type checker as Union[X, Y].
To define a union, use e.g. Union[int, str]. Details:
- The arguments must be types and there must be at least one.
- None as an argument is a special case and is replaced by
type(None).
- Unions of unions are flattened, e.g.::
assert Union[Union[int, str], float] == Union[int, str, float]
- Unions of a single argument vanish, e.g.::
assert Union[int] == int # The constructor actually returns int
- Redundant arguments are skipped, e.g.::
assert Union[int, str, int] == Union[int, str]
- When comparing unions, the argument order is ignored, e.g.::
assert Union[int, str] == Union[str, int]
- You cannot subclass or instantiate a union.
- You can use Optional[X] as a shorthand for Union[X, None].
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\displacy\__init__.py
spacy.errors
Python Library Documentation: module spacy.errors in spacy
NAME
spacy.errors
CLASSES
builtins.ValueError(builtins.Exception)
MatchPatternError
builtins.object
Errors
Warnings
builtins.type(builtins.object)
ErrorsWithCodes
class Errors(builtins.object)
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| E001 = "[E001] No component '{name}' found in pipeline. Available name...
|
| E002 = "[E002] Can't find factory for '{name}' for langu...r class com...
|
| E003 = '[E003] Not a valid pipeline component. Expected ... it correct...
|
| E004 = "[E004] Can't set up pipeline component: a factor...Existing fa...
|
| E005 = "[E005] Pipeline component '{name}' returned {ret...nt, maybe y...
|
| E006 = '[E006] Invalid constraints for adding pipeline c...onfiguratio...
|
| E007 = "[E007] '{name}' already exists in pipeline. Existing names: {o...
|
| E008 = "[E008] Can't restore disabled pipeline component...ipes` or af...
|
| E010 = '[E010] Word vectors set to length 0. This may be...info, see t...
|
| E011 = "[E011] Unknown operator: '{op}'. Options: {opts}"
|
| E012 = '[E012] Cannot add pattern for zero tokens to matcher.\nKey: {k...
|
| E016 = '[E016] MultitaskObjective target should be funct...r one of: d...
|
| E017 = '[E017] Can only add unicode or bytes. Got type: {value_type}'
|
| E018 = "[E018] Can't retrieve string for hash '{hash_val...rs to an is...
|
| E019 = "[E019] Can't create transition with unknown acti...ion IDs are...
|
| E022 = "[E022] Could not find a transition with the name '{name}' in t...
|
| E024 = '[E024] Could not find an optimal move to supervi...r details, ...
|
| E025 = '[E025] String is too long: {length} characters. Max is 2**30.'
|
| E026 = '[E026] Error accessing token at position {i}: out of bounds in...
|
| E027 = "[E027] Arguments `words` and `spaces` should be ... that the w...
|
| E028 = '[E028] `words` expects a list of unicode strings, but got byte...
|
| E029 = '[E029] `noun_chunks` requires the dependency par... the docume...
|
| E030 = '[E030] Sentence boundaries unset. You can add th...nce boundar...
|
| E031 = "[E031] Invalid token: empty string ('') at position {i}."
|
| E033 = '[E033] Cannot load into non-empty Doc of length {length}.'
|
| E035 = '[E035] Error creating span with start {start} and end {end} fo...
|
| E036 = "[E036] Error calculating span: Can't find a token starting at ...
|
| E037 = "[E037] Error calculating span: Can't find a token ending at ch...
|
| E039 = '[E039] Array bounds exceeded while searching for...ue here: ht...
|
| E040 = '[E040] Attempt to access token at {i}, max length {max_length}...
|
| E041 = '[E041] Invalid comparison operator: {op}. Likely a Cython bug?...
|
| E042 = '[E042] Error accessing `doc[{i}].nbor({j})`, for doc of length...
|
| E043 = '[E043] Refusing to write to token.sent_start if ...arsed, beca...
|
| E044 = '[E044] Invalid value for token.sent_start: {value}. Must be on...
|
| E045 = '[E045] Possibly infinite loop encountered while looking for {a...
|
| E046 = "[E046] Can't retrieve unregistered extension att...id you forg...
|
| E047 = "[E047] Can't assign a value to unregistered exte...id you forg...
|
| E048 = "[E048] Can't import language {lang} or any matching language f...
|
| E050 = "[E050] Can't find model '{name}'. It doesn't see...thon packag...
|
| E052 = "[E052] Can't find model directory: {path}"
|
| E053 = '[E053] Could not read {name} from {path}'
|
| E054 = "[E054] No valid '{setting}' setting found in model meta.json."
|
| E055 = '[E055] Invalid ORTH value in exception:\nKey: {key}\nOrths: {o...
|
| E056 = '[E056] Invalid tokenizer exception: ORTH values ... match orig...
|
| E057 = '[E057] Stepped slices not supported in Span objects. Try: `lis...
|
| E058 = '[E058] Could not retrieve vector for key {key}.'
|
| E059 = '[E059] One (and only one) keyword arg must be set. Got: {kwarg...
|
| E060 = '[E060] Cannot add new key to vectors: the table is full. Curre...
|
| E062 = '[E062] Cannot find empty bit for new lexical fla...`nlp.vocab....
|
| E063 = '[E063] Invalid value for `flag_id`: {value}. Flag IDs must be ...
|
| E064 = '[E064] Error fetching a Lexeme from the Vocab. W...: {string}\...
|
| E065 = "[E065] Only one of the vector table's width and ...e specified...
|
| E067 = "[E067] Invalid BILUO tag sequence: Got a tag sta...B' (beginni...
|
| E068 = "[E068] Invalid BILUO tag: '{tag}'."
|
| E071 = '[E071] Error creating lexeme: specified orth ID ...es not matc...
|
| E073 = '[E073] Cannot assign vector of length {new_lengt... clear the ...
|
| E074 = '[E074] Error interpreting compiled match pattern...o end with ...
|
| E079 = '[E079] Error computing states in beam: number of...) does not ...
|
| E080 = '[E080] Duplicate state found in beam: {key}.'
|
| E081 = '[E081] Error getting gradient in beam: number of...ist}) does ...
|
| E082 = '[E082] Error deprojectivizing parse: number of h...roj_heads})...
|
| E083 = '[E083] Error setting extension: only one of `def... optional `...
|
| E084 = '[E084] Error assigning label ID {label} to span: not in String...
|
| E085 = "[E085] Can't create lexeme for string '{string}'."
|
| E087 = '[E087] Unknown displaCy style: {style}.'
|
| E088 = '[E088] Text of length {length} exceeds maximum o...your inputs...
|
| E089 = "[E089] Extensions can't have a setter argument w.... Check the...
|
| E090 = "[E090] Extension '{name}' already exists on {obj...nsion, set ...
|
| E091 = '[E091] Invalid extension attribute {name}: expected callable o...
|
| E093 = '[E093] token.ent_iob values make invalid sequence: I without B...
|
| E094 = '[E094] Error reading line {line_num} in vectors file {loc}.'
|
| E095 = "[E095] Can't write to frozen dictionary. This is.... Are you w...
|
| E096 = '[E096] Invalid object passed to displaCy: Can on...r Span obje...
|
| E097 = '[E097] Invalid pattern: expected token pattern (...ts) or phra...
|
| E098 = '[E098] Invalid pattern: expected both RIGHT_ID and RIGHT_ATTRS...
|
| E099 = '[E099] Invalid pattern: the first node of patter...ode should ...
|
| E100 = '[E100] Nodes other than the anchor node should a...tain {requi...
|
| E1000 = '[E1000] The Chinese word segmenter is pkuseg but...\nnlp.toke...
|
| E1001 = "[E1001] Target token outside of matched span for...ffset '{in...
|
| E1002 = '[E1002] Span index out of range.'
|
| E1003 = "[E1003] Unsupported lemmatizer mode '{mode}'."
|
| E1004 = '[E1004] Missing lemmatizer table(s) found for le...t to call ...
|
| E1005 = "[E1005] Unable to set attribute '{attr}' in toke...ptions are...
|
| E1007 = "[E1007] Unsupported DependencyMatcher operator '{op}'."
|
| E1008 = '[E1008] Invalid pattern: each pattern should be ...oviding a ...
|
| E101 = '[E101] RIGHT_ID should be a new node and LEFT_ID...lready have...
|
| E1010 = '[E1010] Unable to set entity information for tok...ne span in...
|
| E1011 = "[E1011] Unsupported default '{default}' in `doc.set_ents`. Av...
|
| E1012 = '[E1012] Entity spans and blocked/missing/outside...vided to `...
|
| E1013 = '[E1013] Invalid morph: the MorphAnalysis must ha... value wit...
|
| E1014 = "[E1014] Error loading DocBin data. It doesn't lo...t it using...
|
| E1015 = "[E1015] Can't initialize model from config: no {...ion, run: ...
|
| E1016 = "[E1016] The operators 'OP': '?', '*', and '+' ar...h exactly ...
|
| E1017 = '[E1017] A Doc object requires both \'deps\' and \'h...acehold...
|
| E1018 = "[E1018] Knowledge base for component '{name}' is...el.set_kb`...
|
| E1019 = '[E1019] `noun_chunks` requires the pos tagging, ... the docum...
|
| E102 = "[E102] Can't merge non-disjoint spans. '{token}'...\nhttps://s...
|
| E1020 = '[E1020] No `epoch_resume` value specified and co...e from fil...
|
| E1021 = '[E1021] `pos` value "{pp}" is not a valid Univer...s tag. Non...
|
| E1022 = "[E1022] Words must be of type str or int, but input is of typ...
|
| E1023 = "[E1023] Couldn't read EntityRuler from the {path}. This file ...
|
| E1024 = "[E1024] A pattern with {attr_type} '{label}' is not present i...
|
| E1025 = "[E1025] Cannot intify the value '{value}' as an ...e only sup...
|
| E1026 = '[E1026] Edit tree has an invalid format:\n{errors}'
|
| E1027 = '[E1027] AlignmentArray only supports slicing with a step of 1...
|
| E1028 = '[E1028] AlignmentArray only supports indexing using an int or...
|
| E1029 = '[E1029] Edit tree cannot be applied to form.'
|
| E103 = "[E103] Trying to set conflicting doc.ents: '{spa...pping entit...
|
| E1030 = '[E1030] Edit tree identifier out of range.'
|
| E1031 = '[E1031] Could not find gold transition - see logs above.'
|
| E1032 = '[E1032] `{var}` should not be {forbidden}, but received {valu...
|
| E1033 = '[E1033] Dimension {name} invalid -- only nO, nF, nP'
|
| E1034 = '[E1034] Node index {i} out of bounds ({length})'
|
| E1035 = '[E1035] Token index {i} out of bounds ({length})'
|
| E1036 = '[E1036] Cannot index into NoneNode'
|
| E1037 = "[E1037] Invalid attribute value '{attr}'."
|
| E1038 = '[E1038] Invalid JSON input: {message}'
|
| E1039 = '[E1039] The {obj} start or end annotations (star... {end}) co...
|
| E1040 = '[E1040] Doc.from_json requires all tokens to hav...ns do not ...
|
| E1041 = '[E1041] Expected a string, Doc, or bytes as input, but got: {...
|
| E1042 = '[E1042] `enable={enable}` and `disable={disable}...ously not ...
|
| E1043 = '[E1043] Expected None or a value in range [{rang...d}] for en...
|
| E1044 = '[E1044] Expected `candidates_batch_size` to be >= 1, but got:...
|
| E1045 = "[E1045] Encountered {parent} subclass without `{...thod, make...
|
| E1046 = '[E1046] {cls_name} is an abstract class and cann...s default ...
|
| E1047 = '[E1047] `find_threshold()` only supports components with a `s...
|
| E1048 = "[E1048] Got '{unexpected}' as console progress b...pe, but ex...
|
| E1049 = '[E1049] No available port found for displaCy on ...ilable por...
|
| E1050 = '[E1050] Port {port} is already in use. Please sp...rt=True` t...
|
| E1051 = "[E1051] 'allow_overlap' can only be False when m...e is 1, bu...
|
| E1052 = '[E1052] Unable to copy spans: the character offs...ot align w...
|
| E1053 = "[E1053] Both 'min_length' and 'max_length' shoul...length': {...
|
| E1054 = '[E1054] The text, including whitespace, must mat...nce and pr...
|
| E1055 = "[E1055] The 'replace_listener' callback expects ...lbacks wit...
|
| E1056 = '[E1056] The `TextCatBOW` architecture expects a length of at ...
|
| E1057 = '[E1057] The `TextCatReduce` architecture must be...uce_last`,...
|
| E106 = "[E106] Can't find `doc._.{attr}` attribute specified in the un...
|
| E107 = '[E107] Value of custom attribute `{attr}` is not JSON-serializ...
|
| E109 = "[E109] Component '{name}' could not be run. Did you forget to ...
|
| E110 = '[E110] Invalid displaCy render wrapper. Expected callable, got...
|
| E111 = '[E111] Pickling a token is not supported, becaus...pickling th...
|
| E112 = '[E112] Pickling a span is not supported, because...c to conver...
|
| E115 = '[E115] All subtokens must have associated heads.'
|
| E117 = '[E117] The newly split tokens must match the tex...riginal tok...
|
| E118 = "[E118] The custom extension attribute '{attr}' i...ibute, use ...
|
| E119 = "[E119] Can't set custom extension attribute '{at...with a defa...
|
| E120 = "[E120] Can't set custom extension attributes dur...pping attri...
|
| E121 = "[E121] Can't bulk merge spans. Attribute length ...len} should...
|
| E122 = '[E122] Cannot find token to be split. Did it get merged?'
|
| E123 = '[E123] Cannot find head of token to be split. Did it get merge...
|
| E125 = '[E125] Unexpected value: {value}'
|
| E126 = "[E126] Unexpected matcher predicate: '{bad}'. Ex...ly a bug in...
|
| E130 = '[E130] You are running a narrow unicode build, w... Python and...
|
| E132 = '[E132] The vectors for entities and probabilitie..._length} an...
|
| E133 = "[E133] The sum of prior probabilities for alias '{alias}' shou...
|
| E134 = "[E134] Entity '{entity}' is not defined in the Knowledge Base....
|
| E139 = "[E139] Knowledge base for component '{name}' is empty."
|
| E140 = '[E140] The list of entities, prior probabilities and entity ve...
|
| E141 = '[E141] Entity vectors should be of length {required} instead o...
|
| E143 = "[E143] Labels for component '{name}' not initial... examples t...
|
| E145 = '[E145] Error reading `{param}` from input file.'
|
| E146 = '[E146] Could not access {path}.'
|
| E147 = '[E147] Unexpected error in the {method} function... issue: htt...
|
| E148 = '[E148] Expected {ents} KB identifiers but got {i...ity in `doc...
|
| E149 = '[E149] Error deserializing model. Check that the...ate the com...
|
| E150 = "[E150] The language of the `nlp` object and the ...me, but fou...
|
| E152 = '[E152] The attribute {attr} is not supported for..., EntityRul...
|
| E153 = '[E153] The value type {vtype} is not supported f..., EntityRul...
|
| E154 = '[E154] One of the attributes or values is not su..., PhraseMat...
|
| E155 = '[E155] The pipeline needs to include a {pipe} in...pipe())` in...
|
| E157 = "[E157] Can't render negative values for dependen...rt}, end: {...
|
| E158 = "[E158] Can't add table '{name}' to lookups because it already ...
|
| E159 = "[E159] Can't find table '{name}' in lookups. Available tables:...
|
| E160 = "[E160] Can't find language data file: {path}"
|
| E161 = '[E161] Found an internal inconsistency when pred... issue: htt...
|
| E163 = '[E163] cumsum was found to be unstable: its last element does ...
|
| E164 = '[E164] x is neither increasing nor decreasing: {x}.'
|
| E165 = '[E165] Only one class present in the gold labels...abel}. ROC ...
|
| E166 = '[E166] Can only merge DocBins with the same valu....\nCurrent ...
|
| E169 = "[E169] Can't find module: {module}"
|
| E170 = '[E170] Cannot apply transition {name}: invalid for the current...
|
| E171 = "[E171] Matcher.add received invalid 'on_match' c...t: expected...
|
| E175 = "[E175] Can't remove rule for unknown match pattern ID: {key}"
|
| E176 = "[E176] Alias '{alias}' is not defined in the Knowledge Base."
|
| E177 = '[E177] Ill-formed IOB input detected: {tag}'
|
| E178 = "[E178] Each pattern should be a list of dicts, b...t. For exam...
|
| E179 = "[E179] Invalid pattern. Expected a list of Doc o... list. For ...
|
| E180 = "[E180] Span attributes can't be declared as requ...ttributes) ...
|
| E181 = '[E181] Received invalid attributes for unknown o...rs}. Only D...
|
| E182 = '[E182] Received invalid attribute declaration: {...o define th...
|
| E183 = '[E183] Received invalid attribute declaration: {...attributes ...
|
| E184 = '[E184] Only attributes without underscores are s...utes are co...
|
| E185 = "[E185] Received invalid attribute in component a...ttr}`\nAttr...
|
| E187 = '[E187] Only unicode strings are supported as labels.'
|
| E189 = '[E189] Each argument to `Doc.__init__` should be of equal leng...
|
| E190 = '[E190] Token head out of range in `Doc.from_arra... index rath...
|
| E191 = '[E191] Invalid head: the head token must be from the same doc ...
|
| E192 = '[E192] Unable to resize vectors in place with cupy.'
|
| E193 = '[E193] Unable to resize vectors in place if the ...ame as the ...
|
| E194 = "[E194] Unable to aligned mismatched text '{text}' and words '{...
|
| E195 = '[E195] Matcher can be called on {good} only, got {got}.'
|
| E196 = '[E196] Refusing to write to `token.is_sent_end`....ies can onl...
|
| E197 = '[E197] Row out of bounds, unable to add row {row} for key {key...
|
| E198 = '[E198] Unable to return {n} most similar vectors...t vectors t...
|
| E199 = '[E199] Unable to merge 0-length span at `doc[{start}:{end}]`.'
|
| E200 = "[E200] Can't set {attr} from Span."
|
| E202 = "[E202] Unsupported {name} mode '{mode}'. Supported modes: {mod...
|
| E203 = "[E203] If the {name} embedding layer is not upda...ake sure to...
|
| E849 = '[E849] The vocab only supports {method} for vect...f type spac...
|
| E850 = '[E850] The PretrainVectors objective currently o...ts default ...
|
| E851 = "[E851] The 'textcat' component labels should only have values ...
|
| E853 = "[E853] Unsupported component factory name '{name... character ...
|
| E854 = "[E854] Unable to set doc.ents. Check that the 'ents_filter' do...
|
| E855 = '[E855] Invalid {obj}: {obj} is not from the same doc.'
|
| E856 = '[E856] Error accessing span at position {i}: out of bounds in ...
|
| E857 = "[E857] Entry '{name}' not found in edit tree lemmatizer labels...
|
| E858 = '[E858] The {mode} vector table does not support this operation...
|
| E859 = '[E859] The floret vector table cannot be modified.'
|
| E860 = "[E860] Can't truncate floret vectors."
|
| E861 = "[E861] No 'keys' should be provided when initializing floret v...
|
| E862 = "[E862] 'hash_count' must be between 1-4 for floret vectors."
|
| E863 = "[E863] 'maxn' must be greater than or equal to 'minn'."
|
| E864 = "[E864] The complete vector table 'data' is required to initial...
|
| E865 = '[E865] A SpanGroup is not functional after the c...is still av...
|
| E866 = "[E866] Expected a string or 'Doc' as input, but got: {type}."
|
| E867 = "[E867] The 'textcat' component requires at least...he 'textcat...
|
| E868 = '[E868] Found a conflicting gold annotation in a ...ld ents as ...
|
| E869 = "[E869] The notation '{label}' is not supported a...t_spans_key...
|
| E870 = "[E870] Could not serialize the DocBin because it... a director...
|
| E871 = '[E871] Error encountered in nlp.pipe with multiprocessing:\n\n...
|
| E872 = '[E872] Unable to copy tokenizer from base model ...ig "{curr_c...
|
| E873 = '[E873] Unable to merge a span from doc.spans wit... issue: htt...
|
| E874 = "[E874] Could not initialize the tok2vec model from component '...
|
| E875 = '[E875] To use the PretrainVectors objective, mak...se are defi...
|
| E879 = "[E879] Unexpected type for 'spans' data. Provide... be optiona...
|
| E884 = '[E884] The pipeline could not be initialized bec..., or initia...
|
| E885 = '[E885] entity_linker.set_kb received an invalid ...expected a ...
|
| E886 = "[E886] Can't replace {name} -> {tok2vec} listene...ath}' not f...
|
| E887 = "[E887] Can't replace {name} -> {tok2vec} listene...available l...
|
| E888 = "[E888] Can't replace listeners for '{name}' ({pi...isteners ma...
|
| E889 = "[E889] Can't replace '{tok2vec}' listeners of co...isteners ma...
|
| E890 = "[E890] Cannot add the alias '{alias}' to the Kno...e base. Eac...
|
| E891 = "[E891] Alias '{alias}' could not be added to the Knowledge bas...
|
| E892 = "[E892] Unknown function registry: '{name}'.\n\nAvailable names...
|
| E893 = "[E893] Could not find function '{name}' in funct...n your envi...
|
| E894 = "[E894] The 'noun_chunks' syntax iterator is not implemented fo...
|
| E895 = "[E895] The 'textcat' component received gold-sta...tead. Examp...
|
| E896 = "[E896] There was an error using the static vecto...alized, or ...
|
| E897 = "[E897] Field '{field}' should be a dot-notation ...ion in the ...
|
| E898 = "[E898] Can't serialize trainable pipe '{name}': ...`self.model...
|
| E899 = "[E899] Can't serialize trainable pipe '{name}': ...`self.vocab...
|
| E900 = '[E900] Could not run the full pipeline for evalu...nitialized ...
|
| E901 = '[E901] Failed to remove existing output director...the existin...
|
| E902 = '[E902] The sentence-per-line IOB/IOB2 file is no... delimiters...
|
| E903 = '[E903] The token-per-line NER file is not format... delimiters...
|
| E904 = '[E904] Cannot initialize StaticVectors layer: nO...th, after t...
|
| E905 = '[E905] Cannot initialize StaticVectors layer: nM...mension ref...
|
| E906 = "[E906] Unexpected `loss` value in pretraining ob...ive: '{foun...
|
| E908 = "[E908] Can't set `spaces` without `words` in `Doc.__init__`."
|
| E909 = '[E909] Expected {name} in parser internals. This is likely a b...
|
| E910 = "[E910] Encountered NaN value when computing loss for component...
|
| E911 = '[E911] Invalid feature: {feat}. Must be a token attribute.'
|
| E912 = "[E912] Failed to initialize lemmatizer. Missing ...ode}'. Requ...
|
| E913 = "[E913] Corpus path can't be None. Maybe you forg...e it in you...
|
| E914 = '[E914] Executing {name} callback failed. Expecte...t to return...
|
| E915 = "[E915] Can't use score '{name}' to calculate fin...g.score_wei...
|
| E916 = "[E916] Can't log score for '{name}' in table: not a valid scor...
|
| E917 = "[E917] Received invalid value {value} for `state...Parser: onl...
|
| E918 = '[E918] Received invalid value for vocab: {vocab}...acy.vocab.V...
|
| E919 = "[E919] A textcat `positive_label` '{pos_label}' ...n problem w...
|
| E920 = "[E920] The textcat's `positive_label` setting '{...during init...
|
| E921 = '[E921] The method `set_output` can only be calle... the output...
|
| E922 = "[E922] Component '{name}' has been initialized w...t dimension...
|
| E923 = "[E923] It looks like there is no proper sample d... you would ...
|
| E924 = "[E924] The '{name}' component does not seem to b... issue: htt...
|
| E925 = '[E925] Invalid color values for displaCy visuali...nary mappin...
|
| E926 = "[E926] It looks like you're trying to modify `nl... `nlp.disab...
|
| E927 = "[E927] Can't write to frozen list. Maybe you're ...a computed ...
|
| E928 = '[E928] An InMemoryLookupKB can only be serialize...but the pro...
|
| E929 = "[E929] Couldn't read InMemoryLookupKB from {loc}. The path doe...
|
| E930 = '[E930] Received invalid get_examples callback in...rns an iter...
|
| E931 = "[E931] Encountered {parent} subclass without `{p...thod, make ...
|
| E940 = '[E940] Found NaN values in scores.'
|
| E941 = '[E941] Can\'t find model \'{name}\'. It looks like ...del, use...
|
| E942 = '[E942] Executing `after_{name}` callback failed....t to return...
|
| E943 = '[E943] Executing `before_creation` callback fail...n or return...
|
| E944 = "[E944] Can't copy pipeline component '{name}' fr...t found in ...
|
| E945 = "[E945] Can't copy pipeline component '{name}' fr...ce. Expecte...
|
| E947 = "[E947] `Matcher.add` received invalid `greedy` a...d a string ...
|
| E948 = "[E948] `Matcher.add` received invalid 'patterns' argument: exp...
|
| E949 = '[E949] Unable to align tokens for the predicted ... with: {x}....
|
| E952 = "[E952] The section '{name}' is not a valid section in the prov...
|
| E953 = '[E953] Mismatched IDs received by the Tok2Vec listener: {id1} ...
|
| E954 = '[E954] The Tok2Vec listener did not receive any valid input fr...
|
| E955 = "[E955] Can't find table(s) {table} for language ... default lo...
|
| E956 = "[E956] Can't find component '{name}' in [compone...block in th...
|
| E957 = '[E957] Writing directly to `Language.factories` ...n component...
|
| E958 = '[E958] Language code defined in config ({bad_lan...ass with th...
|
| E959 = "[E959] Can't insert component {dir} index {idx}. Existing comp...
|
| E960 = "[E960] No config data found for component '{name}'. This is li...
|
| E961 = '[E961] Found non-serializable Python object in c...nitialize t...
|
| E962 = "[E962] Received incorrect {style} for pipe '{name}'. Expected ...
|
| E963 = "[E963] Can't read component info from `@Language...decorator}(...
|
| E964 = "[E964] The pipeline component factory for '{name...sed to iden...
|
| E965 = "[E965] It looks like you're using the `@Language...n, use the ...
|
| E966 = "[E966] `nlp.add_pipe` now takes the string name ...add_pipe('y...
|
| E967 = "[E967] No {meta} meta information found for '{name}'. This is ...
|
| E968 = "[E968] `nlp.replace_pipe` now takes the string n...en run `nlp...
|
| E969 = "[E969] Expected string values for field '{field}', but receive...
|
| E970 = "[E970] Can not execute command '{str_command}'. Do you have '{...
|
| E971 = '[E971] Found incompatible lengths in `Doc.from_a...or the arra...
|
| E972 = "[E972] `Example.__init__` got None for '{arg}'. Requires Doc."
|
| E973 = '[E973] Unexpected type for NER data'
|
| E974 = '[E974] Unknown {obj} attribute: {key}'
|
| E976 = '[E976] The method `Example.from_dict` expects a {type} as {n} ...
|
| E977 = '[E977] Can not compare a MorphAnalysis with a st... issue: htt...
|
| E978 = '[E978] The {name} method takes a list of Example objects, but ...
|
| E980 = '[E980] Each link annotation should refer to a di...identifier ...
|
| E981 = '[E981] The offsets of the annotations for `links` could not be...
|
| E982 = '[E982] The `Token.ent_iob` attribute should be an integer inde...
|
| E983 = "[E983] Invalid key(s) for '{dict}': {key}. Available keys: {ke...
|
| E984 = "[E984] Invalid component config for '{name}': co...ill copy th...
|
| E985 = "[E985] Can't load model from config file: no [nlp] section fou...
|
| E986 = '[E986] Could not create any training batches: ch...efined? Is ...
|
| E989 = '[E989] `nlp.update()` was called with two positi...objects, in...
|
| E991 = '[E991] The function `nlp.select_pipes` should be...hat specifi...
|
| E992 = '[E992] The function `select_pipes` was called wi...g for the `...
|
| E993 = "[E993] The config for the nlp object needs to in...'en' for En...
|
| E997 = "[E997] Tokenizer special cases are not allowed t... '{orth}' g...
|
| E999 = '[E999] Unable to merge the Doc objects because they do not all...
class ErrorsWithCodes(builtins.type)
| Method resolution order:
| ErrorsWithCodes
| builtins.type
| builtins.object
|
| Methods defined here:
|
| __getattribute__(self, code)
| Return getattr(self, name).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.type:
|
| __call__(self, /, *args, **kwargs)
| Call self as a function.
|
| __delattr__(self, name, /)
| Implement delattr(self, name).
|
| __dir__(self, /)
| Specialized __dir__ implementation for types.
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __instancecheck__(self, instance, /)
| Check if an object is an instance.
|
| __or__(self, value, /)
| Return self|value.
|
| __repr__(self, /)
| Return repr(self).
|
| __ror__(self, value, /)
| Return value|self.
|
| __setattr__(self, name, value, /)
| Implement setattr(self, name, value).
|
| __sizeof__(self, /)
| Return memory consumption of the type object.
|
| __subclasscheck__(self, subclass, /)
| Check if a class is a subclass.
|
| __subclasses__(self, /)
| Return a list of immediate subclasses.
|
| mro(self, /)
| Return a type's method resolution order.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.type:
|
| __prepare__(...)
| __prepare__() -> dict
| used to create the namespace for the class statement
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.type:
|
| __new__(*args, **kwargs) class method of builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.type:
|
| __abstractmethods__
|
| __dict__
|
| __text_signature__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from builtins.type:
|
| __base__ = <class 'type'>
| type(object) -> the object's type
| type(name, bases, dict, **kwds) -> a new type
|
|
| __bases__ = (<class 'type'>,)
|
| __basicsize__ = 920
|
| __dictoffset__ = 264
|
| __flags__ = 2156420608
|
| __itemsize__ = 40
|
| __mro__ = (<class 'spacy.errors.ErrorsWithCodes'>, <class 'type'>, <cl...
|
| __type_params__ = ()
|
| __weakrefoffset__ = 368
class MatchPatternError(builtins.ValueError)
| MatchPatternError(key, errors)
|
| Method resolution order:
| MatchPatternError
| builtins.ValueError
| builtins.Exception
| builtins.BaseException
| builtins.object
|
| Methods defined here:
|
| __init__(self, key, errors)
| Custom error for validating match patterns.
|
| key (str): The name of the matcher rule.
| errors (dict): Validation errors (sequence of strings) mapped to pattern
| ID, i.e. the index of the added pattern.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.ValueError:
|
| __new__(*args, **kwargs) class method of builtins.ValueError
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.BaseException:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__(...)
|
| __str__(self, /)
| Return str(self).
|
| add_note(...)
| Exception.add_note(note) --
| add a note to the exception
|
| with_traceback(...)
| Exception.with_traceback(tb) --
| set self.__traceback__ to tb and return self.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.BaseException:
|
| __cause__
| exception cause
|
| __context__
| exception context
|
| __dict__
|
| __suppress_context__
|
| __traceback__
|
| args
class Warnings(builtins.object)
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| W005 = '[W005] Doc object not parsed. This means displaC...info, see t...
|
| W006 = '[W006] No entities to visualize found in Doc obj...ck the `doc...
|
| W007 = "[W007] The model you're using has no word vector...se one of t...
|
| W008 = '[W008] Evaluating {obj}.similarity based on empty vectors.'
|
| W011 = "[W011] It looks like you're calling displacy.ser...e with disp...
|
| W012 = "[W012] A Doc object you're adding to the PhraseM...ream using ...
|
| W017 = "[W017] Alias '{alias}' already exists in the Knowledge Base."
|
| W018 = "[W018] Entity '{entity}' already exists in the Knowledge Base ...
|
| W021 = '[W021] Unexpected hash collision in PhraseMatche...rect. Modif...
|
| W024 = "[W024] Entity '{entity}' - Alias '{alias}' combination already...
|
| W026 = '[W026] Unable to set all sentence boundaries fro... Doc(words,...
|
| W027 = '[W027] Found a large training file of {size} byt...ng data int...
|
| W028 = '[W028] Doc.from_array was called with a vector o...oblems with...
|
| W030 = "[W030] Some entities could not be aligned in the...d entities ...
|
| W033 = '[W033] Training a new {model} using a model with...1"\nlang = ...
|
| W035 = "[W035] Discarding subpattern '{pattern}' due to an unrecognize...
|
| W036 = "[W036] The component '{name}' does not have any patterns defin...
|
| W086 = "[W086] Component '{listener}' will be (re)traine...s://spacy.i...
|
| W087 = "[W087] Component '{name}' will be (re)trained, b...acy.io/usag...
|
| W088 = '[W088] The pipeline component {name} implements ...details: ht...
|
| W089 = '[W089] As of spaCy v3.0, the `nlp.begin_training` method has b...
|
| W090 = "[W090] Could not locate any {format} files in path '{path}'."
|
| W091 = '[W091] Could not clean/remove the temp directory at {dir}: {ms...
|
| W092 = '[W092] Ignoring annotations for sentence starts, as dependency...
|
| W093 = '[W093] Could not find any data to train the {name} on. Is your...
|
| W094 = "[W094] Model '{model}' ({model_version}) specifi...ith a lower...
|
| W095 = "[W095] Model '{model}' ({model_version}) was tra... available ...
|
| W096 = '[W096] The method `nlp.disable_pipes` is now deprecated - use ...
|
| W100 = '[W100] Skipping unsupported morphological featur...} or string...
|
| W101 = "[W101] Skipping Doc custom extension '{name}' while merging do...
|
| W102 = "[W102] Skipping unsupported user data '{key}: {value}' while m...
|
| W103 = "[W103] Unknown {lang} word segmenter '{segmenter...segmenters:...
|
| W104 = "[W104] Skipping modifications for '{target}' segmenter. The cu...
|
| W105 = '[W105] As of spaCy v3.0, the `{matcher}.pipe` me....pipe` and ...
|
| W107 = '[W107] The property `Doc.{prop}` is deprecated. Use `Doc.has_a...
|
| W108 = "[W108] The rule-based lemmatizer did not find PO...ly 'tagger'...
|
| W109 = '[W109] Unable to save user hooks while serializi... required u...
|
| W110 = '[W110] The DependencyMatcher token pattern {patt...urn matches...
|
| W111 = '[W111] Jupyter notebook detected: if using `pref...on: http://...
|
| W112 = '[W112] The model specified to use for initial ve...s no vector...
|
| W113 = "[W113] Sourced component '{name}' may not work a...rs are not ...
|
| W114 = '[W114] Using multiprocessing with GPU models is not recommende...
|
| W115 = '[W115] Skipping {method}: the floret vector tabl...ed. Vectors...
|
| W116 = "[W116] Unable to clean attribute '{attr}'."
|
| W117 = '[W117] No spans to visualize found in Doc object...ty manually...
|
| W118 = '[W118] Term \'{term}\' not found in glossary. It m...eck `nlp....
|
| W119 = "[W119] Overriding pipe name in `config` is not supported. Igno...
|
| W120 = '[W120] Unable to load all spans in Doc.spans: mo.... Skipping ...
|
| W121 = "[W121] Attempting to trace non-existent method '{method}' in p...
|
| W122 = "[W122] Couldn't trace method '{method}' in pipe ...pen if the ...
|
| W123 = '[W123] Argument `enable` with value {enable} doe...s might aff...
|
| W124 = '[W124] {host}:{port} is already in use, using th...st availabl...
|
| W125 = "[W125] The StaticVectors key_attr is no longer u...ugh Vectors...
|
| W126 = '[W126] These keys are unsupported: {unsupported}'
|
| W127 = '[W127] Not all `Language.pipe` worker processes completed succ...
FUNCTIONS
filter_warning(action: Literal['default', 'error', 'ignore', 'always', 'module', 'once'], error_msg: str)
Customize how spaCy should handle a certain warning.
error_msg (str): e.g. "W006", or a full error message
action (str): "default", "error", "ignore", "always", "module" or "once"
setup_default_warnings()
DATA
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
OLD_MODEL_SHORTCUTS = {'de': 'de_core_news_sm', 'el': 'el_core_news_sm...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\errors.py
spacy.explain
Python Library Documentation: function explain in module spacy.glossary
explain(term)
Get a description for a given POS tag, dependency label or entity type.
term (str): The term to explain.
RETURNS (str): The explanation, or `None` if not found in the glossary.
EXAMPLE:
>>> spacy.explain(u'NORP')
>>> doc = nlp(u'Hello world')
>>> print([w.text, w.tag_, spacy.explain(w.tag_) for w in doc])
spacy.git_info
Python Library Documentation: module spacy.git_info in spacy
NAME
spacy.git_info
DESCRIPTION
# THIS FILE IS GENERATED FROM SPACY SETUP.PY
#
DATA
GIT_VERSION = '0069cf9'
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\git_info.py
spacy.glossary
Python Library Documentation: module spacy.glossary in spacy
NAME
spacy.glossary
FUNCTIONS
explain(term)
Get a description for a given POS tag, dependency label or entity type.
term (str): The term to explain.
RETURNS (str): The explanation, or `None` if not found in the glossary.
EXAMPLE:
>>> spacy.explain(u'NORP')
>>> doc = nlp(u'Hello world')
>>> print([w.text, w.tag_, spacy.explain(w.tag_) for w in doc])
DATA
GLOSSARY = {'""': 'closing quotation mark', '#': 'symbol, number sign'...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\glossary.py
spacy.info
Python Library Documentation: function info in module spacy.cli.info info(model: Optional[str] = None, *, markdown: bool = False, silent: bool = True, exclude: Optional[List[str]] = None, url: bool = False) -> Union[str, dict]
spacy.kb
Python Library Documentation: package spacy.kb in spacy
NAME
spacy.kb
PACKAGE CONTENTS
candidate
kb
kb_in_memory
CLASSES
builtins.object
spacy.kb.candidate.Candidate
spacy.kb.kb.KnowledgeBase
spacy.kb.kb_in_memory.InMemoryLookupKB
class Candidate(builtins.object)
| Candidate(KnowledgeBase kb, entity_hash, entity_freq, entity_vector, alias_hash, prior_prob)
|
| A `Candidate` object refers to a textual mention (`alias`) that may or
| may not be resolved to a specific `entity` from a Knowledge Base. This
| will be used as input for the entity linking algorithm which will
| disambiguate the various candidates to the correct one.
| Each candidate (alias, entity) pair is assigned a certain prior probability.
|
| DOCS: https://spacy.io/api/kb/#candidate-init
|
| Methods defined here:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __reduce__ = __reduce_cython__(...)
| Candidate.__reduce_cython__(self)
|
| __reduce_cython__(self)
| Candidate.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| Candidate.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| Candidate.__setstate_cython__(self, __pyx_state)
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| alias
| Candidate.alias: int
|
| RETURNS (uint64): hash of the alias
|
| alias_
| Candidate.alias_: str
|
| RETURNS (str): ID of the original alias
|
| entity
| Candidate.entity: int
|
| RETURNS (uint64): hash of the entity's KB ID/name
|
| entity_
| Candidate.entity_: str
|
| RETURNS (str): ID/name of this entity in the KB
|
| entity_freq
| Candidate.entity_freq: float
|
| entity_vector
| Candidate.entity_vector: Iterable[float]
|
| kb
|
| prior_prob
| Candidate.prior_prob: float
class InMemoryLookupKB(spacy.kb.kb.KnowledgeBase)
| InMemoryLookupKB(Vocab vocab, entity_vector_length)
|
| An `InMemoryLookupKB` instance stores unique identifiers for entities
| and their textual aliases, to support entity linking of named entities to
| real-world concepts.
|
| DOCS: https://spacy.io/api/inmemorylookupkb
|
| Method resolution order:
| InMemoryLookupKB
| spacy.kb.kb.KnowledgeBase
| builtins.object
|
| Methods defined here:
|
| __init__(...)
| Create an InMemoryLookupKB.
|
| __len__(self, /)
| Return len(self).
|
| __reduce__ = __reduce_cython__(...)
| InMemoryLookupKB.__reduce_cython__(self)
|
| __reduce_cython__(self)
| InMemoryLookupKB.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| InMemoryLookupKB.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| InMemoryLookupKB.__setstate_cython__(self, __pyx_state)
|
| add_alias(self, alias, entities, probabilities)
| InMemoryLookupKB.add_alias(self, str alias, entities, probabilities)
|
| For a given alias, add its potential entities and prior probabilies to the KB.
| Return the alias_hash at the end
|
| add_entity(self, entity, freq, entity_vector)
| InMemoryLookupKB.add_entity(self, str entity, float freq, vector[float] entity_vector)
|
| Add an entity to the KB, optionally specifying its log probability
| based on corpus frequency.
| Return the hash of the entity ID/name at the end.
|
| append_alias(self, alias, entity, prior_prob, ignore_warnings=False)
| InMemoryLookupKB.append_alias(self, str alias, str entity, float prior_prob, ignore_warnings=False)
|
| For an alias already existing in the KB, extend its potential entities
| with one more.
| Throw a warning if either the alias or the entity is unknown,
| or when the combination is already previously recorded.
| Throw an error if this entity+prior prob would exceed the sum of 1.
| For efficiency, it's best to use the method `add_alias` as much as
| possible instead of this one.
|
| contains_alias(self, alias)
| InMemoryLookupKB.contains_alias(self, str alias)
|
| contains_entity(self, entity)
| InMemoryLookupKB.contains_entity(self, str entity)
|
| from_bytes(self, bytes_data, *, exclude=())
| InMemoryLookupKB.from_bytes(self, bytes_data, *, exclude=tuple())
|
| Load state from a binary string.
|
| from_disk(self, path, exclude: 'Iterable[str]' = [])
| InMemoryLookupKB.from_disk(self, path, exclude: Iterable[str] = SimpleFrozenList())
|
| get_alias_candidates(self, alias) -> 'Iterable[Candidate]'
| InMemoryLookupKB.get_alias_candidates(self, str alias) -> Iterable[Candidate]
|
| Return candidate entities for an alias. Each candidate defines the
| entity, the original alias, and the prior probability of that alias
| resolving to that entity.
| If the alias is not known in the KB, and empty list is returned.
|
| get_alias_strings(self)
| InMemoryLookupKB.get_alias_strings(self)
|
| get_candidates(self, mention: 'Span') -> 'Iterable[Candidate]'
| InMemoryLookupKB.get_candidates(self, mention: Span) -> Iterable[Candidate]
|
| get_entity_strings(self)
| InMemoryLookupKB.get_entity_strings(self)
|
| get_prior_prob(self, entity, alias)
| InMemoryLookupKB.get_prior_prob(self, str entity, str alias)
|
| Return the prior probability of a given alias being linked to a
| given entity, or return 0.0 when this combination is not known in the
| knowledge base.
|
| get_size_aliases(self)
| InMemoryLookupKB.get_size_aliases(self)
|
| get_size_entities(self)
| InMemoryLookupKB.get_size_entities(self)
|
| get_vector(self, entity)
| InMemoryLookupKB.get_vector(self, str entity)
|
| is_empty(self)
| InMemoryLookupKB.is_empty(self)
|
| read_contents(self, file_path)
| InMemoryLookupKB.read_contents(self, file_path)
|
| set_entities(self, entity_list, freq_list, vector_list)
| InMemoryLookupKB.set_entities(self, entity_list, freq_list, vector_list)
|
| to_bytes(self, **kwargs)
| InMemoryLookupKB.to_bytes(self, **kwargs)
|
| Serialize the current state to a binary string.
|
| to_disk(self, path, exclude: 'Iterable[str]' = [])
| InMemoryLookupKB.to_disk(self, path, exclude: Iterable[str] = SimpleFrozenList())
|
| write_contents(self, file_path)
| InMemoryLookupKB.write_contents(self, file_path)
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __pyx_vtable__ = <capsule object NULL>
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.kb.kb.KnowledgeBase:
|
| get_candidates_batch(self, mentions: 'Iterable[Span]') -> 'Iterable[Iterable[Candidate]]'
| KnowledgeBase.get_candidates_batch(self, mentions: Iterable[Span]) -> Iterable[Iterable[Candidate]]
|
| Return candidate entities for specified texts. Each candidate defines
| the entity, the original alias, and the prior probability of that
| alias resolving to that entity.
| If no candidate is found for a given text, an empty list is returned.
| mentions (Iterable[Span]): Mentions for which to get candidates.
| RETURNS (Iterable[Iterable[Candidate]]): Identified candidates.
|
| get_vectors(self, entities: 'Iterable[str]') -> 'Iterable[Iterable[float]]'
| KnowledgeBase.get_vectors(self, entities: Iterable[str]) -> Iterable[Iterable[float]]
|
| Return vectors for entities.
| entity (str): Entity name/ID.
| RETURNS (Iterable[Iterable[float]]): Vectors for specified entities.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.kb.kb.KnowledgeBase:
|
| entity_vector_length
|
| vocab
class KnowledgeBase(builtins.object)
| KnowledgeBase(vocab: Vocab, entity_vector_length: int)
|
| A `KnowledgeBase` instance stores unique identifiers for entities and
| their textual aliases, to support entity linking of named entities to
| real-world concepts.
| This is an abstract class and requires its operations to be implemented.
|
| DOCS: https://spacy.io/api/kb
|
| Methods defined here:
|
| __init__(...)
| Create a KnowledgeBase.
|
| __reduce__ = __reduce_cython__(...)
| KnowledgeBase.__reduce_cython__(self)
|
| __reduce_cython__(self)
| KnowledgeBase.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| KnowledgeBase.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| KnowledgeBase.__setstate_cython__(self, __pyx_state)
|
| from_bytes(self, bytes_data: 'bytes', *, exclude: 'Tuple[str]' = ())
| KnowledgeBase.from_bytes(self, bytes_data: bytes, *, exclude: Tuple[str] = tuple())
|
| Load state from a binary string.
| bytes_data (bytes): KB state.
| exclude (Tuple[str]): Properties to exclude when restoring KB.
|
| from_disk(self, path: 'Union[str, Path]', exclude: 'Iterable[str]' = []) -> 'None'
| KnowledgeBase.from_disk(self, path: Union[str, Path], exclude: Iterable[str] = SimpleFrozenList()) -> None
|
| Load KnowledgeBase content from disk.
| path (Union[str, Path]): Target file path.
| exclude (Iterable[str]): List of components to exclude.
|
| get_candidates(self, mention: 'Span') -> 'Iterable[Candidate]'
| KnowledgeBase.get_candidates(self, mention: Span) -> Iterable[Candidate]
|
| Return candidate entities for specified text. Each candidate defines
| the entity, the original alias,
| and the prior probability of that alias resolving to that entity.
| If the no candidate is found for a given text, an empty list is returned.
| mention (Span): Mention for which to get candidates.
| RETURNS (Iterable[Candidate]): Identified candidates.
|
| get_candidates_batch(self, mentions: 'Iterable[Span]') -> 'Iterable[Iterable[Candidate]]'
| KnowledgeBase.get_candidates_batch(self, mentions: Iterable[Span]) -> Iterable[Iterable[Candidate]]
|
| Return candidate entities for specified texts. Each candidate defines
| the entity, the original alias, and the prior probability of that
| alias resolving to that entity.
| If no candidate is found for a given text, an empty list is returned.
| mentions (Iterable[Span]): Mentions for which to get candidates.
| RETURNS (Iterable[Iterable[Candidate]]): Identified candidates.
|
| get_vector(self, entity) -> 'Iterable[float]'
| KnowledgeBase.get_vector(self, str entity) -> Iterable[float]
|
| Return vector for entity.
| entity (str): Entity name/ID.
| RETURNS (Iterable[float]): Vector for specified entity.
|
| get_vectors(self, entities: 'Iterable[str]') -> 'Iterable[Iterable[float]]'
| KnowledgeBase.get_vectors(self, entities: Iterable[str]) -> Iterable[Iterable[float]]
|
| Return vectors for entities.
| entity (str): Entity name/ID.
| RETURNS (Iterable[Iterable[float]]): Vectors for specified entities.
|
| to_bytes(self, **kwargs) -> 'bytes'
| KnowledgeBase.to_bytes(self, **kwargs) -> bytes
|
| Serialize the current state to a binary string.
| RETURNS (bytes): Current state as binary string.
|
| to_disk(self, path: 'Union[str, Path]', exclude: 'Iterable[str]' = []) -> 'None'
| KnowledgeBase.to_disk(self, path: Union[str, Path], exclude: Iterable[str] = SimpleFrozenList()) -> None
|
| Write KnowledgeBase content to disk.
| path (Union[str, Path]): Target file path.
| exclude (Iterable[str]): List of components to exclude.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| entity_vector_length
|
| vocab
FUNCTIONS
get_candidates(kb: 'KnowledgeBase', mention: 'Span') -> 'Iterable[Candidate]'
get_candidates(kb: KnowledgeBase, mention: Span) -> Iterable[Candidate]
Return candidate entities for a given mention and fetching appropriate
entries from the index.
kb (KnowledgeBase): Knowledge base to query.
mention (Span): Entity mention for which to identify candidates.
RETURNS (Iterable[Candidate]): Identified candidates.
get_candidates_batch(kb: 'KnowledgeBase', mentions: 'Iterable[Span]') -> 'Iterable[Iterable[Candidate]]'
get_candidates_batch(kb: KnowledgeBase, mentions: Iterable[Span]) -> Iterable[Iterable[Candidate]]
Return candidate entities for the given mentions and fetching appropriate entries
from the index.
kb (KnowledgeBase): Knowledge base to query.
mention (Iterable[Span]): Entity mentions for which to identify candidates.
RETURNS (Iterable[Iterable[Candidate]]): Identified candidates.
DATA
__all__ = ['Candidate', 'KnowledgeBase', 'InMemoryLookupKB', 'get_cand...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\kb\__init__.py
spacy.lang
Python Library Documentation: package spacy.lang in spacy
NAME
spacy.lang
PACKAGE CONTENTS
af (package)
am (package)
ar (package)
az (package)
bg (package)
bn (package)
bo (package)
ca (package)
char_classes
cs (package)
da (package)
de (package)
dsb (package)
el (package)
en (package)
es (package)
et (package)
eu (package)
fa (package)
fi (package)
fo (package)
fr (package)
ga (package)
gd (package)
grc (package)
gu (package)
he (package)
hi (package)
hr (package)
hsb (package)
ht (package)
hu (package)
hy (package)
id (package)
is (package)
it (package)
ja (package)
kmr (package)
kn (package)
ko (package)
ky (package)
la (package)
lb (package)
lex_attrs
lg (package)
lij (package)
lt (package)
lv (package)
mk (package)
ml (package)
mr (package)
ms (package)
nb (package)
ne (package)
nl (package)
nn (package)
norm_exceptions
pl (package)
pt (package)
punctuation
ro (package)
ru (package)
sa (package)
si (package)
sk (package)
sl (package)
sq (package)
sr (package)
sv (package)
ta (package)
te (package)
th (package)
ti (package)
tl (package)
tn (package)
tokenizer_exceptions
tr (package)
tt (package)
uk (package)
ur (package)
vi (package)
xx (package)
yo (package)
zh (package)
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\lang\__init__.py
spacy.language
Python Library Documentation: module spacy.language in spacy
NAME
spacy.language
CLASSES
builtins.list(builtins.object)
DisabledPipes
builtins.object
BaseDefaults
FactoryMeta
Language
class BaseDefaults(builtins.object)
| Language data defaults, available via Language.Defaults. Can be
| overwritten by language subclasses by defining their own subclasses of
| Language.Defaults.
|
| Static methods defined here:
|
| url_match = match(string, pos=0, endpos=9223372036854775807) method of re.Pattern instance
| Matches zero or more characters at the beginning of the string.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'config': <class 'confection._config.Config'>, 'inf...
|
| config = {}
|
| infixes = [r'\.\.+', '…', r'[\u00A6\u00A9\u00AE\u00B0\u0482\u058D\u058...
|
| lex_attr_getters = {}
|
| prefixes = ['§', '%', '=', '—', '–', r'\+(?![0-9])', '…', '……', ',', '...
|
| stop_words = set()
|
| suffixes = ['…', '……', ',', ':', ';', r'\!', r'\?', '¿', '؟', '¡', r'\...
|
| syntax_iterators = {}
|
| token_match = None
|
| tokenizer_exceptions = {'\t': [{65: '\t'}], '\n': [{65: '\n'}], ' ': [...
|
| writing_system = {'direction': 'ltr', 'has_case': True, 'has_letters':...
class DisabledPipes(builtins.list)
| DisabledPipes(nlp: spacy.language.Language, names: List[str]) -> None
|
| Manager for temporary pipeline disabling.
|
| Method resolution order:
| DisabledPipes
| builtins.list
| builtins.object
|
| Methods defined here:
|
| __enter__(self)
|
| __exit__(self, *args)
|
| __init__(self, nlp: spacy.language.Language, names: List[str]) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| restore(self) -> None
| Restore the pipeline to its state when DisabledPipes was created.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.list:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, index, /)
| Return self[index].
|
| __gt__(self, value, /)
| Return self>value.
|
| __iadd__(self, value, /)
| Implement self+=value.
|
| __imul__(self, value, /)
| Implement self*=value.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __repr__(self, /)
| Return repr(self).
|
| __reversed__(self, /)
| Return a reverse iterator over the list.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __setitem__(self, key, value, /)
| Set self[key] to value.
|
| __sizeof__(self, /)
| Return the size of the list in memory, in bytes.
|
| append(self, object, /)
| Append object to the end of the list.
|
| clear(self, /)
| Remove all items from list.
|
| copy(self, /)
| Return a shallow copy of the list.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| extend(self, iterable, /)
| Extend list by appending elements from the iterable.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| insert(self, index, object, /)
| Insert object before index.
|
| pop(self, index=-1, /)
| Remove and return item at index (default last).
|
| Raises IndexError if list is empty or index is out of range.
|
| remove(self, value, /)
| Remove first occurrence of value.
|
| Raises ValueError if the value is not present.
|
| reverse(self, /)
| Reverse *IN PLACE*.
|
| sort(self, /, *, key=None, reverse=False)
| Sort the list in ascending order and return None.
|
| The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
| order of two equal elements is maintained).
|
| If a key function is given, apply it once to each list item and sort them,
| ascending or descending, according to their function values.
|
| The reverse flag can be set to sort in descending order.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.list:
|
| __class_getitem__(...)
| See PEP 585
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.list:
|
| __new__(*args, **kwargs) class method of builtins.list
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from builtins.list:
|
| __hash__ = None
class FactoryMeta(builtins.object)
| FactoryMeta(factory: str, default_config: Optional[Dict[str, Any]] = None, assigns: Iterable[str] = (), requires: Iterable[str] = (), retokenizes: bool = False, scores: Iterable[str] = (), default_score_weights: Optional[Dict[str, Optional[float]]] = None) -> None
|
| Dataclass containing information about a component and its defaults
| provided by the @Language.component or @Language.factory decorator. It's
| created whenever a component is defined and stored on the Language class for
| each component instance and factory instance.
|
| Methods defined here:
|
| __eq__(self, other)
| Return self==value.
|
| __init__(self, factory: str, default_config: Optional[Dict[str, Any]] = None, assigns: Iterable[str] = (), requires: Iterable[str] = (), retokenizes: bool = False, scores: Iterable[str] = (), default_score_weights: Optional[Dict[str, Optional[float]]] = None) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'assigns': typing.Iterable[str], 'default_config': ...
|
| __dataclass_fields__ = {'assigns': Field(name='assigns',type=typing.It...
|
| __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
|
| __hash__ = None
|
| __match_args__ = ('factory', 'default_config', 'assigns', 'requires', ...
|
| assigns = ()
|
| default_config = None
|
| default_score_weights = None
|
| requires = ()
|
| retokenizes = False
|
| scores = ()
class Language(builtins.object)
| Language(vocab: Union[spacy.vocab.Vocab, bool] = True, *, max_length: int = 1000000, meta: Dict[str, Any] = {}, create_tokenizer: Optional[Callable[[ForwardRef('Language')], Callable[[str], spacy.tokens.doc.Doc]]] = None, create_vectors: Optional[Callable[[ForwardRef('Vocab')], spacy.vectors.BaseVectors]] = None, batch_size: int = 1000, **kwargs) -> None
|
| A text-processing pipeline. Usually you'll load this once per process,
| and pass the instance around your application.
|
| Defaults (class): Settings, data and factory methods for creating the `nlp`
| object and processing pipeline.
| lang (str): Two-letter ISO 639-1 or three-letter ISO 639-3 language codes, such as 'en' and 'eng'.
|
| DOCS: https://spacy.io/api/language
|
| Methods defined here:
|
| __call__(self, text: Union[str, spacy.tokens.doc.Doc], *, disable: Iterable[str] = [], component_cfg: Optional[Dict[str, Dict[str, Any]]] = None) -> spacy.tokens.doc.Doc
| Apply the pipeline to some text. The text can span multiple sentences,
| and can contain arbitrary whitespace. Alignment into the original string
| is preserved.
|
| text (Union[str, Doc]): If `str`, the text to be processed. If `Doc`,
| the doc will be passed directly to the pipeline, skipping
| `Language.make_doc`.
| disable (List[str]): Names of the pipeline components to disable.
| component_cfg (Dict[str, dict]): An optional dictionary with extra
| keyword arguments for specific components.
| RETURNS (Doc): A container for accessing the annotations.
|
| DOCS: https://spacy.io/api/language#call
|
| __init__(self, vocab: Union[spacy.vocab.Vocab, bool] = True, *, max_length: int = 1000000, meta: Dict[str, Any] = {}, create_tokenizer: Optional[Callable[[ForwardRef('Language')], Callable[[str], spacy.tokens.doc.Doc]]] = None, create_vectors: Optional[Callable[[ForwardRef('Vocab')], spacy.vectors.BaseVectors]] = None, batch_size: int = 1000, **kwargs) -> None
| Initialise a Language object.
|
| vocab (Vocab): A `Vocab` object. If `True`, a vocab is created.
| meta (dict): Custom meta data for the Language class. Is written to by
| models to add model meta data.
| max_length (int): Maximum number of characters in a single text. The
| current models may run out memory on extremely long texts, due to
| large internal allocations. You should segment these texts into
| meaningful units, e.g. paragraphs, subsections etc, before passing
| them to spaCy. Default maximum length is 1,000,000 charas (1mb). As
| a rule of thumb, if all pipeline components are enabled, spaCy's
| default models currently requires roughly 1GB of temporary memory per
| 100,000 characters in one text.
| create_tokenizer (Callable): Function that takes the nlp object and
| returns a tokenizer.
| batch_size (int): Default batch size for pipe and evaluate.
|
| DOCS: https://spacy.io/api/language#init
|
| add_pipe(self, factory_name: str, name: Optional[str] = None, *, before: Union[str, int, NoneType] = None, after: Union[str, int, NoneType] = None, first: Optional[bool] = None, last: Optional[bool] = None, source: Optional[ForwardRef('Language')] = None, config: Dict[str, Any] = {}, raw_config: Optional[confection._config.Config] = None, validate: bool = True) -> Callable[[spacy.tokens.doc.Doc], spacy.tokens.doc.Doc]
| Add a component to the processing pipeline. Valid components are
| callables that take a `Doc` object, modify it and return it. Only one
| of before/after/first/last can be set. Default behaviour is "last".
|
| factory_name (str): Name of the component factory.
| name (str): Name of pipeline component. Overwrites existing
| component.name attribute if available. If no name is set and
| the component exposes no name attribute, component.__name__ is
| used. An error is raised if a name already exists in the pipeline.
| before (Union[str, int]): Name or index of the component to insert new
| component directly before.
| after (Union[str, int]): Name or index of the component to insert new
| component directly after.
| first (bool): If True, insert component first in the pipeline.
| last (bool): If True, insert component last in the pipeline.
| source (Language): Optional loaded nlp object to copy the pipeline
| component from.
| config (Dict[str, Any]): Config parameters to use for this component.
| Will be merged with default config, if available.
| raw_config (Optional[Config]): Internals: the non-interpolated config.
| validate (bool): Whether to validate the component config against the
| arguments and types expected by the factory.
| RETURNS (Callable[[Doc], Doc]): The pipeline component.
|
| DOCS: https://spacy.io/api/language#add_pipe
|
| analyze_pipes(self, *, keys: List[str] = ['assigns', 'requires', 'scores', 'retokenizes'], pretty: bool = False) -> Optional[Dict[str, Any]]
| Analyze the current pipeline components, print a summary of what
| they assign or require and check that all requirements are met.
|
| keys (List[str]): The meta values to display in the table. Corresponds
| to values in FactoryMeta, defined by @Language.factory decorator.
| pretty (bool): Pretty-print the results.
| RETURNS (dict): The data.
|
| begin_training(self, get_examples: Optional[Callable[[], Iterable[spacy.training.example.Example]]] = None, *, sgd: Optional[thinc.optimizers.Optimizer] = None) -> thinc.optimizers.Optimizer
|
| create_optimizer(self)
| Create an optimizer, usually using the [training.optimizer] config.
|
| create_pipe(self, factory_name: str, name: Optional[str] = None, *, config: Dict[str, Any] = {}, raw_config: Optional[confection._config.Config] = None, validate: bool = True) -> Callable[[spacy.tokens.doc.Doc], spacy.tokens.doc.Doc]
| Create a pipeline component. Mostly used internally. To create and
| add a component to the pipeline, you can use nlp.add_pipe.
|
| factory_name (str): Name of component factory.
| name (Optional[str]): Optional name to assign to component instance.
| Defaults to factory name if not set.
| config (Dict[str, Any]): Config parameters to use for this component.
| Will be merged with default config, if available.
| raw_config (Optional[Config]): Internals: the non-interpolated config.
| validate (bool): Whether to validate the component config against the
| arguments and types expected by the factory.
| RETURNS (Callable[[Doc], Doc]): The pipeline component.
|
| DOCS: https://spacy.io/api/language#create_pipe
|
| create_pipe_from_source(self, source_name: str, source: 'Language', *, name: str) -> Tuple[Callable[[spacy.tokens.doc.Doc], spacy.tokens.doc.Doc], str]
| Create a pipeline component by copying it from an existing model.
|
| source_name (str): Name of the component in the source pipeline.
| source (Language): The source nlp object to copy from.
| name (str): Optional alternative name to use in current pipeline.
| RETURNS (Tuple[Callable[[Doc], Doc], str]): The component and its factory name.
|
| disable_pipe(self, name: str) -> None
| Disable a pipeline component. The component will still exist on
| the nlp object, but it won't be run as part of the pipeline. Does
| nothing if the component is already disabled.
|
| name (str): The name of the component to disable.
|
| disable_pipes(self, *names) -> 'DisabledPipes'
| Disable one or more pipeline components. If used as a context
| manager, the pipeline will be restored to the initial state at the end
| of the block. Otherwise, a DisabledPipes object is returned, that has
| a `.restore()` method you can use to undo your changes.
|
| This method has been deprecated since 3.0
|
| enable_pipe(self, name: str) -> None
| Enable a previously disabled pipeline component so it's run as part
| of the pipeline. Does nothing if the component is already enabled.
|
| name (str): The name of the component to enable.
|
| evaluate(self, examples: Iterable[spacy.training.example.Example], *, batch_size: Optional[int] = None, scorer: Optional[spacy.scorer.Scorer] = None, component_cfg: Optional[Dict[str, Dict[str, Any]]] = None, scorer_cfg: Optional[Dict[str, Any]] = None, per_component: bool = False) -> Dict[str, Any]
| Evaluate a model's pipeline components.
|
| examples (Iterable[Example]): `Example` objects.
| batch_size (Optional[int]): Batch size to use.
| scorer (Optional[Scorer]): Scorer to use. If not passed in, a new one
| will be created.
| component_cfg (dict): An optional dictionary with extra keyword
| arguments for specific components.
| scorer_cfg (dict): An optional dictionary with extra keyword arguments
| for the scorer.
| per_component (bool): Whether to return the scores keyed by component
| name. Defaults to False.
|
| RETURNS (Scorer): The scorer containing the evaluation results.
|
| DOCS: https://spacy.io/api/language#evaluate
|
| from_bytes(self, bytes_data: bytes, *, exclude: Iterable[str] = []) -> 'Language'
| Load state from a binary string.
|
| bytes_data (bytes): The data to load from.
| exclude (Iterable[str]): Names of components or serialization fields to exclude.
| RETURNS (Language): The `Language` object.
|
| DOCS: https://spacy.io/api/language#from_bytes
|
| from_disk(self, path: Union[str, pathlib.Path], *, exclude: Iterable[str] = [], overrides: Dict[str, Any] = {}) -> 'Language'
| Loads state from a directory. Modifies the object in place and
| returns it. If the saved `Language` object contains a model, the
| model will be loaded.
|
| path (str / Path): A path to a directory.
| exclude (Iterable[str]): Names of components or serialization fields to exclude.
| RETURNS (Language): The modified `Language` object.
|
| DOCS: https://spacy.io/api/language#from_disk
|
| get_pipe(self, name: str) -> Callable[[spacy.tokens.doc.Doc], spacy.tokens.doc.Doc]
| Get a pipeline component for a given component name.
|
| name (str): Name of pipeline component to get.
| RETURNS (callable): The pipeline component.
|
| DOCS: https://spacy.io/api/language#get_pipe
|
| get_pipe_config(self, name: str) -> confection._config.Config
| Get the config used to create a pipeline component.
|
| name (str): The component name.
| RETURNS (Config): The config used to create the pipeline component.
|
| get_pipe_meta(self, name: str) -> 'FactoryMeta'
| Get the meta information for a given component name.
|
| name (str): The component name.
| RETURNS (FactoryMeta): The meta for the given component name.
|
| has_pipe(self, name: str) -> bool
| Check if a component name is present in the pipeline. Equivalent to
| `name in nlp.pipe_names`.
|
| name (str): Name of the component.
| RETURNS (bool): Whether a component of the name exists in the pipeline.
|
| DOCS: https://spacy.io/api/language#has_pipe
|
| initialize(self, get_examples: Optional[Callable[[], Iterable[spacy.training.example.Example]]] = None, *, sgd: Optional[thinc.optimizers.Optimizer] = None) -> thinc.optimizers.Optimizer
| Initialize the pipe for training, using data examples if available.
|
| get_examples (Callable[[], Iterable[Example]]): Optional function that
| returns gold-standard Example objects.
| sgd (Optional[Optimizer]): An optimizer to use for updates. If not
| provided, will be created using the .create_optimizer() method.
| RETURNS (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/language#initialize
|
| make_doc(self, text: str) -> spacy.tokens.doc.Doc
| Turn a text into a Doc object.
|
| text (str): The text to process.
| RETURNS (Doc): The processed doc.
|
| memory_zone(self, mem: Optional[cymem.cymem.Pool] = None) -> Iterator[cymem.cymem.Pool]
| Begin a block where all resources allocated during the block will
| be freed at the end of it. If a resources was created within the
| memory zone block, accessing it outside the block is invalid.
| Behaviour of this invalid access is undefined. Memory zones should
| not be nested.
|
| The memory zone is helpful for services that need to process large
| volumes of text with a defined memory budget.
|
| Example
| -------
| >>> with nlp.memory_zone():
| ... for doc in nlp.pipe(texts):
| ... process_my_doc(doc)
| >>> # use_doc(doc) <-- Invalid: doc was allocated in the memory zone
|
| pipe(self, texts: Union[Iterable[Union[str, spacy.tokens.doc.Doc]], Iterable[Tuple[Union[str, spacy.tokens.doc.Doc], ~_AnyContext]]], *, as_tuples: bool = False, batch_size: Optional[int] = None, disable: Iterable[str] = [], component_cfg: Optional[Dict[str, Dict[str, Any]]] = None, n_process: int = 1) -> Union[Iterator[spacy.tokens.doc.Doc], Iterator[Tuple[spacy.tokens.doc.Doc, ~_AnyContext]]]
| Process texts as a stream, and yield `Doc` objects in order.
|
| texts (Iterable[Union[str, Doc]]): A sequence of texts or docs to
| process.
| as_tuples (bool): If set to True, inputs should be a sequence of
| (text, context) tuples. Output will then be a sequence of
| (doc, context) tuples. Defaults to False.
| batch_size (Optional[int]): The number of texts to buffer.
| disable (List[str]): Names of the pipeline components to disable.
| component_cfg (Dict[str, Dict]): An optional dictionary with extra keyword
| arguments for specific components.
| n_process (int): Number of processors to process texts. If -1, set `multiprocessing.cpu_count()`.
| YIELDS (Doc): Documents in the order of the original text.
|
| DOCS: https://spacy.io/api/language#pipe
|
| rehearse(self, examples: Iterable[spacy.training.example.Example], *, sgd: Optional[thinc.optimizers.Optimizer] = None, losses: Optional[Dict[str, float]] = None, component_cfg: Optional[Dict[str, Dict[str, Any]]] = None, exclude: Iterable[str] = []) -> Dict[str, float]
| Make a "rehearsal" update to the models in the pipeline, to prevent
| forgetting. Rehearsal updates run an initial copy of the model over some
| data, and update the model so its current predictions are more like the
| initial ones. This is useful for keeping a pretrained model on-track,
| even if you're updating it with a smaller set of examples.
|
| examples (Iterable[Example]): A batch of `Example` objects.
| sgd (Optional[Optimizer]): An optimizer.
| component_cfg (Dict[str, Dict]): Config parameters for specific pipeline
| components, keyed by component name.
| exclude (Iterable[str]): Names of components that shouldn't be updated.
| RETURNS (dict): Results from the update.
|
| EXAMPLE:
| >>> raw_text_batches = minibatch(raw_texts)
| >>> for labelled_batch in minibatch(examples):
| >>> nlp.update(labelled_batch)
| >>> raw_batch = [Example.from_dict(nlp.make_doc(text), {}) for text in next(raw_text_batches)]
| >>> nlp.rehearse(raw_batch)
|
| DOCS: https://spacy.io/api/language#rehearse
|
| remove_pipe(self, name: str) -> Tuple[str, Callable[[spacy.tokens.doc.Doc], spacy.tokens.doc.Doc]]
| Remove a component from the pipeline.
|
| name (str): Name of the component to remove.
| RETURNS (Tuple[str, Callable[[Doc], Doc]]): A `(name, component)` tuple of the removed component.
|
| DOCS: https://spacy.io/api/language#remove_pipe
|
| rename_pipe(self, old_name: str, new_name: str) -> None
| Rename a pipeline component.
|
| old_name (str): Name of the component to rename.
| new_name (str): New name of the component.
|
| DOCS: https://spacy.io/api/language#rename_pipe
|
| replace_listeners(self, tok2vec_name: str, pipe_name: str, listeners: Iterable[str]) -> None
| Find listener layers (connecting to a token-to-vector embedding
| component) of a given pipeline component model and replace
| them with a standalone copy of the token-to-vector layer. This can be
| useful when training a pipeline with components sourced from an existing
| pipeline: if multiple components (e.g. tagger, parser, NER) listen to
| the same tok2vec component, but some of them are frozen and not updated,
| their performance may degrade significantly as the tok2vec component is
| updated with new data. To prevent this, listeners can be replaced with
| a standalone tok2vec layer that is owned by the component and doesn't
| change if the component isn't updated.
|
| tok2vec_name (str): Name of the token-to-vector component, typically
| "tok2vec" or "transformer".
| pipe_name (str): Name of pipeline component to replace listeners for.
| listeners (Iterable[str]): The paths to the listeners, relative to the
| component config, e.g. ["model.tok2vec"]. Typically, implementations
| will only connect to one tok2vec component, [model.tok2vec], but in
| theory, custom models can use multiple listeners. The value here can
| either be an empty list to not replace any listeners, or a complete
| (!) list of the paths to all listener layers used by the model.
|
| DOCS: https://spacy.io/api/language#replace_listeners
|
| replace_pipe(self, name: str, factory_name: str, *, config: Dict[str, Any] = {}, validate: bool = True) -> Callable[[spacy.tokens.doc.Doc], spacy.tokens.doc.Doc]
| Replace a component in the pipeline.
|
| name (str): Name of the component to replace.
| factory_name (str): Factory name of replacement component.
| config (Optional[Dict[str, Any]]): Config parameters to use for this
| component. Will be merged with default config, if available.
| validate (bool): Whether to validate the component config against the
| arguments and types expected by the factory.
| RETURNS (Callable[[Doc], Doc]): The new pipeline component.
|
| DOCS: https://spacy.io/api/language#replace_pipe
|
| resume_training(self, *, sgd: Optional[thinc.optimizers.Optimizer] = None) -> thinc.optimizers.Optimizer
| Continue training a pretrained model.
|
| Create and return an optimizer, and initialize "rehearsal" for any pipeline
| component that has a .rehearse() method. Rehearsal is used to prevent
| models from "forgetting" their initialized "knowledge". To perform
| rehearsal, collect samples of text you want the models to retain performance
| on, and call nlp.rehearse() with a batch of Example objects.
|
| RETURNS (Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/language#resume_training
|
| select_pipes(self, *, disable: Union[str, Iterable[str], NoneType] = None, enable: Union[str, Iterable[str], NoneType] = None) -> 'DisabledPipes'
| Disable one or more pipeline components. If used as a context
| manager, the pipeline will be restored to the initial state at the end
| of the block. Otherwise, a DisabledPipes object is returned, that has
| a `.restore()` method you can use to undo your changes.
|
| disable (str or iterable): The name(s) of the pipes to disable
| enable (str or iterable): The name(s) of the pipes to enable - all others will be disabled
|
| DOCS: https://spacy.io/api/language#select_pipes
|
| set_error_handler(self, error_handler: Callable[[str, Callable[[spacy.tokens.doc.Doc], spacy.tokens.doc.Doc], List[spacy.tokens.doc.Doc], Exception], NoReturn])
| Set an error handler object for all the components in the pipeline
| that implement a set_error_handler function.
|
| error_handler (Callable[[str, Callable[[Doc], Doc], List[Doc], Exception], NoReturn]):
| Function that deals with a failing batch of documents. This callable
| function should take in the component's name, the component itself,
| the offending batch of documents, and the exception that was thrown.
| DOCS: https://spacy.io/api/language#set_error_handler
|
| to_bytes(self, *, exclude: Iterable[str] = []) -> bytes
| Serialize the current state to a binary string.
|
| exclude (Iterable[str]): Names of components or serialization fields to exclude.
| RETURNS (bytes): The serialized form of the `Language` object.
|
| DOCS: https://spacy.io/api/language#to_bytes
|
| to_disk(self, path: Union[str, pathlib.Path], *, exclude: Iterable[str] = []) -> None
| Save the current state to a directory. If a model is loaded, this
| will include the model.
|
| path (str / Path): Path to a directory, which will be created if
| it doesn't exist.
| exclude (Iterable[str]): Names of components or serialization fields to exclude.
|
| DOCS: https://spacy.io/api/language#to_disk
|
| update(self, examples: Iterable[spacy.training.example.Example], _: Optional[Any] = None, *, drop: float = 0.0, sgd: Optional[thinc.optimizers.Optimizer] = None, losses: Optional[Dict[str, float]] = None, component_cfg: Optional[Dict[str, Dict[str, Any]]] = None, exclude: Iterable[str] = [], annotates: Iterable[str] = [])
| Update the models in the pipeline.
|
| examples (Iterable[Example]): A batch of examples
| _: Should not be set - serves to catch backwards-incompatible scripts.
| drop (float): The dropout rate.
| sgd (Optimizer): An optimizer.
| losses (Dict[str, float]): Dictionary to update with the loss, keyed by
| component.
| component_cfg (Dict[str, Dict]): Config parameters for specific pipeline
| components, keyed by component name.
| exclude (Iterable[str]): Names of components that shouldn't be updated.
| annotates (Iterable[str]): Names of components that should set
| annotations on the predicted examples after updating.
| RETURNS (Dict[str, float]): The updated losses dictionary
|
| DOCS: https://spacy.io/api/language#update
|
| use_params(self, params: Optional[dict])
| Replace weights of models in the pipeline with those provided in the
| params dictionary. Can be used as a contextmanager, in which case,
| models go back to their original weights after the block.
|
| params (dict): A dictionary of parameters keyed by model ID.
|
| EXAMPLE:
| >>> with nlp.use_params(optimizer.averages):
| >>> nlp.to_disk("/tmp/checkpoint")
|
| DOCS: https://spacy.io/api/language#use_params
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __init_subclass__(**kwargs)
| This method is called when a class is subclassed.
|
| The default implementation does nothing. It may be
| overridden to extend subclasses.
|
| component(name: str, *, assigns: Iterable[str] = [], requires: Iterable[str] = [], retokenizes: bool = False, func: Optional[Callable[[spacy.tokens.doc.Doc], spacy.tokens.doc.Doc]] = None) -> Callable[..., Any]
| Register a new pipeline component. Can be used for stateless function
| components that don't require a separate factory. Can be used as a
| decorator on a function or classmethod, or called as a function with the
| factory provided as the func keyword argument. To create a component and
| add it to the pipeline, you can use nlp.add_pipe(name).
|
| name (str): The name of the component factory.
| assigns (Iterable[str]): Doc/Token attributes assigned by this component,
| e.g. "token.ent_id". Used for pipeline analysis.
| requires (Iterable[str]): Doc/Token attributes required by this component,
| e.g. "token.ent_id". Used for pipeline analysis.
| retokenizes (bool): Whether the component changes the tokenization.
| Used for pipeline analysis.
| func (Optional[Callable[[Doc], Doc]): Factory function if not used as a decorator.
|
| DOCS: https://spacy.io/api/language#component
|
| factory(name: str, *, default_config: Dict[str, Any] = {}, assigns: Iterable[str] = [], requires: Iterable[str] = [], retokenizes: bool = False, default_score_weights: Dict[str, Optional[float]] = {}, func: Optional[Callable] = None) -> Callable
| Register a new pipeline component factory. Can be used as a decorator
| on a function or classmethod, or called as a function with the factory
| provided as the func keyword argument. To create a component and add
| it to the pipeline, you can use nlp.add_pipe(name).
|
| name (str): The name of the component factory.
| default_config (Dict[str, Any]): Default configuration, describing the
| default values of the factory arguments.
| assigns (Iterable[str]): Doc/Token attributes assigned by this component,
| e.g. "token.ent_id". Used for pipeline analysis.
| requires (Iterable[str]): Doc/Token attributes required by this component,
| e.g. "token.ent_id". Used for pipeline analysis.
| retokenizes (bool): Whether the component changes the tokenization.
| Used for pipeline analysis.
| default_score_weights (Dict[str, Optional[float]]): The scores to report during
| training, and their default weight towards the final score used to
| select the best model. Weights should sum to 1.0 per component and
| will be combined and normalized for the whole pipeline. If None,
| the score won't be shown in the logs or be weighted.
| func (Optional[Callable]): Factory function if not used as a decorator.
|
| DOCS: https://spacy.io/api/language#factory
|
| from_config(config: Union[Dict[str, Any], confection._config.Config] = {}, *, vocab: Union[spacy.vocab.Vocab, bool] = True, disable: Union[str, Iterable[str]] = [], enable: Union[str, Iterable[str]] = [], exclude: Union[str, Iterable[str]] = [], meta: Dict[str, Any] = {}, auto_fill: bool = True, validate: bool = True) -> 'Language'
| Create the nlp object from a loaded config. Will set up the tokenizer
| and language data, add pipeline components etc. If no config is provided,
| the default config of the given language is used.
|
| config (Dict[str, Any] / Config): The loaded config.
| vocab (Vocab): A Vocab object. If True, a vocab is created.
| disable (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to disable.
| Disabled pipes will be loaded but they won't be run unless you
| explicitly enable them by calling nlp.enable_pipe.
| enable (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to enable. All other
| pipes will be disabled (and can be enabled using `nlp.enable_pipe`).
| exclude (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to exclude.
| Excluded components won't be loaded.
| meta (Dict[str, Any]): Meta overrides for nlp.meta.
| auto_fill (bool): Automatically fill in missing values in config based
| on defaults and function argument annotations.
| validate (bool): Validate the component config and arguments against
| the types expected by the factory.
| RETURNS (Language): The initialized Language class.
|
| DOCS: https://spacy.io/api/language#from_config
|
| get_factory_meta(name: str) -> 'FactoryMeta'
| Get the meta information for a given factory name.
|
| name (str): The component factory name.
| RETURNS (FactoryMeta): The meta for the given factory name.
|
| get_factory_name(name: str) -> str
| Get the internal factory name based on the language subclass.
|
| name (str): The factory name.
| RETURNS (str): The internal factory name.
|
| has_factory(name: str) -> bool
| RETURNS (bool): Whether a factory of that name is registered.
|
| set_factory_meta(name: str, value: 'FactoryMeta') -> None
| Set the meta information for a given factory name.
|
| name (str): The component factory name.
| value (FactoryMeta): The meta to set.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| component_names
| Get the names of the available pipeline components. Includes all
| active and inactive pipeline components.
|
| RETURNS (List[str]): List of component name strings, in order.
|
| components
| Get all (name, component) tuples in the pipeline, including the
| currently disabled components.
|
| disabled
| Get the names of all disabled components.
|
| RETURNS (List[str]): The disabled components.
|
| factory_names
| Get names of all available factories.
|
| RETURNS (List[str]): The factory names.
|
| path
|
| pipe_factories
| Get the component factories for the available pipeline components.
|
| RETURNS (Dict[str, str]): Factory names, keyed by component names.
|
| pipe_labels
| Get the labels set by the pipeline components, if available (if
| the component exposes a labels property and the labels are not
| hidden).
|
| RETURNS (Dict[str, List[str]]): Labels keyed by component name.
|
| pipe_names
| Get names of available active pipeline components.
|
| RETURNS (List[str]): List of component name strings, in order.
|
| pipeline
| The processing pipeline consisting of (name, component) tuples. The
| components are called on the Doc in order as it passes through the
| pipeline.
|
| RETURNS (List[Tuple[str, Callable[[Doc], Doc]]]): The pipeline.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| config
| Trainable config for the current language instance. Includes the
| current pipeline components, as well as default training config.
|
| RETURNS (thinc.api.Config): The config.
|
| DOCS: https://spacy.io/api/language#config
|
| meta
| Custom meta data of the language class. If a model is loaded, this
| includes details from the model's meta.json.
|
| RETURNS (Dict[str, Any]): The meta.
|
| DOCS: https://spacy.io/api/language#meta
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| Defaults = <class 'spacy.language.BaseDefaults'>
| Language data defaults, available via Language.Defaults. Can be
| overwritten by language subclasses by defining their own subclasses of
| Language.Defaults.
|
|
| __annotations__ = {'_factory_meta': typing.Dict[str, ForwardRef('Facto...
|
| default_config = {'paths': {'train': None, 'dev': None, 'vectors'...s'...
|
| factories = {'merge_noun_chunks': <function Language.compone...ent.<lo...
|
| lang = None
FUNCTIONS
URL_MATCH = match(string, pos=0, endpos=9223372036854775807) method of re.Pattern instance
Matches zero or more characters at the beginning of the string.
create_tokenizer() -> Callable[[ForwardRef('Language')], spacy.tokenizer.Tokenizer]
Registered function to create a tokenizer. Returns a factory that takes
the nlp object and returns a Tokenizer instance using the language detaults.
load_lookups_data(lang, tables)
timer = perf_counter(...)
perf_counter() -> float
Performance counter for benchmarking.
DATA
BASE_EXCEPTIONS = {'\t': [{65: '\t'}], '\n': [{65: '\n'}], ' ': [{65: ...
CONFIG_SECTION_ORDER = ['paths', 'variables', 'system', 'nlp', 'compon...
Callable = typing.Callable
Deprecated alias to collections.abc.Callable.
Callable[[int], str] signifies a function that takes a single
parameter of type int and returns a str.
The subscription syntax must always be used with exactly two
values: the argument list and the return type.
The argument list must be a list of types, a ParamSpec,
Concatenate or ellipsis. The return type must be a single type.
There is no syntax to indicate optional or keyword arguments;
such function types are rarely used as callback types.
DEFAULT_CONFIG = {'paths': {'train': None, 'dev': None, 'vectors'...s'...
DEFAULT_CONFIG_PATH = WindowsPath('C:/Users/Youse/AppData/Local/Progra...
DEFAULT_CONFIG_PRETRAIN_PATH = WindowsPath('C:/Users/Youse/AppData/Loc...
Dict = typing.Dict
A generic version of dict.
GIT_VERSION = '0069cf9'
Iterable = typing.Iterable
A generic version of collections.abc.Iterable.
Iterator = typing.Iterator
A generic version of collections.abc.Iterator.
List = typing.List
A generic version of list.
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
NoReturn = typing.NoReturn
Special type indicating functions that never return.
Example::
from typing import NoReturn
def stop() -> NoReturn:
raise Exception('no way')
NoReturn can also be used as a bottom type, a type that
has no values. Starting in Python 3.11, the Never type should
be used for this concept instead. Type checkers should treat the two
equivalently.
Optional = typing.Optional
Optional[X] is equivalent to Union[X, None].
Pattern = typing.Pattern
A generic version of re.Pattern.
PipeCallable = typing.Callable[[spacy.tokens.doc.Doc], spacy.tokens.do...
Sequence = typing.Sequence
A generic version of collections.abc.Sequence.
Set = typing.Set
A generic version of set.
TOKENIZER_INFIXES = [r'\.\.+', '…', r'[\u00A6\u00A9\u00AE\u00B0\u0482\...
TOKENIZER_PREFIXES = ['§', '%', '=', '—', '–', r'\+(?![0-9])', '…', '…...
TOKENIZER_SUFFIXES = ['…', '……', ',', ':', ';', r'\!', r'\?', '¿', '؟'...
Tuple = typing.Tuple
Deprecated alias to builtins.tuple.
Tuple[X, Y] is the cross-product type of X and Y.
Example: Tuple[T1, T2] is a tuple of two elements corresponding
to type variables T1 and T2. Tuple[int, float, str] is a tuple
of an int, a float and a string.
To specify a variable-length tuple of homogeneous type, use Tuple[T, ...].
Union = typing.Union
Union type; Union[X, Y] means either X or Y.
On Python 3.10 and higher, the | operator
can also be used to denote unions;
X | Y means the same thing to the type checker as Union[X, Y].
To define a union, use e.g. Union[int, str]. Details:
- The arguments must be types and there must be at least one.
- None as an argument is a special case and is replaced by
type(None).
- Unions of unions are flattened, e.g.::
assert Union[Union[int, str], float] == Union[int, str, float]
- Unions of a single argument vanish, e.g.::
assert Union[int] == int # The constructor actually returns int
- Redundant arguments are skipped, e.g.::
assert Union[int, str, int] == Union[int, str]
- When comparing unions, the argument order is ignored, e.g.::
assert Union[int, str] == Union[str, int]
- You cannot subclass or instantiate a union.
- You can use Optional[X] as a shorthand for Union[X, None].
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\language.py
spacy.lexeme
Python Library Documentation: module spacy.lexeme in spacy
NAME
spacy.lexeme
CLASSES
builtins.object
Lexeme
class Lexeme(builtins.object)
| Lexeme(Vocab vocab, attr_t orth)
|
| An entry in the vocabulary. A `Lexeme` has no string context – it's a
| word-type, as opposed to a word token. It therefore has no part-of-speech
| tag, dependency parse, or lemma (lemmatization depends on the
| part-of-speech tag).
|
| DOCS: https://spacy.io/api/lexeme
|
| Methods defined here:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __init__(...)
| Create a Lexeme object.
|
| vocab (Vocab): The parent vocabulary
| orth (uint64): The orth id of the lexeme.
| Returns (Lexeme): The newly constructd object.
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __reduce__ = __reduce_cython__(...)
| Lexeme.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| Lexeme.__setstate_cython__(self, __pyx_state)
|
| check_flag(self, flag_id)
| Lexeme.check_flag(self, attr_id_t flag_id)
|
| Check the value of a boolean flag.
|
| flag_id (int): The attribute ID of the flag to query.
| RETURNS (bool): The value of the flag.
|
| set_attrs(self, **attrs)
| Lexeme.set_attrs(self, **attrs)
|
| set_flag(self, flag_id, value)
| Lexeme.set_flag(self, attr_id_t flag_id, bool value)
|
| Change the value of a boolean flag.
|
| flag_id (int): The attribute ID of the flag to set.
| value (bool): The new value of the flag.
|
| similarity(self, other)
| Lexeme.similarity(self, other)
|
| Compute a semantic similarity estimate. Defaults to cosine over
| vectors.
|
| other (object): The object to compare with. By default, accepts `Doc`,
| `Span`, `Token` and `Lexeme` objects.
| RETURNS (float): A scalar similarity score. Higher is more similar.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| cluster
| RETURNS (int): Brown cluster ID.
|
| flags
| RETURNS (uint64): Container of the lexeme's binary flags.
|
| has_vector
| RETURNS (bool): Whether a word vector is associated with the object.
|
| is_alpha
| RETURNS (bool): Whether the lexeme consists of alphabetic
| characters. Equivalent to `lexeme.text.isalpha()`.
|
| is_ascii
| RETURNS (bool): Whether the lexeme consists of ASCII characters.
| Equivalent to `[any(ord(c) >= 128 for c in lexeme.text)]`.
|
| is_bracket
| RETURNS (bool): Whether the lexeme is a bracket.
|
| is_currency
| RETURNS (bool): Whether the lexeme is a currency symbol, e.g. $, €.
|
| is_digit
| RETURNS (bool): Whether the lexeme consists of digits. Equivalent
| to `lexeme.text.isdigit()`.
|
| is_left_punct
| RETURNS (bool): Whether the lexeme is left punctuation, e.g. (.
|
| is_lower
| RETURNS (bool): Whether the lexeme is in lowercase. Equivalent to
| `lexeme.text.islower()`.
|
| is_oov
| RETURNS (bool): Whether the lexeme is out-of-vocabulary.
|
| is_punct
| RETURNS (bool): Whether the lexeme is punctuation.
|
| is_quote
| RETURNS (bool): Whether the lexeme is a quotation mark.
|
| is_right_punct
| RETURNS (bool): Whether the lexeme is right punctuation, e.g. ).
|
| is_space
| RETURNS (bool): Whether the lexeme consist of whitespace characters.
| Equivalent to `lexeme.text.isspace()`.
|
| is_stop
| RETURNS (bool): Whether the lexeme is a stop word.
|
| is_title
| RETURNS (bool): Whether the lexeme is in titlecase. Equivalent to
| `lexeme.text.istitle()`.
|
| is_upper
| RETURNS (bool): Whether the lexeme is in uppercase. Equivalent to
| `lexeme.text.isupper()`.
|
| lang
| RETURNS (uint64): Language of the parent vocabulary.
|
| lang_
| RETURNS (str): Language of the parent vocabulary.
|
| like_email
| RETURNS (bool): Whether the lexeme resembles an email address.
|
| like_num
| RETURNS (bool): Whether the lexeme represents a number, e.g. "10.9",
| "10", "ten", etc.
|
| like_url
| RETURNS (bool): Whether the lexeme resembles a URL.
|
| lower
| RETURNS (uint64): Lowercase form of the lexeme.
|
| lower_
| RETURNS (str): Lowercase form of the word.
|
| norm
| RETURNS (uint64): The lexeme's norm, i.e. a normalised form of the
| lexeme text.
|
| norm_
| RETURNS (str): The lexeme's norm, i.e. a normalised form of the
| lexeme text.
|
| orth
|
| orth_
| RETURNS (str): The original verbatim text of the lexeme
| (identical to `Lexeme.text`). Exists mostly for consistency with
| the other attributes.
|
| prefix
| RETURNS (uint64): Length-N substring from the start of the word.
| Defaults to `N=1`.
|
| prefix_
| RETURNS (str): Length-N substring from the start of the word.
| Defaults to `N=1`.
|
| prob
| RETURNS (float): Smoothed log probability estimate of the lexeme's
| type.
|
| rank
| RETURNS (str): Sequential ID of the lexeme's lexical type, used
| to index into tables, e.g. for word vectors.
|
| sentiment
| RETURNS (float): A scalar value indicating the positivity or
| negativity of the lexeme.
|
| shape
| RETURNS (uint64): Transform of the word's string, to show
| orthographic features.
|
| shape_
| RETURNS (str): Transform of the word's string, to show
| orthographic features.
|
| suffix
| RETURNS (uint64): Length-N substring from the end of the word.
| Defaults to `N=3`.
|
| suffix_
| RETURNS (str): Length-N substring from the end of the word.
| Defaults to `N=3`.
|
| text
| RETURNS (str): The original verbatim text of the lexeme.
|
| vector
| A real-valued meaning representation.
|
| RETURNS (numpy.ndarray[ndim=1, dtype='float32']): A 1D numpy array
| representing the lexeme's semantics.
|
| vector_norm
| RETURNS (float): The L2 norm of the vector representation.
|
| vocab
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __pyx_vtable__ = <capsule object NULL>
FUNCTIONS
__reduce_cython__(self)
Lexeme.__reduce_cython__(self)
__setstate_cython__(self, __pyx_state)
Lexeme.__setstate_cython__(self, __pyx_state)
DATA
__pyx_capi__ = {'EMPTY_LEXEME': <capsule object "struct __pyx_t_5spacy...
__test__ = {}
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\lexeme.cp312-win_amd64.pyd
spacy.load
Python Library Documentation: function load in module spacy
load(name: Union[str, pathlib.Path], *, vocab: Union[spacy.vocab.Vocab, bool] = True, disable: Union[str, Iterable[str]] = [], enable: Union[str, Iterable[str]] = [], exclude: Union[str, Iterable[str]] = [], config: Union[Dict[str, Any], confection._config.Config] = {}) -> spacy.language.Language
Load a spaCy model from an installed package or a local path.
name (str): Package name or model path.
vocab (Vocab): A Vocab object. If True, a vocab is created.
disable (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to disable. Disabled
pipes will be loaded but they won't be run unless you explicitly
enable them by calling nlp.enable_pipe.
enable (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to enable. All other
pipes will be disabled (but can be enabled later using nlp.enable_pipe).
exclude (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to exclude. Excluded
components won't be loaded.
config (Dict[str, Any] / Config): Config overrides as nested dict or dict
keyed by section values in dot notation.
RETURNS (Language): The loaded nlp object.
spacy.logger
Python Library Documentation: Logger in module logging object
class Logger(Filterer)
| Logger(name, level=0)
|
| Instances of the Logger class represent a single logging channel. A
| "logging channel" indicates an area of an application. Exactly how an
| "area" is defined is up to the application developer. Since an
| application can have any number of areas, logging channels are identified
| by a unique string. Application areas can be nested (e.g. an area
| of "input processing" might include sub-areas "read CSV files", "read
| XLS files" and "read Gnumeric files"). To cater for this natural nesting,
| channel names are organized into a namespace hierarchy where levels are
| separated by periods, much like the Java or Python package namespace. So
| in the instance given above, channel names might be "input" for the upper
| level, and "input.csv", "input.xls" and "input.gnu" for the sub-levels.
| There is no arbitrary limit to the depth of nesting.
|
| Method resolution order:
| Logger
| Filterer
| builtins.object
|
| Methods defined here:
|
| __init__(self, name, level=0)
| Initialize the logger with a name and an optional level.
|
| __reduce__(self)
| Helper for pickle.
|
| __repr__(self)
| Return repr(self).
|
| addHandler(self, hdlr)
| Add the specified handler to this logger.
|
| callHandlers(self, record)
| Pass a record to all relevant handlers.
|
| Loop through all handlers for this logger and its parents in the
| logger hierarchy. If no handler was found, output a one-off error
| message to sys.stderr. Stop searching up the hierarchy whenever a
| logger with the "propagate" attribute set to zero is found - that
| will be the last logger whose handlers are called.
|
| critical(self, msg, *args, **kwargs)
| Log 'msg % args' with severity 'CRITICAL'.
|
| To pass exception information, use the keyword argument exc_info with
| a true value, e.g.
|
| logger.critical("Houston, we have a %s", "major disaster", exc_info=True)
|
| debug(self, msg, *args, **kwargs)
| Log 'msg % args' with severity 'DEBUG'.
|
| To pass exception information, use the keyword argument exc_info with
| a true value, e.g.
|
| logger.debug("Houston, we have a %s", "thorny problem", exc_info=True)
|
| error(self, msg, *args, **kwargs)
| Log 'msg % args' with severity 'ERROR'.
|
| To pass exception information, use the keyword argument exc_info with
| a true value, e.g.
|
| logger.error("Houston, we have a %s", "major problem", exc_info=True)
|
| exception(self, msg, *args, exc_info=True, **kwargs)
| Convenience method for logging an ERROR with exception information.
|
| fatal(self, msg, *args, **kwargs)
| Don't use this method, use critical() instead.
|
| findCaller(self, stack_info=False, stacklevel=1)
| Find the stack frame of the caller so that we can note the source
| file name, line number and function name.
|
| getChild(self, suffix)
| Get a logger which is a descendant to this one.
|
| This is a convenience method, such that
|
| logging.getLogger('abc').getChild('def.ghi')
|
| is the same as
|
| logging.getLogger('abc.def.ghi')
|
| It's useful, for example, when the parent logger is named using
| __name__ rather than a literal string.
|
| getChildren(self)
|
| getEffectiveLevel(self)
| Get the effective level for this logger.
|
| Loop through this logger and its parents in the logger hierarchy,
| looking for a non-zero logging level. Return the first one found.
|
| handle(self, record)
| Call the handlers for the specified record.
|
| This method is used for unpickled records received from a socket, as
| well as those created locally. Logger-level filtering is applied.
|
| hasHandlers(self)
| See if this logger has any handlers configured.
|
| Loop through all handlers for this logger and its parents in the
| logger hierarchy. Return True if a handler was found, else False.
| Stop searching up the hierarchy whenever a logger with the "propagate"
| attribute set to zero is found - that will be the last logger which
| is checked for the existence of handlers.
|
| info(self, msg, *args, **kwargs)
| Log 'msg % args' with severity 'INFO'.
|
| To pass exception information, use the keyword argument exc_info with
| a true value, e.g.
|
| logger.info("Houston, we have a %s", "notable problem", exc_info=True)
|
| isEnabledFor(self, level)
| Is this logger enabled for level 'level'?
|
| log(self, level, msg, *args, **kwargs)
| Log 'msg % args' with the integer severity 'level'.
|
| To pass exception information, use the keyword argument exc_info with
| a true value, e.g.
|
| logger.log(level, "We have a %s", "mysterious problem", exc_info=True)
|
| makeRecord(self, name, level, fn, lno, msg, args, exc_info, func=None, extra=None, sinfo=None)
| A factory method which can be overridden in subclasses to create
| specialized LogRecords.
|
| removeHandler(self, hdlr)
| Remove the specified handler from this logger.
|
| setLevel(self, level)
| Set the logging level of this logger. level must be an int or a str.
|
| warn(self, msg, *args, **kwargs)
|
| warning(self, msg, *args, **kwargs)
| Log 'msg % args' with severity 'WARNING'.
|
| To pass exception information, use the keyword argument exc_info with
| a true value, e.g.
|
| logger.warning("Houston, we have a %s", "bit of a problem", exc_info=True)
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| manager = <logging.Manager object>
|
| root = <RootLogger root (WARNING)>
|
| ----------------------------------------------------------------------
| Methods inherited from Filterer:
|
| addFilter(self, filter)
| Add the specified filter to this handler.
|
| filter(self, record)
| Determine if a record is loggable by consulting all the filters.
|
| The default is to allow the record to be logged; any filter can veto
| this by returning a false value.
| If a filter attached to a handler returns a log record instance,
| then that instance is used in place of the original log record in
| any further processing of the event by that handler.
| If a filter returns any other true value, the original log record
| is used in any further processing of the event by that handler.
|
| If none of the filters return false values, this method returns
| a log record.
| If any of the filters return a false value, this method returns
| a false value.
|
| .. versionchanged:: 3.2
|
| Allow filters to be just callables.
|
| .. versionchanged:: 3.12
| Allow filters to return a LogRecord instead of
| modifying it in place.
|
| removeFilter(self, filter)
| Remove the specified filter from this handler.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from Filterer:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
spacy.lookups
Python Library Documentation: module spacy.lookups in spacy
NAME
spacy.lookups
CLASSES
builtins.object
Lookups
collections.OrderedDict(builtins.dict)
Table
class Lookups(builtins.object)
| Lookups() -> None
|
| Container for large lookup tables and dictionaries, e.g. lemmatization
| data or tokenizer exception lists. Lookups are available via vocab.lookups,
| so they can be accessed before the pipeline components are applied (e.g.
| in the tokenizer and lemmatizer), as well as within the pipeline components
| via doc.vocab.lookups.
|
| Methods defined here:
|
| __contains__(self, name: str) -> bool
| Check if the lookups contain a table of a given name. Delegates to
| Lookups.has_table.
|
| name (str): Name of the table.
| RETURNS (bool): Whether a table of that name is in the lookups.
|
| __init__(self) -> None
| Initialize the Lookups object.
|
| DOCS: https://spacy.io/api/lookups#init
|
| __len__(self) -> int
| RETURNS (int): The number of tables in the lookups.
|
| add_table(self, name: str, data: dict = {}) -> spacy.lookups.Table
| Add a new table to the lookups. Raises an error if the table exists.
|
| name (str): Unique name of table.
| data (dict): Optional data to add to the table.
| RETURNS (Table): The newly added table.
|
| DOCS: https://spacy.io/api/lookups#add_table
|
| from_bytes(self, bytes_data: bytes, **kwargs) -> 'Lookups'
| Load the lookups from a bytestring.
|
| bytes_data (bytes): The data to load.
| RETURNS (Lookups): The loaded Lookups.
|
| DOCS: https://spacy.io/api/lookups#from_bytes
|
| from_disk(self, path: Union[str, pathlib.Path], filename: str = 'lookups.bin', **kwargs) -> 'Lookups'
| Load lookups from a directory containing a lookups.bin. Will skip
| loading if the file doesn't exist.
|
| path (str / Path): The directory path.
| RETURNS (Lookups): The loaded lookups.
|
| DOCS: https://spacy.io/api/lookups#from_disk
|
| get_table(self, name: str, default: Any = <object object at 0x0000022153ADFBF0>) -> spacy.lookups.Table
| Get a table. Raises an error if the table doesn't exist and no
| default value is provided.
|
| name (str): Name of the table.
| default (Any): Optional default value to return if table doesn't exist.
| RETURNS (Table): The table.
|
| DOCS: https://spacy.io/api/lookups#get_table
|
| has_table(self, name: str) -> bool
| Check if the lookups contain a table of a given name.
|
| name (str): Name of the table.
| RETURNS (bool): Whether a table of that name exists.
|
| DOCS: https://spacy.io/api/lookups#has_table
|
| remove_table(self, name: str) -> spacy.lookups.Table
| Remove a table. Raises an error if the table doesn't exist.
|
| name (str): Name of the table to remove.
| RETURNS (Table): The removed table.
|
| DOCS: https://spacy.io/api/lookups#remove_table
|
| set_table(self, name: str, table: spacy.lookups.Table) -> None
| Set a table.
|
| name (str): Name of the table to set.
| table (Table): The Table to set.
|
| DOCS: https://spacy.io/api/lookups#set_table
|
| to_bytes(self, **kwargs) -> bytes
| Serialize the lookups to a bytestring.
|
| RETURNS (bytes): The serialized Lookups.
|
| DOCS: https://spacy.io/api/lookups#to_bytes
|
| to_disk(self, path: Union[str, pathlib.Path], filename: str = 'lookups.bin', **kwargs) -> None
| Save the lookups to a directory as lookups.bin. Expects a path to a
| directory, which will be created if it doesn't exist.
|
| path (str / Path): The file path.
|
| DOCS: https://spacy.io/api/lookups#to_disk
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| tables
| RETURNS (List[str]): Names of all tables in the lookups.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Table(collections.OrderedDict)
| Table(name: Optional[str] = None, data: Optional[dict] = None) -> None
|
| A table in the lookups. Subclass of builtin dict that implements a
| slightly more consistent and unified API.
|
| Includes a Bloom filter to speed up missed lookups.
|
| Method resolution order:
| Table
| collections.OrderedDict
| builtins.dict
| builtins.object
|
| Methods defined here:
|
| __contains__(self, key: Union[str, int]) -> bool
| Check whether a key is in the table. String keys will be hashed.
|
| key (str / int): The key to check.
| RETURNS (bool): Whether the key is in the table.
|
| __getitem__(self, key: Union[str, int]) -> Any
| Get the value for a given key. String keys will be hashed.
|
| key (str / int): The key to get.
| RETURNS: The value.
|
| __init__(self, name: Optional[str] = None, data: Optional[dict] = None) -> None
| Initialize a new table.
|
| name (str): Optional table name for reference.
| data (dict): Initial data, used to hint Bloom Filter.
|
| DOCS: https://spacy.io/api/lookups#table.init
|
| __setitem__(self, key: Union[str, int], value: Any) -> None
| Set new key/value pair. String keys will be hashed.
|
| key (str / int): The key to set.
| value: The value to set.
|
| from_bytes(self, bytes_data: bytes) -> 'Table'
| Load a table from a bytestring.
|
| bytes_data (bytes): The data to load.
| RETURNS (Table): The loaded table.
|
| DOCS: https://spacy.io/api/lookups#table.from_bytes
|
| get(self, key: Union[str, int], default: Optional[Any] = None) -> Any
| Get the value for a given key. String keys will be hashed.
|
| key (str / int): The key to get.
| default: The default value to return.
| RETURNS: The value.
|
| set(self, key: Union[str, int], value: Any) -> None
| Set new key/value pair. String keys will be hashed.
| Same as table[key] = value.
|
| key (str / int): The key to set.
| value: The value to set.
|
| to_bytes(self) -> bytes
| Serialize table to a bytestring.
|
| RETURNS (bytes): The serialized table.
|
| DOCS: https://spacy.io/api/lookups#table.to_bytes
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| from_dict(data: dict, name: Optional[str] = None) -> 'Table'
| Initialize a new table from a dict.
|
| data (dict): The dictionary.
| name (str): Optional table name for reference.
|
| DOCS: https://spacy.io/api/lookups#table.from_dict
|
| ----------------------------------------------------------------------
| Methods inherited from collections.OrderedDict:
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __gt__(self, value, /)
| Return self>value.
|
| __ior__(self, value, /)
| Return self|=value.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __or__(self, value, /)
| Return self|value.
|
| __reduce__(...)
| Return state information for pickling
|
| __repr__(self, /)
| Return repr(self).
|
| __reversed__(...)
| od.__reversed__() <==> reversed(od)
|
| __ror__(self, value, /)
| Return value|self.
|
| __sizeof__(...)
| D.__sizeof__() -> size of D in memory, in bytes
|
| clear(...)
| od.clear() -> None. Remove all items from od.
|
| copy(...)
| od.copy() -> a shallow copy of od
|
| items(...)
| D.items() -> a set-like object providing a view on D's items
|
| keys(...)
| D.keys() -> a set-like object providing a view on D's keys
|
| move_to_end(self, /, key, last=True)
| Move an existing element to the end (or beginning if last is false).
|
| Raise KeyError if the element does not exist.
|
| pop(...)
| od.pop(key[,default]) -> v, remove specified key and return the corresponding value.
|
| If the key is not found, return the default if given; otherwise,
| raise a KeyError.
|
| popitem(self, /, last=True)
| Remove and return a (key, value) pair from the dictionary.
|
| Pairs are returned in LIFO order if last is true or FIFO order if false.
|
| setdefault(self, /, key, default=None)
| Insert key with a value of default if key is not in the dictionary.
|
| Return the value for key if key is in the dictionary, else default.
|
| update(...)
| D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
| If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
| If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
| In either case, this is followed by: for k in F: D[k] = F[k]
|
| values(...)
| D.values() -> an object providing a view on D's values
|
| ----------------------------------------------------------------------
| Class methods inherited from collections.OrderedDict:
|
| fromkeys(iterable, value=None)
| Create a new ordered dictionary with keys from iterable and values set to value.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from collections.OrderedDict:
|
| __dict__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from collections.OrderedDict:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.dict:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __len__(self, /)
| Return len(self).
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.dict:
|
| __class_getitem__(...)
| See PEP 585
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.dict:
|
| __new__(*args, **kwargs) class method of builtins.dict
| Create and return a new object. See help(type) for accurate signature.
FUNCTIONS
load_lookups(lang: str, tables: List[str], strict: bool = True) -> 'Lookups'
Load the data from the spacy-lookups-data package for a given language,
if available. Returns an empty `Lookups` container if there's no data or if the package
is not installed.
lang (str): The language code (corresponds to entry point exposed by
the spacy-lookups-data package).
tables (List[str]): Name of tables to load, e.g. ["lemma_lookup", "lemma_exc"]
strict (bool): Whether to raise an error if a table doesn't exist.
RETURNS (Lookups): The lookups container containing the loaded tables.
DATA
Dict = typing.Dict
A generic version of dict.
List = typing.List
A generic version of list.
Optional = typing.Optional
Optional[X] is equivalent to Union[X, None].
UNSET = <object object>
Union = typing.Union
Union type; Union[X, Y] means either X or Y.
On Python 3.10 and higher, the | operator
can also be used to denote unions;
X | Y means the same thing to the type checker as Union[X, Y].
To define a union, use e.g. Union[int, str]. Details:
- The arguments must be types and there must be at least one.
- None as an argument is a special case and is replaced by
type(None).
- Unions of unions are flattened, e.g.::
assert Union[Union[int, str], float] == Union[int, str, float]
- Unions of a single argument vanish, e.g.::
assert Union[int] == int # The constructor actually returns int
- Redundant arguments are skipped, e.g.::
assert Union[int, str, int] == Union[int, str]
- When comparing unions, the argument order is ignored, e.g.::
assert Union[int, str] == Union[str, int]
- You cannot subclass or instantiate a union.
- You can use Optional[X] as a shorthand for Union[X, None].
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\lookups.py
spacy.matcher
Python Library Documentation: package spacy.matcher in spacy
NAME
spacy.matcher
PACKAGE CONTENTS
dependencymatcher
levenshtein
matcher
phrasematcher
CLASSES
builtins.object
spacy.matcher.dependencymatcher.DependencyMatcher
spacy.matcher.matcher.Matcher
spacy.matcher.phrasematcher.PhraseMatcher
class DependencyMatcher(builtins.object)
| DependencyMatcher(vocab, validate=False, *)
|
| Match dependency parse tree based on pattern rules.
|
| Methods defined here:
|
| __call__(...)
| DependencyMatcher.__call__(self, doclike)
|
| Find all token sequences matching the supplied pattern.
|
| doclike (Doc or Span): The document to match over.
| RETURNS (list): A list of `(key, start, end)` tuples,
| describing the matches. A match tuple describes a span
| `doc[start:end]`. The `label_id` and `key` are both integers.
|
| __contains__(...)
| DependencyMatcher.__contains__(self, key)
|
| Check whether the matcher contains rules for a match ID.
|
| key (str): The match ID.
| RETURNS (bool): Whether the matcher contains rules for this match ID.
|
| __init__(...)
| Create the DependencyMatcher.
|
| vocab (Vocab): The vocabulary object, which must be shared with the
| documents the matcher will operate on.
| validate (bool): Whether patterns should be validated, passed to
| Matcher as `validate`
|
| __len__(...)
| DependencyMatcher.__len__(self)
|
| Get the number of rules, which are edges, added to the dependency
| tree matcher.
|
| RETURNS (int): The number of rules.
|
| __reduce__(self)
| DependencyMatcher.__reduce__(self)
|
| add(self, key, patterns, *, on_match=None)
| DependencyMatcher.add(self, key, patterns, *, on_match=None)
|
| Add a new matcher rule to the matcher.
|
| key (str): The match ID.
| patterns (list): The patterns to add for the given key.
| on_match (callable): Optional callback executed on match.
|
| get(self, key, default=None)
| DependencyMatcher.get(self, key, default=None)
|
| Retrieve the pattern stored for a key.
|
| key (str / int): The key to retrieve.
| RETURNS (tuple): The rule, as an (on_match, patterns) tuple.
|
| has_key(self, key)
| DependencyMatcher.has_key(self, key)
|
| Check whether the matcher has a rule with a given key.
|
| key (string or int): The key to check.
| RETURNS (bool): Whether the matcher has the rule.
|
| remove(self, key)
| DependencyMatcher.remove(self, key)
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| vocab
class Matcher(builtins.object)
| Matcher(vocab, validate=True, fuzzy_compare=levenshtein_compare, *)
|
| Match sequences of tokens, based on pattern rules.
|
| DOCS: https://spacy.io/api/matcher
| USAGE: https://spacy.io/usage/rule-based-matching
|
| Methods defined here:
|
| __call__(...)
| Matcher.__call__(self, doclike, *, as_spans=False, allow_missing=False, with_alignments=False)
|
| Find all token sequences matching the supplied pattern.
|
| doclike (Doc or Span): The document to match over.
| as_spans (bool): Return Span objects with labels instead of (match_id,
| start, end) tuples.
| allow_missing (bool): Whether to skip checks for missing annotation for
| attributes included in patterns. Defaults to False.
| with_alignments (bool): Return match alignment information, which is
| `List[int]` with length of matched span. Each entry denotes the
| corresponding index of token pattern. If as_spans is set to True,
| this setting is ignored.
| RETURNS (list): A list of `(match_id, start, end)` tuples,
| describing the matches. A match tuple describes a span
| `doc[start:end]`. The `match_id` is an integer. If as_spans is set
| to True, a list of Span objects is returned.
| If with_alignments is set to True and as_spans is set to False,
| A list of `(match_id, start, end, alignments)` tuples is returned.
|
| __contains__(...)
| Matcher.__contains__(self, key)
|
| Check whether the matcher contains rules for a match ID.
|
| key (str): The match ID.
| RETURNS (bool): Whether the matcher contains rules for this match ID.
|
| __init__(...)
| Create the Matcher.
|
| vocab (Vocab): The vocabulary object, which must be shared with the
| validate (bool): Validate all patterns added to this matcher.
| fuzzy_compare (Callable[[str, str, int], bool]): The comparison method
| for the FUZZY operators.
|
| __len__(...)
| Matcher.__len__(self)
|
| Get the number of rules added to the matcher. Note that this only
| returns the number of rules (identical with the number of IDs), not the
| number of individual patterns.
|
| RETURNS (int): The number of rules.
|
| __reduce__(self)
| Matcher.__reduce__(self)
|
| add(self, key, patterns, *, on_match=None, greedy: 'str' = None)
| Matcher.add(self, key, patterns, *, on_match=None, greedy: str = None)
|
| Add a match-rule to the matcher. A match-rule consists of: an ID
| key, an on_match callback, and one or more patterns.
|
| If the key exists, the patterns are appended to the previous ones, and
| the previous on_match callback is replaced. The `on_match` callback
| will receive the arguments `(matcher, doc, i, matches)`. You can also
| set `on_match` to `None` to not perform any actions.
|
| A pattern consists of one or more `token_specs`, where a `token_spec`
| is a dictionary mapping attribute IDs to values, and optionally a
| quantifier operator under the key "op". The available quantifiers are:
|
| '!': Negate the pattern, by requiring it to match exactly 0 times.
| '?': Make the pattern optional, by allowing it to match 0 or 1 times.
| '+': Require the pattern to match 1 or more times.
| '*': Allow the pattern to zero or more times.
| '{n}': Require the pattern to match exactly _n_ times.
| '{n,m}': Require the pattern to match at least _n_ but not more than _m_ times.
| '{n,}': Require the pattern to match at least _n_ times.
| '{,m}': Require the pattern to match at most _m_ times.
|
| The + and * operators return all possible matches (not just the greedy
| ones). However, the "greedy" argument can filter the final matches
| by returning a non-overlapping set per key, either taking preference to
| the first greedy match ("FIRST"), or the longest ("LONGEST").
|
| Since spaCy v2.2.2, Matcher.add takes a list of patterns as the second
| argument, and the on_match callback is an optional keyword argument.
|
| key (Union[str, int]): The match ID.
| patterns (list): The patterns to add for the given key.
| on_match (callable): Optional callback executed on match.
| greedy (str): Optional filter: "FIRST" or "LONGEST".
|
| get(self, key, default=None)
| Matcher.get(self, key, default=None)
|
| Retrieve the pattern stored for a key.
|
| key (str / int): The key to retrieve.
| RETURNS (tuple): The rule, as an (on_match, patterns) tuple.
|
| has_key(self, key)
| Matcher.has_key(self, key)
|
| Check whether the matcher has a rule with a given key.
|
| key (string or int): The key to check.
| RETURNS (bool): Whether the matcher has the rule.
|
| pipe(self, docs, batch_size=1000, return_matches=False, as_tuples=False)
| Matcher.pipe(self, docs, batch_size=1000, return_matches=False, as_tuples=False)
|
| Match a stream of documents, yielding them in turn. Deprecated as of
| spaCy v3.0.
|
| remove(self, key)
| Matcher.remove(self, key)
|
| Remove a rule from the matcher. A KeyError is raised if the key does
| not exist.
|
| key (str): The ID of the match rule.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| validate
| validate: object
|
| vocab
class PhraseMatcher(builtins.object)
| PhraseMatcher(Vocab vocab, attr='ORTH', validate=False)
|
| Efficiently match large terminology lists. While the `Matcher` matches
| sequences based on lists of token descriptions, the `PhraseMatcher` accepts
| match patterns in the form of `Doc` objects.
|
| DOCS: https://spacy.io/api/phrasematcher
| USAGE: https://spacy.io/usage/rule-based-matching#phrasematcher
|
| Adapted from FlashText: https://github.com/vi3k6i5/flashtext
| MIT License (see `LICENSE`)
| Copyright (c) 2017 Vikash Singh (vikash.duliajan@gmail.com)
|
| Methods defined here:
|
| __call__(...)
| PhraseMatcher.__call__(self, doclike, *, as_spans=False)
|
| Find all sequences matching the supplied patterns on the `Doc`.
|
| doclike (Doc or Span): The document to match over.
| as_spans (bool): Return Span objects with labels instead of (match_id,
| start, end) tuples.
| RETURNS (list): A list of `(match_id, start, end)` tuples,
| describing the matches. A match tuple describes a span
| `doc[start:end]`. The `match_id` is an integer. If as_spans is set
| to True, a list of Span objects is returned.
|
| DOCS: https://spacy.io/api/phrasematcher#call
|
| __contains__(...)
| PhraseMatcher.__contains__(self, key)
|
| Check whether the matcher contains rules for a match ID.
|
| key (str): The match ID.
| RETURNS (bool): Whether the matcher contains rules for this match ID.
|
| DOCS: https://spacy.io/api/phrasematcher#contains
|
| __init__(...)
| Initialize the PhraseMatcher.
|
| vocab (Vocab): The shared vocabulary.
| attr (int / str): Token attribute to match on.
| validate (bool): Perform additional validation when patterns are added.
|
| DOCS: https://spacy.io/api/phrasematcher#init
|
| __len__(...)
| PhraseMatcher.__len__(self)
|
| Get the number of match IDs added to the matcher.
|
| RETURNS (int): The number of rules.
|
| DOCS: https://spacy.io/api/phrasematcher#len
|
| __reduce__(self)
| PhraseMatcher.__reduce__(self)
|
| add(self, key, docs, *_docs, on_match=None)
| PhraseMatcher.add(self, key, docs, *_docs, on_match=None)
|
| Add a match-rule to the phrase-matcher. A match-rule consists of: an ID
| key, an on_match callback, and one or more patterns.
|
| Since spaCy v2.2.2, PhraseMatcher.add takes a list of patterns as the
| second argument, with the on_match callback as an optional keyword
| argument.
|
| key (str): The match ID.
| docs (list): List of `Doc` objects representing match patterns.
| on_match (callable): Callback executed on match.
| *_docs (Doc): For backwards compatibility: list of patterns to add
| as variable arguments. Will be ignored if a list of patterns is
| provided as the second argument.
|
| DOCS: https://spacy.io/api/phrasematcher#add
|
| pipe(self, stream, batch_size=1000, return_matches=False, as_tuples=False)
| PhraseMatcher.pipe(self, stream, batch_size=1000, return_matches=False, as_tuples=False)
|
| Match a stream of documents, yielding them in turn. Deprecated as of
| spaCy v3.0.
|
| remove(self, key)
| PhraseMatcher.remove(self, key)
|
| Remove a rule from the matcher by match ID. A KeyError is raised if
| the key does not exist.
|
| key (str): The match ID.
|
| DOCS: https://spacy.io/api/phrasematcher#remove
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| vocab
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __pyx_vtable__ = <capsule object NULL>
FUNCTIONS
levenshtein(a: 'str', b: 'str', k: 'Optional[int]' = None)
levenshtein(a: str, b: str, k: Optional[int] = None) -> int64_t
DATA
__all__ = ['DependencyMatcher', 'Matcher', 'PhraseMatcher', 'levenshte...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\matcher\__init__.py
spacy.ml
Python Library Documentation: package spacy.ml in spacy
NAME
spacy.ml
PACKAGE CONTENTS
_character_embed
_precomputable_affine
callbacks
extract_ngrams
extract_spans
featureextractor
models (package)
parser_model
staticvectors
tb_framework
SUBMODULES
entity_linker
multi_task
parser
span_finder
spancat
tagger
textcat
tok2vec
DATA
ArrayXd = typing.Union[ForwardRef('Floats1d'), ForwardRef(...2d'), For...
Callable = typing.Callable
Deprecated alias to collections.abc.Callable.
Callable[[int], str] signifies a function that takes a single
parameter of type int and returns a str.
The subscription syntax must always be used with exactly two
values: the argument list and the return type.
The argument list must be a list of types, a ParamSpec,
Concatenate or ellipsis. The return type must be a single type.
There is no syntax to indicate optional or keyword arguments;
such function types are rarely used as callback types.
ID = 64
InT = typing.List[spacy.tokens.doc.Doc]
Iterable = typing.Iterable
A generic version of collections.abc.Iterable.
List = typing.List
A generic version of list.
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
NEG_VALUE = -5000
OOV_RANK = 18446744073709551615
ORTH = 65
Optional = typing.Optional
Optional[X] is equivalent to Union[X, None].
TYPE_CHECKING = False
Tuple = typing.Tuple
Deprecated alias to builtins.tuple.
Tuple[X, Y] is the cross-product type of X and Y.
Example: Tuple[T1, T2] is a tuple of two elements corresponding
to type variables T1 and T2. Tuple[int, float, str] is a tuple
of an int, a float and a string.
To specify a variable-length tuple of homogeneous type, use Tuple[T, ...].
Union = typing.Union
Union type; Union[X, Y] means either X or Y.
On Python 3.10 and higher, the | operator
can also be used to denote unions;
X | Y means the same thing to the type checker as Union[X, Y].
To define a union, use e.g. Union[int, str]. Details:
- The arguments must be types and there must be at least one.
- None as an argument is a special case and is replaced by
type(None).
- Unions of unions are flattened, e.g.::
assert Union[Union[int, str], float] == Union[int, str, float]
- Unions of a single argument vanish, e.g.::
assert Union[int] == int # The constructor actually returns int
- Redundant arguments are skipped, e.g.::
assert Union[int, str, int] == Union[int, str]
- When comparing unions, the argument order is ignored, e.g.::
assert Union[int, str] == Union[str, int]
- You cannot subclass or instantiate a union.
- You can use Optional[X] as a shorthand for Union[X, None].
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\ml\__init__.py
spacy.morphology
Python Library Documentation: module spacy.morphology in spacy
NAME
spacy.morphology
CLASSES
builtins.object
Morphology
class Morphology(builtins.object)
| Morphology(StringStore strings)
|
| Store the possible morphological analyses for a language, and index them
| by hash.
|
| To save space on each token, tokens only know the hash of their
| morphological analysis, so queries of morphological attributes are delegated
| to this class.
|
| Methods defined here:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __reduce__(self)
| Morphology.__reduce__(self)
|
| add(self, features)
| Morphology.add(self, features)
|
| Insert a morphological analysis in the morphology table, if not
| already present. The morphological analysis may be provided in the UD
| FEATS format as a string or in the tag map dict format.
| Returns the hash of the new analysis.
|
| get(self, morph)
| Morphology.get(self, hash_t morph)
|
| normalize_attrs(self, attrs)
| Morphology.normalize_attrs(self, attrs)
|
| Convert attrs dict so that POS is always by ID, other features are
| by string. Values separated by VALUE_SEP are sorted.
|
| normalize_features(self, features)
| Morphology.normalize_features(self, features)
|
| Create a normalized FEATS string from a features string or dict.
|
| features (Union[dict, str]): Features as dict or UFEATS string.
| RETURNS (str): Features as normalized UFEATS string.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| dict_to_feats(feats_dict)
| Morphology.dict_to_feats(feats_dict)
|
| feats_to_dict(feats)
| Morphology.feats_to_dict(feats)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| mem
|
| strings
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| EMPTY_MORPH = '_'
|
| FEATURE_SEP = '|'
|
| FIELD_SEP = '='
|
| VALUE_SEP = ','
|
| __pyx_vtable__ = <capsule object NULL>
FUNCTIONS
unpickle_morphology(strings, tags)
unpickle_morphology(strings, tags)
DATA
POS_IDS = {'': <univ_pos_t.NO_TAG: 0>, 'ADJ': <univ_pos_t.ADJ: 84>, 'A...
__pyx_capi__ = {'check_feature': <capsule object "int (struct __pyx_t_...
__test__ = {}
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\morphology.cp312-win_amd64.pyd
spacy.parts_of_speech
Python Library Documentation: module spacy.parts_of_speech in spacy
NAME
spacy.parts_of_speech
CLASSES
enum.IntFlag(builtins.int, enum.ReprEnum, enum.Flag)
univ_pos_t
class univ_pos_t(enum.IntFlag)
| univ_pos_t(*values)
|
| Method resolution order:
| univ_pos_t
| enum.IntFlag
| builtins.int
| enum.ReprEnum
| enum.Flag
| enum.Enum
| builtins.object
|
| Methods defined here:
|
| __and__(self, other) from enum.Flag
|
| __format__(self, format_spec, /) from builtins.int
| Convert to a string according to format_spec.
|
| __invert__(self) from enum.Flag
|
| __new__(cls, value) from enum.Enum
| Create and return a new object. See help(type) for accurate signature.
|
| __or__(self, other) from enum.Flag
| Return self|value.
|
| __rand__ = __and__(self, other)
|
| __ror__ = __or__(self, other)
|
| __rxor__ = __xor__(self, other)
|
| __xor__(self, other) from enum.Flag
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| ADJ = <univ_pos_t.ADJ: 84>
|
| ADP = <univ_pos_t.ADP: 85>
|
| ADV = <univ_pos_t.ADV: 86>
|
| AUX = <univ_pos_t.AUX: 87>
|
| CCONJ = <univ_pos_t.CCONJ: 89>
|
| CONJ = <univ_pos_t.CONJ: 88>
|
| DET = <univ_pos_t.DET: 90>
|
| EOL = <univ_pos_t.EOL: 102>
|
| INTJ = <univ_pos_t.INTJ: 91>
|
| NOUN = <univ_pos_t.NOUN: 92>
|
| NO_TAG = <univ_pos_t.NO_TAG: 0>
|
| NUM = <univ_pos_t.NUM: 93>
|
| PART = <univ_pos_t.PART: 94>
|
| PRON = <univ_pos_t.PRON: 95>
|
| PROPN = <univ_pos_t.PROPN: 96>
|
| PUNCT = <univ_pos_t.PUNCT: 97>
|
| SCONJ = <univ_pos_t.SCONJ: 98>
|
| SPACE = <univ_pos_t.SPACE: 103>
|
| SYM = <univ_pos_t.SYM: 99>
|
| VERB = <univ_pos_t.VERB: 100>
|
| X = <univ_pos_t.X: 101>
|
| ----------------------------------------------------------------------
| Methods inherited from enum.IntFlag:
|
| __repr__(self) from enum.Flag
| Return repr(self).
|
| __str__ = __repr__(self, /) from builtins.int
| Return repr(self).
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.int:
|
| __abs__(self, /)
| abs(self)
|
| __add__(self, value, /)
| Return self+value.
|
| __bool__(self, /)
| True if self else False
|
| __ceil__(...)
| Ceiling of an Integral returns itself.
|
| __divmod__(self, value, /)
| Return divmod(self, value).
|
| __eq__(self, value, /)
| Return self==value.
|
| __float__(self, /)
| float(self)
|
| __floor__(...)
| Flooring an Integral returns itself.
|
| __floordiv__(self, value, /)
| Return self//value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getnewargs__(self, /)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __index__(self, /)
| Return self converted to an integer, if self is suitable for use as an index into a list.
|
| __int__(self, /)
| int(self)
|
| __le__(self, value, /)
| Return self<=value.
|
| __lshift__(self, value, /)
| Return self<<value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __mod__(self, value, /)
| Return self%value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __neg__(self, /)
| -self
|
| __pos__(self, /)
| +self
|
| __pow__(self, value, mod=None, /)
| Return pow(self, value, mod).
|
| __radd__(self, value, /)
| Return value+self.
|
| __rdivmod__(self, value, /)
| Return divmod(value, self).
|
| __rfloordiv__(self, value, /)
| Return value//self.
|
| __rlshift__(self, value, /)
| Return value<<self.
|
| __rmod__(self, value, /)
| Return value%self.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __round__(...)
| Rounding an Integral returns itself.
|
| Rounding with an ndigits argument also returns an integer.
|
| __rpow__(self, value, mod=None, /)
| Return pow(value, self, mod).
|
| __rrshift__(self, value, /)
| Return value>>self.
|
| __rshift__(self, value, /)
| Return self>>value.
|
| __rsub__(self, value, /)
| Return value-self.
|
| __rtruediv__(self, value, /)
| Return value/self.
|
| __sizeof__(self, /)
| Returns size in memory, in bytes.
|
| __sub__(self, value, /)
| Return self-value.
|
| __truediv__(self, value, /)
| Return self/value.
|
| __trunc__(...)
| Truncating an Integral returns itself.
|
| as_integer_ratio(self, /)
| Return a pair of integers, whose ratio is equal to the original int.
|
| The ratio is in lowest terms and has a positive denominator.
|
| >>> (10).as_integer_ratio()
| (10, 1)
| >>> (-10).as_integer_ratio()
| (-10, 1)
| >>> (0).as_integer_ratio()
| (0, 1)
|
| bit_count(self, /)
| Number of ones in the binary representation of the absolute value of self.
|
| Also known as the population count.
|
| >>> bin(13)
| '0b1101'
| >>> (13).bit_count()
| 3
|
| bit_length(self, /)
| Number of bits necessary to represent self in binary.
|
| >>> bin(37)
| '0b100101'
| >>> (37).bit_length()
| 6
|
| conjugate(...)
| Returns self, the complex conjugate of any int.
|
| is_integer(self, /)
| Returns True. Exists for duck type compatibility with float.is_integer.
|
| to_bytes(self, /, length=1, byteorder='big', *, signed=False)
| Return an array of bytes representing an integer.
|
| length
| Length of bytes object to use. An OverflowError is raised if the
| integer is not representable with the given number of bytes. Default
| is length 1.
| byteorder
| The byte order used to represent the integer. If byteorder is 'big',
| the most significant byte is at the beginning of the byte array. If
| byteorder is 'little', the most significant byte is at the end of the
| byte array. To request the native byte order of the host system, use
| `sys.byteorder' as the byte order value. Default is to use 'big'.
| signed
| Determines whether two's complement is used to represent the integer.
| If signed is False and a negative integer is given, an OverflowError
| is raised.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.int:
|
| from_bytes(bytes, byteorder='big', *, signed=False)
| Return the integer represented by the given array of bytes.
|
| bytes
| Holds the array of bytes to convert. The argument must either
| support the buffer protocol or be an iterable object producing bytes.
| Bytes and bytearray are examples of built-in objects that support the
| buffer protocol.
| byteorder
| The byte order used to represent the integer. If byteorder is 'big',
| the most significant byte is at the beginning of the byte array. If
| byteorder is 'little', the most significant byte is at the end of the
| byte array. To request the native byte order of the host system, use
| `sys.byteorder' as the byte order value. Default is to use 'big'.
| signed
| Indicates whether two's complement is used to represent the integer.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from builtins.int:
|
| denominator
| the denominator of a rational number in lowest terms
|
| imag
| the imaginary part of a complex number
|
| numerator
| the numerator of a rational number in lowest terms
|
| real
| the real part of a complex number
|
| ----------------------------------------------------------------------
| Methods inherited from enum.Flag:
|
| __contains__(self, other)
| Returns True if self has at least the same flags set as other.
|
| __iter__(self)
| Returns flags in definition order.
|
| __len__(self)
| Return the number of members (no aliases)
|
| ----------------------------------------------------------------------
| Methods inherited from enum.Enum:
|
| __dir__(self)
| Returns public methods and other interesting attributes.
|
| __init__(self, *args, **kwds)
| Initialize self. See help(type(self)) for accurate signature.
|
| __reduce_ex__(self, proto)
| Helper for pickle.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from enum.Enum:
|
| name
| The name of the Enum member.
|
| value
| The value of the Enum member.
|
| ----------------------------------------------------------------------
| Static methods inherited from enum.EnumType:
|
| __getitem__(name)
| Return the member matching `name`.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from enum.EnumType:
|
| __members__
| Returns a mapping of member name->value.
|
| This mapping lists all enum members, including aliases. Note that this
| is a read-only view of the internal mapping.
DATA
<univ_pos_t.NO_TAG: 0>
ADJ = <univ_pos_t.ADJ: 84>
ADP = <univ_pos_t.ADP: 85>
ADV = <univ_pos_t.ADV: 86>
AUX = <univ_pos_t.AUX: 87>
CCONJ = <univ_pos_t.CCONJ: 89>
CONJ = <univ_pos_t.CONJ: 88>
DET = <univ_pos_t.DET: 90>
EOL = <univ_pos_t.EOL: 102>
IDS = {'': <univ_pos_t.NO_TAG: 0>, 'ADJ': <univ_pos_t.ADJ: 84>, 'ADP':...
INTJ = <univ_pos_t.INTJ: 91>
NAMES = {<univ_pos_t.NO_TAG: 0>: '', <univ_pos_t.ADJ: 84>: 'ADJ', <uni...
NOUN = <univ_pos_t.NOUN: 92>
NUM = <univ_pos_t.NUM: 93>
PART = <univ_pos_t.PART: 94>
PRON = <univ_pos_t.PRON: 95>
PROPN = <univ_pos_t.PROPN: 96>
PUNCT = <univ_pos_t.PUNCT: 97>
SCONJ = <univ_pos_t.SCONJ: 98>
SPACE = <univ_pos_t.SPACE: 103>
SYM = <univ_pos_t.SYM: 99>
VERB = <univ_pos_t.VERB: 100>
X = <univ_pos_t.X: 101>
__test__ = {}
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\parts_of_speech.cp312-win_amd64.pyd
spacy.pipe_analysis
Python Library Documentation: module spacy.pipe_analysis in spacy
NAME
spacy.pipe_analysis
FUNCTIONS
analyze_pipes(nlp: 'Language', *, keys: List[str] = ['requires', 'assigns', 'scores', 'retokenizes']) -> Dict[str, Dict[str, Union[List[str], Dict]]]
Print a formatted summary for the current nlp object's pipeline. Shows
a table with the pipeline components and why they assign and require, as
well as any problems if available.
nlp (Language): The nlp object.
keys (List[str]): The meta keys to show in the table.
RETURNS (dict): A dict with "summary" and "problems".
get_attr_info(nlp: 'Language', attr: str) -> Dict[str, List[str]]
Check which components in the pipeline assign or require an attribute.
nlp (Language): The current nlp object.
attr (str): The attribute, e.g. "doc.tensor".
RETURNS (Dict[str, List[str]]): A dict keyed by "assigns" and "requires",
mapped to a list of component names.
print_pipe_analysis(analysis: Dict[str, Dict[str, Union[List[str], Dict]]], *, keys: List[str] = ['requires', 'assigns', 'scores', 'retokenizes']) -> None
Print a formatted version of the pipe analysis produced by analyze_pipes.
analysis (Dict[str, Union[List[str], Dict[str, List[str]]]]): The analysis.
keys (List[str]): The meta keys to show in the table.
validate_attrs(values: Iterable[str]) -> Iterable[str]
Validate component attributes provided to "assigns", "requires" etc.
Raises error for invalid attributes and formatting. Doesn't check if
custom extension attributes are registered, since this is something the
user might want to do themselves later in the component.
values (Iterable[str]): The string attributes to check, e.g. `["token.pos"]`.
RETURNS (Iterable[str]): The checked attributes.
DATA
DEFAULT_KEYS = ['requires', 'assigns', 'scores', 'retokenizes']
Dict = typing.Dict
A generic version of dict.
ItemsView = typing.ItemsView
A generic version of collections.abc.ItemsView.
Iterable = typing.Iterable
A generic version of collections.abc.Iterable.
List = typing.List
A generic version of list.
Set = typing.Set
A generic version of set.
TYPE_CHECKING = False
Union = typing.Union
Union type; Union[X, Y] means either X or Y.
On Python 3.10 and higher, the | operator
can also be used to denote unions;
X | Y means the same thing to the type checker as Union[X, Y].
To define a union, use e.g. Union[int, str]. Details:
- The arguments must be types and there must be at least one.
- None as an argument is a special case and is replaced by
type(None).
- Unions of unions are flattened, e.g.::
assert Union[Union[int, str], float] == Union[int, str, float]
- Unions of a single argument vanish, e.g.::
assert Union[int] == int # The constructor actually returns int
- Redundant arguments are skipped, e.g.::
assert Union[int, str, int] == Union[int, str]
- When comparing unions, the argument order is ignored, e.g.::
assert Union[int, str] == Union[str, int]
- You cannot subclass or instantiate a union.
- You can use Optional[X] as a shorthand for Union[X, None].
msg = <wasabi.printer.Printer object>
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\pipe_analysis.py
spacy.pipeline
Python Library Documentation: package spacy.pipeline in spacy
NAME
spacy.pipeline
PACKAGE CONTENTS
_edit_tree_internals (package)
_parser_internals (package)
attributeruler
dep_parser
edit_tree_lemmatizer
entity_linker
entityruler
factories
functions
legacy (package)
lemmatizer
morphologizer
multitask
ner
pipe
sentencizer
senter
span_finder
span_ruler
spancat
tagger
textcat
textcat_multilabel
tok2vec
trainable_pipe
transition_parser
CLASSES
builtins.object
spacy.pipeline.pipe.Pipe
spacy.pipeline.attributeruler.AttributeRuler
spacy.pipeline.entityruler.EntityRuler
spacy.pipeline.lemmatizer.Lemmatizer
spacy.pipeline.sentencizer.Sentencizer
spacy.pipeline.span_ruler.SpanRuler
spacy.pipeline.trainable_pipe.TrainablePipe
spacy.pipeline.edit_tree_lemmatizer.EditTreeLemmatizer
spacy.pipeline.entity_linker.EntityLinker
spacy.pipeline.span_finder.SpanFinder
spacy.pipeline.spancat.SpanCategorizer
spacy.pipeline.tagger.Tagger
spacy.pipeline.morphologizer.Morphologizer
spacy.pipeline.senter.SentenceRecognizer
spacy.pipeline.textcat.TextCategorizer
spacy.pipeline.textcat_multilabel.MultiLabel_TextCategorizer
spacy.pipeline.tok2vec.Tok2Vec
spacy.pipeline.transition_parser.Parser(spacy.pipeline.trainable_pipe.TrainablePipe)
spacy.pipeline.dep_parser.DependencyParser
spacy.pipeline.ner.EntityRecognizer
class AttributeRuler(spacy.pipeline.pipe.Pipe)
| AttributeRuler(vocab: spacy.vocab.Vocab, name: str = 'attribute_ruler', *, validate: bool = False, scorer: Optional[Callable] = <function attribute_ruler_score at 0x000002215458E980>) -> None
|
| Set token-level attributes for tokens matched by Matcher patterns.
| Additionally supports importing patterns from tag maps and morph rules.
|
| DOCS: https://spacy.io/api/attributeruler
|
| Method resolution order:
| AttributeRuler
| spacy.pipeline.pipe.Pipe
| builtins.object
|
| Methods defined here:
|
| __call__(self, doc: spacy.tokens.doc.Doc) -> spacy.tokens.doc.Doc
| Apply the AttributeRuler to a Doc and set all attribute exceptions.
|
| doc (Doc): The document to process.
| RETURNS (Doc): The processed Doc.
|
| DOCS: https://spacy.io/api/attributeruler#call
|
| __init__(self, vocab: spacy.vocab.Vocab, name: str = 'attribute_ruler', *, validate: bool = False, scorer: Optional[Callable] = <function attribute_ruler_score at 0x000002215458E980>) -> None
| Create the AttributeRuler. After creation, you can add patterns
| with the `.initialize()` or `.add_patterns()` methods, or load patterns
| with `.from_bytes()` or `.from_disk()`. Loading patterns will remove
| any patterns you've added previously.
|
| vocab (Vocab): The vocab.
| name (str): The pipe name. Defaults to "attribute_ruler".
| scorer (Optional[Callable]): The scoring method. Defaults to
| Scorer.score_token_attr for the attributes "tag", "pos", "morph" and
| "lemma" and Scorer.score_token_attr_per_feat for the attribute
| "morph".
|
| RETURNS (AttributeRuler): The AttributeRuler component.
|
| DOCS: https://spacy.io/api/attributeruler#init
|
| add(self, patterns: Iterable[List[Dict[Union[int, str], Any]]], attrs: Dict, index: int = 0) -> None
| Add Matcher patterns for tokens that should be modified with the
| provided attributes. The token at the specified index within the
| matched span will be assigned the attributes.
|
| patterns (Iterable[List[Dict]]): A list of Matcher patterns.
| attrs (Dict): The attributes to assign to the target token in the
| matched span.
| index (int): The index of the token in the matched span to modify. May
| be negative to index from the end of the span. Defaults to 0.
|
| DOCS: https://spacy.io/api/attributeruler#add
|
| add_patterns(self, patterns: Iterable[Dict[str, Union[List[List[Dict[Union[int, str], Any]]], List[Dict[Union[int, str], Any]], Dict, int]]]) -> None
| Add patterns from a list of pattern dicts with the keys as the
| arguments to AttributeRuler.add.
| patterns (Iterable[dict]): A list of pattern dicts with the keys
| as the arguments to AttributeRuler.add (patterns/attrs/index) to
| add as patterns.
|
| DOCS: https://spacy.io/api/attributeruler#add_patterns
|
| clear(self) -> None
| Reset all patterns.
|
| from_bytes(self, bytes_data: bytes, exclude: Iterable[str] = []) -> 'AttributeRuler'
| Load the AttributeRuler from a bytestring.
|
| bytes_data (bytes): The data to load.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| returns (AttributeRuler): The loaded object.
|
| DOCS: https://spacy.io/api/attributeruler#from_bytes
|
| from_disk(self, path: Union[pathlib.Path, str], exclude: Iterable[str] = []) -> 'AttributeRuler'
| Load the AttributeRuler from disk.
|
| path (Union[Path, str]): A path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (AttributeRuler): The loaded object.
|
| DOCS: https://spacy.io/api/attributeruler#from_disk
|
| initialize(self, get_examples: Optional[Callable[[], Iterable[spacy.training.example.Example]]], *, nlp: Optional[spacy.language.Language] = None, patterns: Optional[Iterable[Dict[str, Union[List[List[Dict[Union[int, str], Any]]], List[Dict[Union[int, str], Any]], Dict, int]]]] = None, tag_map: Optional[Dict[str, Dict[Union[int, str], Union[int, str]]]] = None, morph_rules: Optional[Dict[str, Dict[str, Dict[Union[int, str], Union[int, str]]]]] = None) -> None
| Initialize the attribute ruler by adding zero or more patterns.
|
| Rules can be specified as a sequence of dicts using the `patterns`
| keyword argument. You can also provide rules using the "tag map" or
| "morph rules" formats supported by spaCy prior to v3.
|
| load_from_morph_rules(self, morph_rules: Dict[str, Dict[str, Dict[Union[int, str], Union[int, str]]]]) -> None
| Load attribute ruler patterns from morph rules.
|
| morph_rules (dict): The morph rules that map token text and
| fine-grained tags to coarse-grained tags, lemmas and morphological
| features.
|
| DOCS: https://spacy.io/api/attributeruler#load_from_morph_rules
|
| load_from_tag_map(self, tag_map: Dict[str, Dict[Union[int, str], Union[int, str]]]) -> None
| Load attribute ruler patterns from a tag map.
|
| tag_map (dict): The tag map that maps fine-grained tags to
| coarse-grained tags and morphological features.
|
| DOCS: https://spacy.io/api/attributeruler#load_from_morph_rules
|
| match(self, doc: spacy.tokens.doc.Doc)
|
| set_annotations(self, doc, matches)
| Modify the document in place
|
| to_bytes(self, exclude: Iterable[str] = []) -> bytes
| Serialize the AttributeRuler to a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (bytes): The serialized object.
|
| DOCS: https://spacy.io/api/attributeruler#to_bytes
|
| to_disk(self, path: Union[pathlib.Path, str], exclude: Iterable[str] = []) -> None
| Serialize the AttributeRuler to disk.
|
| path (Union[Path, str]): A path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
|
| DOCS: https://spacy.io/api/attributeruler#to_disk
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| patterns
| All the added patterns.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.pipe.Pipe:
|
| __reduce__ = __reduce_cython__(...)
| Pipe.__reduce_cython__(self)
|
| __reduce_cython__(self)
| Pipe.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| Pipe.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| Pipe.__setstate_cython__(self, __pyx_state)
|
| get_error_handler(self) -> 'Callable'
| Pipe.get_error_handler(self) -> Callable
|
| Retrieve the error handler function.
|
| RETURNS (Callable): The error handler, or if it's not set a default function that just reraises.
|
| DOCS: https://spacy.io/api/pipe#get_error_handler
|
| pipe(self, stream: 'Iterable[Doc]', *, batch_size: 'int' = 128) -> 'Iterator[Doc]'
| Pipe.pipe(self, stream: Iterable[Doc], *, batch_size: int = 128) -> Iterator[Doc]
|
| Apply the pipe to a stream of documents. This usually happens under
| the hood when the nlp object is called on a text and all components are
| applied to the Doc.
|
| stream (Iterable[Doc]): A stream of documents.
| batch_size (int): The number of documents to buffer.
| YIELDS (Doc): Processed documents in order.
|
| DOCS: https://spacy.io/api/pipe#pipe
|
| score(self, examples: 'Iterable[Example]', **kwargs) -> 'Dict[str, Union[float, Dict[str, float]]]'
| Pipe.score(self, examples: Iterable[Example], **kwargs) -> Dict[str, Union[float, Dict[str, float]]]
|
| Score a batch of examples.
|
| examples (Iterable[Example]): The examples to score.
| RETURNS (Dict[str, Any]): The scores.
|
| DOCS: https://spacy.io/api/pipe#score
|
| set_error_handler(self, error_handler: 'Callable') -> 'None'
| Pipe.set_error_handler(self, error_handler: Callable) -> None
|
| Set an error handler function.
|
| error_handler (Callable[[str, Callable[[Doc], Doc], List[Doc], Exception], None]):
| Function that deals with a failing batch of documents. This callable function should take in
| the component's name, the component itself, the offending batch of documents, and the exception
| that was thrown.
|
| DOCS: https://spacy.io/api/pipe#set_error_handler
|
| ----------------------------------------------------------------------
| Static methods inherited from spacy.pipeline.pipe.Pipe:
|
| __new__(*args, **kwargs) class method of spacy.pipeline.pipe.Pipe
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.pipe.Pipe:
|
| hide_labels
| Pipe.hide_labels: bool
|
| is_trainable
| Pipe.is_trainable: bool
|
| label_data
| Optional JSON-serializable data that would be sufficient to recreate
| the label set if provided to the `pipe.initialize()` method.
|
| labels
| Pipe.labels: Tuple[str, ...]
|
| name
| name: str
class DependencyParser(spacy.pipeline.transition_parser.Parser)
| DependencyParser(vocab, model, name='parser', moves=None, update_with_oracle_cut_size=100, *, min_action_freq=30, learn_tokens=False, beam_width=1, beam_density=0.0, beam_update_prob=0.0, multitasks=tuple(), incorrect_spans_key=None, scorer=parser_score)
|
| Pipeline component for dependency parsing.
|
| DOCS: https://spacy.io/api/dependencyparser
|
| Method resolution order:
| DependencyParser
| spacy.pipeline.transition_parser.Parser
| spacy.pipeline.trainable_pipe.TrainablePipe
| spacy.pipeline.pipe.Pipe
| builtins.object
|
| Methods defined here:
|
| __init__(...)
| Create a DependencyParser.
|
| __reduce__ = __reduce_cython__(...)
| DependencyParser.__reduce_cython__(self)
|
| __reduce_cython__(self)
| DependencyParser.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| DependencyParser.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| DependencyParser.__setstate_cython__(self, __pyx_state)
|
| add_multitask_objective(self, mt_component)
| DependencyParser.add_multitask_objective(self, mt_component)
|
| init_multitask_objectives(self, get_examples, nlp=None, **cfg)
| DependencyParser.init_multitask_objectives(self, get_examples, nlp=None, **cfg)
|
| scored_parses(self, beams)
| DependencyParser.scored_parses(self, beams)
|
| Return two dictionaries with scores for each beam/doc that was processed:
| one containing (i, head) keys, and another containing (i, label) keys.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| labels
| Pipe.labels: Tuple[str, ...]
|
| postprocesses
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| TransitionSystem = <class 'spacy.pipeline._parser_internals.arc_eager....
| ArcEager(*args, **kwargs)
|
|
| __pyx_vtable__ = <capsule object NULL>
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.transition_parser.Parser:
|
| __getnewargs_ex__(self)
| Parser.__getnewargs_ex__(self)
|
| This allows pickling the Parser and its keyword-only init arguments
|
| add_label(self, label)
| Parser.add_label(self, label)
|
| beam_parse(self, docs, beam_width, drop=0.0, beam_density=0.0)
| Parser.beam_parse(self, docs, int beam_width, float drop=0., beam_density=0.)
|
| from_bytes(self, bytes_data, exclude=())
| Parser.from_bytes(self, bytes_data, exclude=tuple())
|
| from_disk(self, path, exclude=())
| Parser.from_disk(self, path, exclude=tuple())
|
| get_batch_loss(self, states, golds, scores, losses)
| Parser.get_batch_loss(self, states, golds, float[:, ::1] scores, losses)
|
| greedy_parse(self, docs, drop=0.0)
| Parser.greedy_parse(self, docs, drop=0.)
|
| initialize(self, get_examples, nlp=None, labels=None)
| Parser.initialize(self, get_examples, nlp=None, labels=None)
|
| pipe(self, docs, *, batch_size=256)
| Parser.pipe(self, docs, *, int batch_size=256)
|
| Process a stream of documents.
|
| stream: The sequence of documents to process.
| batch_size (int): Number of documents to accumulate into a working set.
| error_handler (Callable[[str, List[Doc], Exception], Any]): Function that
| deals with a failing batch of documents. The default function just reraises
| the exception.
|
| YIELDS (Doc): Documents, in order.
|
| predict(self, docs)
| Parser.predict(self, docs)
|
| rehearse(self, examples, sgd=None, losses=None, **cfg)
| Parser.rehearse(self, examples, sgd=None, losses=None, **cfg)
|
| Perform a "rehearsal" update, to prevent catastrophic forgetting.
|
| set_annotations(self, docs, states_or_beams)
| Parser.set_annotations(self, docs, states_or_beams)
|
| set_output(self, nO)
| Parser.set_output(self, nO)
|
| to_bytes(self, exclude=())
| Parser.to_bytes(self, exclude=tuple())
|
| to_disk(self, path, exclude=())
| Parser.to_disk(self, path, exclude=tuple())
|
| transition_states(self, states, scores)
| Parser.transition_states(self, states, float[:, ::1] scores)
|
| update(self, examples, *, drop=0.0, sgd=None, losses=None)
| Parser.update(self, examples, *, drop=0., sgd=None, losses=None)
|
| update_beam(self, examples, *, beam_width, drop=0.0, sgd=None, losses=None, beam_density=0.0)
| Parser.update_beam(self, examples, *, beam_width, drop=0., sgd=None, losses=None, beam_density=0.0)
|
| use_params(self, params)
| Parser.use_params(self, params)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.transition_parser.Parser:
|
| incorrect_spans_key
|
| label_data
| Optional JSON-serializable data that would be sufficient to recreate
| the label set if provided to the `pipe.initialize()` method.
|
| move_names
|
| moves
|
| tok2vec
| Return the embedding and convolutional layer of the model.
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __call__(...)
| TrainablePipe.__call__(self, Doc doc) -> Doc
|
| Apply the pipe to one document. The document is modified in place,
| and returned. This usually happens under the hood when the nlp object
| is called on a text and all components are applied to the Doc.
|
| docs (Doc): The Doc to process.
| RETURNS (Doc): The processed Doc.
|
| DOCS: https://spacy.io/api/pipe#call
|
| create_optimizer(self) -> 'Optimizer'
| TrainablePipe.create_optimizer(self) -> Optimizer
|
| Create an optimizer for the pipeline component.
|
| RETURNS (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#create_optimizer
|
| finish_update(self, sgd: 'Optimizer') -> 'None'
| TrainablePipe.finish_update(self, sgd: Optimizer) -> None
|
| Update parameters using the current parameter gradients.
| The Optimizer instance contains the functionality to perform
| the stochastic gradient descent.
|
| sgd (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#finish_update
|
| get_loss(self, examples: 'Iterable[Example]', scores) -> 'Tuple[float, float]'
| TrainablePipe.get_loss(self, examples: Iterable[Example], scores) -> Tuple[float, float]
|
| Find the loss and gradient of loss for the batch of documents and
| their predicted scores.
|
| examples (Iterable[Examples]): The batch of examples.
| scores: Scores representing the model's predictions.
| RETURNS (Tuple[float, float]): The loss and the gradient.
|
| DOCS: https://spacy.io/api/pipe#get_loss
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| cfg
| cfg: object
|
| is_resizable
| TrainablePipe.is_resizable: bool
|
| is_trainable
| TrainablePipe.is_trainable: bool
|
| model
| model: object
|
| scorer
| scorer: object
|
| vocab
| vocab: spacy.vocab.Vocab
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.pipe.Pipe:
|
| get_error_handler(self) -> 'Callable'
| Pipe.get_error_handler(self) -> Callable
|
| Retrieve the error handler function.
|
| RETURNS (Callable): The error handler, or if it's not set a default function that just reraises.
|
| DOCS: https://spacy.io/api/pipe#get_error_handler
|
| score(self, examples: 'Iterable[Example]', **kwargs) -> 'Dict[str, Union[float, Dict[str, float]]]'
| Pipe.score(self, examples: Iterable[Example], **kwargs) -> Dict[str, Union[float, Dict[str, float]]]
|
| Score a batch of examples.
|
| examples (Iterable[Example]): The examples to score.
| RETURNS (Dict[str, Any]): The scores.
|
| DOCS: https://spacy.io/api/pipe#score
|
| set_error_handler(self, error_handler: 'Callable') -> 'None'
| Pipe.set_error_handler(self, error_handler: Callable) -> None
|
| Set an error handler function.
|
| error_handler (Callable[[str, Callable[[Doc], Doc], List[Doc], Exception], None]):
| Function that deals with a failing batch of documents. This callable function should take in
| the component's name, the component itself, the offending batch of documents, and the exception
| that was thrown.
|
| DOCS: https://spacy.io/api/pipe#set_error_handler
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.pipe.Pipe:
|
| hide_labels
| Pipe.hide_labels: bool
|
| name
| name: str
class EditTreeLemmatizer(spacy.pipeline.trainable_pipe.TrainablePipe)
| EditTreeLemmatizer(vocab: spacy.vocab.Vocab, model: thinc.model.Model, name: str = 'trainable_lemmatizer', *, backoff: Optional[str] = 'orth', min_tree_freq: int = 3, overwrite: bool = False, top_k: int = 1, scorer: Optional[Callable] = <function lemmatizer_score at 0x0000022154B69EE0>)
|
| Lemmatizer that lemmatizes each word using a predicted edit tree.
|
| Method resolution order:
| EditTreeLemmatizer
| spacy.pipeline.trainable_pipe.TrainablePipe
| spacy.pipeline.pipe.Pipe
| builtins.object
|
| Methods defined here:
|
| __init__(self, vocab: spacy.vocab.Vocab, model: thinc.model.Model, name: str = 'trainable_lemmatizer', *, backoff: Optional[str] = 'orth', min_tree_freq: int = 3, overwrite: bool = False, top_k: int = 1, scorer: Optional[Callable] = <function lemmatizer_score at 0x0000022154B69EE0>)
| Construct an edit tree lemmatizer.
|
| backoff (Optional[str]): backoff to use when the predicted edit trees
| are not applicable. Must be an attribute of Token or None (leave the
| lemma unset).
| min_tree_freq (int): prune trees that are applied less than this
| frequency in the training data.
| overwrite (bool): overwrite existing lemma annotations.
| top_k (int): try to apply at most the k most probable edit trees.
|
| from_bytes(self, bytes_data, *, exclude=())
| TrainablePipe.from_bytes(self, bytes_data, *, exclude=tuple())
|
| Load the pipe from a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (TrainablePipe): The loaded object.
|
| DOCS: https://spacy.io/api/pipe#from_bytes
|
| from_disk(self, path, exclude=())
| TrainablePipe.from_disk(self, path, *, exclude=tuple())
|
| Load the pipe from disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (TrainablePipe): The loaded object.
|
| DOCS: https://spacy.io/api/pipe#from_disk
|
| get_loss(self, examples: Iterable[spacy.training.example.Example], scores: List[thinc.types.Floats2d]) -> Tuple[float, List[thinc.types.Floats2d]]
| TrainablePipe.get_loss(self, examples: Iterable[Example], scores) -> Tuple[float, float]
|
| Find the loss and gradient of loss for the batch of documents and
| their predicted scores.
|
| examples (Iterable[Examples]): The batch of examples.
| scores: Scores representing the model's predictions.
| RETURNS (Tuple[float, float]): The loss and the gradient.
|
| DOCS: https://spacy.io/api/pipe#get_loss
|
| initialize(self, get_examples: Callable[[], Iterable[spacy.training.example.Example]], *, nlp: Optional[spacy.language.Language] = None, labels: Optional[Dict] = None)
| TrainablePipe.initialize(self, get_examples: Callable[[], Iterable[Example]], *, nlp: Language = None)
|
| Initialize the pipe for training, using data examples if available.
| This method needs to be implemented by each TrainablePipe component,
| ensuring the internal model (if available) is initialized properly
| using the provided sample of Example objects.
|
| get_examples (Callable[[], Iterable[Example]]): Function that
| returns a representative sample of gold-standard Example objects.
| nlp (Language): The current nlp object the component is part of.
|
| DOCS: https://spacy.io/api/pipe#initialize
|
| predict(self, docs: Iterable[spacy.tokens.doc.Doc]) -> List[thinc.types.Ints2d]
| TrainablePipe.predict(self, docs: Iterable[Doc])
|
| Apply the pipeline's model to a batch of docs, without modifying them.
| Returns a single tensor for a batch of documents.
|
| docs (Iterable[Doc]): The documents to predict.
| RETURNS: Vector representations of the predictions.
|
| DOCS: https://spacy.io/api/pipe#predict
|
| set_annotations(self, docs: Iterable[spacy.tokens.doc.Doc], batch_tree_ids)
| TrainablePipe.set_annotations(self, docs: Iterable[Doc], scores)
|
| Modify a batch of documents, using pre-computed scores.
|
| docs (Iterable[Doc]): The documents to modify.
| scores: The scores to assign.
|
| DOCS: https://spacy.io/api/pipe#set_annotations
|
| to_bytes(self, *, exclude=())
| TrainablePipe.to_bytes(self, *, exclude=tuple())
|
| Serialize the pipe to a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (bytes): The serialized object.
|
| DOCS: https://spacy.io/api/pipe#to_bytes
|
| to_disk(self, path, exclude=())
| TrainablePipe.to_disk(self, path, *, exclude=tuple())
|
| Serialize the pipe to disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
|
| DOCS: https://spacy.io/api/pipe#to_disk
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| hide_labels
| Pipe.hide_labels: bool
|
| label_data
| Optional JSON-serializable data that would be sufficient to recreate
| the label set if provided to the `pipe.initialize()` method.
|
| labels
| Returns the labels currently added to the component.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __call__(...)
| TrainablePipe.__call__(self, Doc doc) -> Doc
|
| Apply the pipe to one document. The document is modified in place,
| and returned. This usually happens under the hood when the nlp object
| is called on a text and all components are applied to the Doc.
|
| docs (Doc): The Doc to process.
| RETURNS (Doc): The processed Doc.
|
| DOCS: https://spacy.io/api/pipe#call
|
| __reduce__ = __reduce_cython__(...)
| TrainablePipe.__reduce_cython__(self)
|
| __reduce_cython__(self)
| TrainablePipe.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| add_label(self, label: 'str') -> 'int'
| TrainablePipe.add_label(self, label: str) -> int
|
| Add an output label.
| For TrainablePipe components, it is possible to
| extend pretrained models with new labels, but care should be taken to
| avoid the "catastrophic forgetting" problem.
|
| label (str): The label to add.
| RETURNS (int): 0 if label is already present, otherwise 1.
|
| DOCS: https://spacy.io/api/pipe#add_label
|
| create_optimizer(self) -> 'Optimizer'
| TrainablePipe.create_optimizer(self) -> Optimizer
|
| Create an optimizer for the pipeline component.
|
| RETURNS (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#create_optimizer
|
| finish_update(self, sgd: 'Optimizer') -> 'None'
| TrainablePipe.finish_update(self, sgd: Optimizer) -> None
|
| Update parameters using the current parameter gradients.
| The Optimizer instance contains the functionality to perform
| the stochastic gradient descent.
|
| sgd (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#finish_update
|
| pipe(self, stream: 'Iterable[Doc]', *, batch_size: 'int' = 128) -> 'Iterator[Doc]'
| TrainablePipe.pipe(self, stream: Iterable[Doc], *, batch_size: int = 128) -> Iterator[Doc]
|
| Apply the pipe to a stream of documents. This usually happens under
| the hood when the nlp object is called on a text and all components are
| applied to the Doc.
|
| stream (Iterable[Doc]): A stream of documents.
| batch_size (int): The number of documents to buffer.
| error_handler (Callable[[str, List[Doc], Exception], Any]): Function that
| deals with a failing batch of documents. The default function just reraises
| the exception.
| YIELDS (Doc): Processed documents in order.
|
| DOCS: https://spacy.io/api/pipe#pipe
|
| rehearse(self, examples: 'Iterable[Example]', *, sgd: 'Optimizer' = None, losses: 'Dict[str, float]' = None, **config) -> 'Dict[str, float]'
| TrainablePipe.rehearse(self, examples: Iterable[Example], *, sgd: Optimizer = None, losses: Dict[str, float] = None, **config) -> Dict[str, float]
|
| Perform a "rehearsal" update from a batch of data. Rehearsal updates
| teach the current model to make predictions similar to an initial model,
| to try to address the "catastrophic forgetting" problem. This feature is
| experimental.
|
| examples (Iterable[Example]): A batch of Example objects.
| sgd (thinc.api.Optimizer): The optimizer.
| losses (Dict[str, float]): Optional record of the loss during training.
| Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/pipe#rehearse
|
| set_output(self, nO: 'int') -> 'None'
| TrainablePipe.set_output(self, nO: int) -> None
|
| update(self, examples: "Iterable['Example']", *, drop: 'float' = 0.0, sgd: 'Optimizer' = None, losses: 'Optional[Dict[str, float]]' = None) -> 'Dict[str, float]'
| TrainablePipe.update(self, examples: Iterable['Example'], *, drop: float = 0.0, sgd: Optimizer = None, losses: Optional[Dict[str, float]] = None) -> Dict[str, float]
|
| Learn from a batch of documents and gold-standard information,
| updating the pipe's model. Delegates to predict and get_loss.
|
| examples (Iterable[Example]): A batch of Example objects.
| drop (float): The dropout rate.
| sgd (thinc.api.Optimizer): The optimizer.
| losses (Dict[str, float]): Optional record of the loss during training.
| Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/pipe#update
|
| use_params(self, params: 'dict')
| TrainablePipe.use_params(self, params: dict)
|
| Modify the pipe's model, to use the given parameter values. At the
| end of the context, the original parameters are restored.
|
| params (dict): The parameter values to use in the model.
|
| DOCS: https://spacy.io/api/pipe#use_params
|
| ----------------------------------------------------------------------
| Static methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __new__(*args, **kwargs) class method of spacy.pipeline.trainable_pipe.TrainablePipe
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| cfg
| cfg: object
|
| is_resizable
| TrainablePipe.is_resizable: bool
|
| is_trainable
| TrainablePipe.is_trainable: bool
|
| model
| model: object
|
| scorer
| scorer: object
|
| vocab
| vocab: spacy.vocab.Vocab
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.pipe.Pipe:
|
| get_error_handler(self) -> 'Callable'
| Pipe.get_error_handler(self) -> Callable
|
| Retrieve the error handler function.
|
| RETURNS (Callable): The error handler, or if it's not set a default function that just reraises.
|
| DOCS: https://spacy.io/api/pipe#get_error_handler
|
| score(self, examples: 'Iterable[Example]', **kwargs) -> 'Dict[str, Union[float, Dict[str, float]]]'
| Pipe.score(self, examples: Iterable[Example], **kwargs) -> Dict[str, Union[float, Dict[str, float]]]
|
| Score a batch of examples.
|
| examples (Iterable[Example]): The examples to score.
| RETURNS (Dict[str, Any]): The scores.
|
| DOCS: https://spacy.io/api/pipe#score
|
| set_error_handler(self, error_handler: 'Callable') -> 'None'
| Pipe.set_error_handler(self, error_handler: Callable) -> None
|
| Set an error handler function.
|
| error_handler (Callable[[str, Callable[[Doc], Doc], List[Doc], Exception], None]):
| Function that deals with a failing batch of documents. This callable function should take in
| the component's name, the component itself, the offending batch of documents, and the exception
| that was thrown.
|
| DOCS: https://spacy.io/api/pipe#set_error_handler
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.pipe.Pipe:
|
| name
| name: str
class EntityLinker(spacy.pipeline.trainable_pipe.TrainablePipe)
| EntityLinker(vocab: spacy.vocab.Vocab, model: thinc.model.Model, name: str = 'entity_linker', *, labels_discard: Iterable[str], n_sents: int, incl_prior: bool, incl_context: bool, entity_vector_length: int, get_candidates: Callable[[spacy.kb.kb.KnowledgeBase, spacy.tokens.span.Span], Iterable[spacy.kb.candidate.Candidate]], get_candidates_batch: Callable[[spacy.kb.kb.KnowledgeBase, Iterable[spacy.tokens.span.Span]], Iterable[Iterable[spacy.kb.candidate.Candidate]]], generate_empty_kb: Callable[[spacy.vocab.Vocab, int], spacy.kb.kb.KnowledgeBase], overwrite: bool = True, scorer: Optional[Callable] = <function entity_linker_score at 0x0000022154BA8180>, use_gold_ents: bool, candidates_batch_size: int, threshold: Optional[float] = None) -> None
|
| Pipeline component for named entity linking.
|
| DOCS: https://spacy.io/api/entitylinker
|
| Method resolution order:
| EntityLinker
| spacy.pipeline.trainable_pipe.TrainablePipe
| spacy.pipeline.pipe.Pipe
| builtins.object
|
| Methods defined here:
|
| __init__(self, vocab: spacy.vocab.Vocab, model: thinc.model.Model, name: str = 'entity_linker', *, labels_discard: Iterable[str], n_sents: int, incl_prior: bool, incl_context: bool, entity_vector_length: int, get_candidates: Callable[[spacy.kb.kb.KnowledgeBase, spacy.tokens.span.Span], Iterable[spacy.kb.candidate.Candidate]], get_candidates_batch: Callable[[spacy.kb.kb.KnowledgeBase, Iterable[spacy.tokens.span.Span]], Iterable[Iterable[spacy.kb.candidate.Candidate]]], generate_empty_kb: Callable[[spacy.vocab.Vocab, int], spacy.kb.kb.KnowledgeBase], overwrite: bool = True, scorer: Optional[Callable] = <function entity_linker_score at 0x0000022154BA8180>, use_gold_ents: bool, candidates_batch_size: int, threshold: Optional[float] = None) -> None
| Initialize an entity linker.
|
| vocab (Vocab): The shared vocabulary.
| model (thinc.api.Model): The Thinc Model powering the pipeline component.
| name (str): The component instance name, used to add entries to the
| losses during training.
| labels_discard (Iterable[str]): NER labels that will automatically get a "NIL" prediction.
| n_sents (int): The number of neighbouring sentences to take into account.
| incl_prior (bool): Whether or not to include prior probabilities from the KB in the model.
| incl_context (bool): Whether or not to include the local context in the model.
| entity_vector_length (int): Size of encoding vectors in the KB.
| get_candidates (Callable[[KnowledgeBase, Span], Iterable[Candidate]]): Function that
| produces a list of candidates, given a certain knowledge base and a textual mention.
| get_candidates_batch (
| Callable[[KnowledgeBase, Iterable[Span]], Iterable[Iterable[Candidate]]],
| Iterable[Candidate]]
| ): Function that produces a list of candidates, given a certain knowledge base and several textual mentions.
| generate_empty_kb (Callable[[Vocab, int], KnowledgeBase]): Callable returning empty KnowledgeBase.
| scorer (Optional[Callable]): The scoring method. Defaults to Scorer.score_links.
| use_gold_ents (bool): Whether to copy entities from gold docs or not. If false, another
| component must provide entity annotations.
| candidates_batch_size (int): Size of batches for entity candidate generation.
| threshold (Optional[float]): Confidence threshold for entity predictions. If confidence is below the
| threshold, prediction is discarded. If None, predictions are not filtered by any threshold.
| DOCS: https://spacy.io/api/entitylinker#init
|
| add_label(self, label)
| TrainablePipe.add_label(self, label: str) -> int
|
| Add an output label.
| For TrainablePipe components, it is possible to
| extend pretrained models with new labels, but care should be taken to
| avoid the "catastrophic forgetting" problem.
|
| label (str): The label to add.
| RETURNS (int): 0 if label is already present, otherwise 1.
|
| DOCS: https://spacy.io/api/pipe#add_label
|
| batch_has_learnable_example(self, examples)
| Check if a batch contains a learnable example.
|
| If one isn't present, then the update step needs to be skipped.
|
| from_bytes(self, bytes_data, *, exclude=())
| Load the pipe from a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (TrainablePipe): The loaded object.
|
| DOCS: https://spacy.io/api/entitylinker#from_bytes
|
| from_disk(self, path: Union[str, pathlib.Path], *, exclude: Iterable[str] = []) -> 'EntityLinker'
| Load the pipe from disk. Modifies the object in place and returns it.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (EntityLinker): The modified EntityLinker object.
|
| DOCS: https://spacy.io/api/entitylinker#from_disk
|
| get_loss(self, examples: Iterable[spacy.training.example.Example], sentence_encodings: thinc.types.Floats2d)
| TrainablePipe.get_loss(self, examples: Iterable[Example], scores) -> Tuple[float, float]
|
| Find the loss and gradient of loss for the batch of documents and
| their predicted scores.
|
| examples (Iterable[Examples]): The batch of examples.
| scores: Scores representing the model's predictions.
| RETURNS (Tuple[float, float]): The loss and the gradient.
|
| DOCS: https://spacy.io/api/pipe#get_loss
|
| initialize(self, get_examples: Callable[[], Iterable[spacy.training.example.Example]], *, nlp: Optional[spacy.language.Language] = None, kb_loader: Optional[Callable[[spacy.vocab.Vocab], spacy.kb.kb.KnowledgeBase]] = None)
| Initialize the pipe for training, using a representative set
| of data examples.
|
| get_examples (Callable[[], Iterable[Example]]): Function that
| returns a representative sample of gold-standard Example objects.
| nlp (Language): The current nlp object the component is part of.
| kb_loader (Callable[[Vocab], KnowledgeBase]): A function that creates a KnowledgeBase from a Vocab
| instance. Note that providing this argument will overwrite all data accumulated in the current KB.
| Use this only when loading a KB as-such from file.
|
| DOCS: https://spacy.io/api/entitylinker#initialize
|
| predict(self, docs: Iterable[spacy.tokens.doc.Doc]) -> List[str]
| Apply the pipeline's model to a batch of docs, without modifying them.
| Returns the KB IDs for each entity in each doc, including NIL if there is
| no prediction.
|
| docs (Iterable[Doc]): The documents to predict.
| RETURNS (List[str]): The models prediction for each document.
|
| DOCS: https://spacy.io/api/entitylinker#predict
|
| rehearse(self, examples, *, sgd=None, losses=None, **config)
| TrainablePipe.rehearse(self, examples: Iterable[Example], *, sgd: Optimizer = None, losses: Dict[str, float] = None, **config) -> Dict[str, float]
|
| Perform a "rehearsal" update from a batch of data. Rehearsal updates
| teach the current model to make predictions similar to an initial model,
| to try to address the "catastrophic forgetting" problem. This feature is
| experimental.
|
| examples (Iterable[Example]): A batch of Example objects.
| sgd (thinc.api.Optimizer): The optimizer.
| losses (Dict[str, float]): Optional record of the loss during training.
| Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/pipe#rehearse
|
| set_annotations(self, docs: Iterable[spacy.tokens.doc.Doc], kb_ids: List[str]) -> None
| Modify a batch of documents, using pre-computed scores.
|
| docs (Iterable[Doc]): The documents to modify.
| kb_ids (List[str]): The IDs to set, produced by EntityLinker.predict.
|
| DOCS: https://spacy.io/api/entitylinker#set_annotations
|
| set_kb(self, kb_loader: Callable[[spacy.vocab.Vocab], spacy.kb.kb.KnowledgeBase])
| Define the KB of this pipe by providing a function that will
| create it using this object's vocab.
|
| to_bytes(self, *, exclude=())
| Serialize the pipe to a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (bytes): The serialized object.
|
| DOCS: https://spacy.io/api/entitylinker#to_bytes
|
| to_disk(self, path: Union[str, pathlib.Path], *, exclude: Iterable[str] = []) -> None
| Serialize the pipe to disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
|
| DOCS: https://spacy.io/api/entitylinker#to_disk
|
| update(self, examples: Iterable[spacy.training.example.Example], *, drop: float = 0.0, sgd: Optional[thinc.optimizers.Optimizer] = None, losses: Optional[Dict[str, float]] = None) -> Dict[str, float]
| Learn from a batch of documents and gold-standard information,
| updating the pipe's model. Delegates to predict and get_loss.
|
| examples (Iterable[Example]): A batch of Example objects.
| drop (float): The dropout rate.
| sgd (thinc.api.Optimizer): The optimizer.
| losses (Dict[str, float]): Optional record of the loss during training.
| Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/entitylinker#update
|
| validate_kb(self) -> None
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| NIL = 'NIL'
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __call__(...)
| TrainablePipe.__call__(self, Doc doc) -> Doc
|
| Apply the pipe to one document. The document is modified in place,
| and returned. This usually happens under the hood when the nlp object
| is called on a text and all components are applied to the Doc.
|
| docs (Doc): The Doc to process.
| RETURNS (Doc): The processed Doc.
|
| DOCS: https://spacy.io/api/pipe#call
|
| __reduce__ = __reduce_cython__(...)
| TrainablePipe.__reduce_cython__(self)
|
| __reduce_cython__(self)
| TrainablePipe.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| create_optimizer(self) -> 'Optimizer'
| TrainablePipe.create_optimizer(self) -> Optimizer
|
| Create an optimizer for the pipeline component.
|
| RETURNS (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#create_optimizer
|
| finish_update(self, sgd: 'Optimizer') -> 'None'
| TrainablePipe.finish_update(self, sgd: Optimizer) -> None
|
| Update parameters using the current parameter gradients.
| The Optimizer instance contains the functionality to perform
| the stochastic gradient descent.
|
| sgd (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#finish_update
|
| pipe(self, stream: 'Iterable[Doc]', *, batch_size: 'int' = 128) -> 'Iterator[Doc]'
| TrainablePipe.pipe(self, stream: Iterable[Doc], *, batch_size: int = 128) -> Iterator[Doc]
|
| Apply the pipe to a stream of documents. This usually happens under
| the hood when the nlp object is called on a text and all components are
| applied to the Doc.
|
| stream (Iterable[Doc]): A stream of documents.
| batch_size (int): The number of documents to buffer.
| error_handler (Callable[[str, List[Doc], Exception], Any]): Function that
| deals with a failing batch of documents. The default function just reraises
| the exception.
| YIELDS (Doc): Processed documents in order.
|
| DOCS: https://spacy.io/api/pipe#pipe
|
| set_output(self, nO: 'int') -> 'None'
| TrainablePipe.set_output(self, nO: int) -> None
|
| use_params(self, params: 'dict')
| TrainablePipe.use_params(self, params: dict)
|
| Modify the pipe's model, to use the given parameter values. At the
| end of the context, the original parameters are restored.
|
| params (dict): The parameter values to use in the model.
|
| DOCS: https://spacy.io/api/pipe#use_params
|
| ----------------------------------------------------------------------
| Static methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __new__(*args, **kwargs) class method of spacy.pipeline.trainable_pipe.TrainablePipe
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| cfg
| cfg: object
|
| is_resizable
| TrainablePipe.is_resizable: bool
|
| is_trainable
| TrainablePipe.is_trainable: bool
|
| model
| model: object
|
| scorer
| scorer: object
|
| vocab
| vocab: spacy.vocab.Vocab
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.pipe.Pipe:
|
| get_error_handler(self) -> 'Callable'
| Pipe.get_error_handler(self) -> Callable
|
| Retrieve the error handler function.
|
| RETURNS (Callable): The error handler, or if it's not set a default function that just reraises.
|
| DOCS: https://spacy.io/api/pipe#get_error_handler
|
| score(self, examples: 'Iterable[Example]', **kwargs) -> 'Dict[str, Union[float, Dict[str, float]]]'
| Pipe.score(self, examples: Iterable[Example], **kwargs) -> Dict[str, Union[float, Dict[str, float]]]
|
| Score a batch of examples.
|
| examples (Iterable[Example]): The examples to score.
| RETURNS (Dict[str, Any]): The scores.
|
| DOCS: https://spacy.io/api/pipe#score
|
| set_error_handler(self, error_handler: 'Callable') -> 'None'
| Pipe.set_error_handler(self, error_handler: Callable) -> None
|
| Set an error handler function.
|
| error_handler (Callable[[str, Callable[[Doc], Doc], List[Doc], Exception], None]):
| Function that deals with a failing batch of documents. This callable function should take in
| the component's name, the component itself, the offending batch of documents, and the exception
| that was thrown.
|
| DOCS: https://spacy.io/api/pipe#set_error_handler
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.pipe.Pipe:
|
| hide_labels
| Pipe.hide_labels: bool
|
| label_data
| Optional JSON-serializable data that would be sufficient to recreate
| the label set if provided to the `pipe.initialize()` method.
|
| labels
| Pipe.labels: Tuple[str, ...]
|
| name
| name: str
class EntityRecognizer(spacy.pipeline.transition_parser.Parser)
| EntityRecognizer(vocab, model, name='ner', moves=None, update_with_oracle_cut_size=100, *, beam_width=1, beam_density=0.0, beam_update_prob=0.0, multitasks=tuple(), incorrect_spans_key=None, scorer=ner_score)
|
| Pipeline component for named entity recognition.
|
| DOCS: https://spacy.io/api/entityrecognizer
|
| Method resolution order:
| EntityRecognizer
| spacy.pipeline.transition_parser.Parser
| spacy.pipeline.trainable_pipe.TrainablePipe
| spacy.pipeline.pipe.Pipe
| builtins.object
|
| Methods defined here:
|
| __init__(...)
| Create an EntityRecognizer.
|
| __reduce__ = __reduce_cython__(...)
| EntityRecognizer.__reduce_cython__(self)
|
| __reduce_cython__(self)
| EntityRecognizer.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| EntityRecognizer.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| EntityRecognizer.__setstate_cython__(self, __pyx_state)
|
| add_multitask_objective(self, mt_component)
| EntityRecognizer.add_multitask_objective(self, mt_component)
|
| Register another component as a multi-task objective. Experimental.
|
| init_multitask_objectives(self, get_examples, nlp=None, **cfg)
| EntityRecognizer.init_multitask_objectives(self, get_examples, nlp=None, **cfg)
|
| Setup multi-task objective components. Experimental and internal.
|
| scored_ents(self, beams)
| EntityRecognizer.scored_ents(self, beams)
|
| Return a dictionary of (start, end, label) tuples with corresponding scores
| for each beam/doc that was processed.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| labels
| Pipe.labels: Tuple[str, ...]
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| TransitionSystem = <class 'spacy.pipeline._parser_internals.ner.BiluoP...
| BiluoPushDown(*args, **kwargs)
|
|
| __pyx_vtable__ = <capsule object NULL>
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.transition_parser.Parser:
|
| __getnewargs_ex__(self)
| Parser.__getnewargs_ex__(self)
|
| This allows pickling the Parser and its keyword-only init arguments
|
| add_label(self, label)
| Parser.add_label(self, label)
|
| beam_parse(self, docs, beam_width, drop=0.0, beam_density=0.0)
| Parser.beam_parse(self, docs, int beam_width, float drop=0., beam_density=0.)
|
| from_bytes(self, bytes_data, exclude=())
| Parser.from_bytes(self, bytes_data, exclude=tuple())
|
| from_disk(self, path, exclude=())
| Parser.from_disk(self, path, exclude=tuple())
|
| get_batch_loss(self, states, golds, scores, losses)
| Parser.get_batch_loss(self, states, golds, float[:, ::1] scores, losses)
|
| greedy_parse(self, docs, drop=0.0)
| Parser.greedy_parse(self, docs, drop=0.)
|
| initialize(self, get_examples, nlp=None, labels=None)
| Parser.initialize(self, get_examples, nlp=None, labels=None)
|
| pipe(self, docs, *, batch_size=256)
| Parser.pipe(self, docs, *, int batch_size=256)
|
| Process a stream of documents.
|
| stream: The sequence of documents to process.
| batch_size (int): Number of documents to accumulate into a working set.
| error_handler (Callable[[str, List[Doc], Exception], Any]): Function that
| deals with a failing batch of documents. The default function just reraises
| the exception.
|
| YIELDS (Doc): Documents, in order.
|
| predict(self, docs)
| Parser.predict(self, docs)
|
| rehearse(self, examples, sgd=None, losses=None, **cfg)
| Parser.rehearse(self, examples, sgd=None, losses=None, **cfg)
|
| Perform a "rehearsal" update, to prevent catastrophic forgetting.
|
| set_annotations(self, docs, states_or_beams)
| Parser.set_annotations(self, docs, states_or_beams)
|
| set_output(self, nO)
| Parser.set_output(self, nO)
|
| to_bytes(self, exclude=())
| Parser.to_bytes(self, exclude=tuple())
|
| to_disk(self, path, exclude=())
| Parser.to_disk(self, path, exclude=tuple())
|
| transition_states(self, states, scores)
| Parser.transition_states(self, states, float[:, ::1] scores)
|
| update(self, examples, *, drop=0.0, sgd=None, losses=None)
| Parser.update(self, examples, *, drop=0., sgd=None, losses=None)
|
| update_beam(self, examples, *, beam_width, drop=0.0, sgd=None, losses=None, beam_density=0.0)
| Parser.update_beam(self, examples, *, beam_width, drop=0., sgd=None, losses=None, beam_density=0.0)
|
| use_params(self, params)
| Parser.use_params(self, params)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.transition_parser.Parser:
|
| incorrect_spans_key
|
| label_data
| Optional JSON-serializable data that would be sufficient to recreate
| the label set if provided to the `pipe.initialize()` method.
|
| move_names
|
| moves
|
| postprocesses
|
| tok2vec
| Return the embedding and convolutional layer of the model.
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __call__(...)
| TrainablePipe.__call__(self, Doc doc) -> Doc
|
| Apply the pipe to one document. The document is modified in place,
| and returned. This usually happens under the hood when the nlp object
| is called on a text and all components are applied to the Doc.
|
| docs (Doc): The Doc to process.
| RETURNS (Doc): The processed Doc.
|
| DOCS: https://spacy.io/api/pipe#call
|
| create_optimizer(self) -> 'Optimizer'
| TrainablePipe.create_optimizer(self) -> Optimizer
|
| Create an optimizer for the pipeline component.
|
| RETURNS (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#create_optimizer
|
| finish_update(self, sgd: 'Optimizer') -> 'None'
| TrainablePipe.finish_update(self, sgd: Optimizer) -> None
|
| Update parameters using the current parameter gradients.
| The Optimizer instance contains the functionality to perform
| the stochastic gradient descent.
|
| sgd (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#finish_update
|
| get_loss(self, examples: 'Iterable[Example]', scores) -> 'Tuple[float, float]'
| TrainablePipe.get_loss(self, examples: Iterable[Example], scores) -> Tuple[float, float]
|
| Find the loss and gradient of loss for the batch of documents and
| their predicted scores.
|
| examples (Iterable[Examples]): The batch of examples.
| scores: Scores representing the model's predictions.
| RETURNS (Tuple[float, float]): The loss and the gradient.
|
| DOCS: https://spacy.io/api/pipe#get_loss
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| cfg
| cfg: object
|
| is_resizable
| TrainablePipe.is_resizable: bool
|
| is_trainable
| TrainablePipe.is_trainable: bool
|
| model
| model: object
|
| scorer
| scorer: object
|
| vocab
| vocab: spacy.vocab.Vocab
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.pipe.Pipe:
|
| get_error_handler(self) -> 'Callable'
| Pipe.get_error_handler(self) -> Callable
|
| Retrieve the error handler function.
|
| RETURNS (Callable): The error handler, or if it's not set a default function that just reraises.
|
| DOCS: https://spacy.io/api/pipe#get_error_handler
|
| score(self, examples: 'Iterable[Example]', **kwargs) -> 'Dict[str, Union[float, Dict[str, float]]]'
| Pipe.score(self, examples: Iterable[Example], **kwargs) -> Dict[str, Union[float, Dict[str, float]]]
|
| Score a batch of examples.
|
| examples (Iterable[Example]): The examples to score.
| RETURNS (Dict[str, Any]): The scores.
|
| DOCS: https://spacy.io/api/pipe#score
|
| set_error_handler(self, error_handler: 'Callable') -> 'None'
| Pipe.set_error_handler(self, error_handler: Callable) -> None
|
| Set an error handler function.
|
| error_handler (Callable[[str, Callable[[Doc], Doc], List[Doc], Exception], None]):
| Function that deals with a failing batch of documents. This callable function should take in
| the component's name, the component itself, the offending batch of documents, and the exception
| that was thrown.
|
| DOCS: https://spacy.io/api/pipe#set_error_handler
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.pipe.Pipe:
|
| hide_labels
| Pipe.hide_labels: bool
|
| name
| name: str
class EntityRuler(spacy.pipeline.pipe.Pipe)
| EntityRuler(nlp: spacy.language.Language, name: str = 'entity_ruler', *, phrase_matcher_attr: Union[str, int, NoneType] = None, matcher_fuzzy_compare: Callable = <cyfunction levenshtein_compare at 0x0000022154907380>, validate: bool = False, overwrite_ents: bool = False, ent_id_sep: str = '||', patterns: Optional[List[Dict[str, Union[str, List[Dict[str, Any]]]]]] = None, scorer: Optional[Callable] = <function entity_ruler_score at 0x0000022154BA8F40>) -> None
|
| The EntityRuler lets you add spans to the `Doc.ents` using token-based
| rules or exact phrase matches. It can be combined with the statistical
| `EntityRecognizer` to boost accuracy, or used on its own to implement a
| purely rule-based entity recognition system. After initialization, the
| component is typically added to the pipeline using `nlp.add_pipe`.
|
| DOCS: https://spacy.io/api/entityruler
| USAGE: https://spacy.io/usage/rule-based-matching#entityruler
|
| Method resolution order:
| EntityRuler
| spacy.pipeline.pipe.Pipe
| builtins.object
|
| Methods defined here:
|
| __call__(self, doc: spacy.tokens.doc.Doc) -> spacy.tokens.doc.Doc
| Find matches in document and add them as entities.
|
| doc (Doc): The Doc object in the pipeline.
| RETURNS (Doc): The Doc with added entities, if available.
|
| DOCS: https://spacy.io/api/entityruler#call
|
| __contains__(self, label: str) -> bool
| Whether a label is present in the patterns.
|
| __init__(self, nlp: spacy.language.Language, name: str = 'entity_ruler', *, phrase_matcher_attr: Union[str, int, NoneType] = None, matcher_fuzzy_compare: Callable = <cyfunction levenshtein_compare at 0x0000022154907380>, validate: bool = False, overwrite_ents: bool = False, ent_id_sep: str = '||', patterns: Optional[List[Dict[str, Union[str, List[Dict[str, Any]]]]]] = None, scorer: Optional[Callable] = <function entity_ruler_score at 0x0000022154BA8F40>) -> None
| Initialize the entity ruler. If patterns are supplied here, they
| need to be a list of dictionaries with a `"label"` and `"pattern"`
| key. A pattern can either be a token pattern (list) or a phrase pattern
| (string). For example: `{'label': 'ORG', 'pattern': 'Apple'}`.
|
| nlp (Language): The shared nlp object to pass the vocab to the matchers
| and process phrase patterns.
| name (str): Instance name of the current pipeline component. Typically
| passed in automatically from the factory when the component is
| added. Used to disable the current entity ruler while creating
| phrase patterns with the nlp object.
| phrase_matcher_attr (int / str): Token attribute to match on, passed
| to the internal PhraseMatcher as `attr`.
| matcher_fuzzy_compare (Callable): The fuzzy comparison method for the
| internal Matcher. Defaults to
| spacy.matcher.levenshtein.levenshtein_compare.
| validate (bool): Whether patterns should be validated, passed to
| Matcher and PhraseMatcher as `validate`
| patterns (iterable): Optional patterns to load in.
| overwrite_ents (bool): If existing entities are present, e.g. entities
| added by the model, overwrite them by matches if necessary.
| ent_id_sep (str): Separator used internally for entity IDs.
| scorer (Optional[Callable]): The scoring method. Defaults to
| spacy.scorer.get_ner_prf.
|
| DOCS: https://spacy.io/api/entityruler#init
|
| __len__(self) -> int
| The number of all patterns added to the entity ruler.
|
| add_patterns(self, patterns: List[Dict[str, Union[str, List[Dict[str, Any]]]]]) -> None
| Add patterns to the entity ruler. A pattern can either be a token
| pattern (list of dicts) or a phrase pattern (string). For example:
| {'label': 'ORG', 'pattern': 'Apple'}
| {'label': 'GPE', 'pattern': [{'lower': 'san'}, {'lower': 'francisco'}]}
|
| patterns (list): The patterns to add.
|
| DOCS: https://spacy.io/api/entityruler#add_patterns
|
| clear(self) -> None
| Reset all patterns.
|
| from_bytes(self, patterns_bytes: bytes, *, exclude: Iterable[str] = []) -> 'EntityRuler'
| Load the entity ruler from a bytestring.
|
| patterns_bytes (bytes): The bytestring to load.
| RETURNS (EntityRuler): The loaded entity ruler.
|
| DOCS: https://spacy.io/api/entityruler#from_bytes
|
| from_disk(self, path: Union[str, pathlib.Path], *, exclude: Iterable[str] = []) -> 'EntityRuler'
| Load the entity ruler from a file. Expects a file containing
| newline-delimited JSON (JSONL) with one entry per line.
|
| path (str / Path): The JSONL file to load.
| RETURNS (EntityRuler): The loaded entity ruler.
|
| DOCS: https://spacy.io/api/entityruler#from_disk
|
| initialize(self, get_examples: Callable[[], Iterable[spacy.training.example.Example]], *, nlp: Optional[spacy.language.Language] = None, patterns: Optional[Sequence[Dict[str, Union[str, List[Dict[str, Any]]]]]] = None)
| Initialize the pipe for training.
|
| get_examples (Callable[[], Iterable[Example]]): Function that
| returns a representative sample of gold-standard Example objects.
| nlp (Language): The current nlp object the component is part of.
| patterns Optional[Iterable[PatternType]]: The list of patterns.
|
| DOCS: https://spacy.io/api/entityruler#initialize
|
| match(self, doc: spacy.tokens.doc.Doc)
|
| remove(self, ent_id: str) -> None
| Remove a pattern by its ent_id if a pattern with this ent_id was added before
|
| ent_id (str): id of the pattern to be removed
| RETURNS: None
| DOCS: https://spacy.io/api/entityruler#remove
|
| set_annotations(self, doc, matches)
| Modify the document in place
|
| to_bytes(self, *, exclude: Iterable[str] = []) -> bytes
| Serialize the entity ruler patterns to a bytestring.
|
| RETURNS (bytes): The serialized patterns.
|
| DOCS: https://spacy.io/api/entityruler#to_bytes
|
| to_disk(self, path: Union[str, pathlib.Path], *, exclude: Iterable[str] = []) -> None
| Save the entity ruler patterns to a directory. The patterns will be
| saved as newline-delimited JSON (JSONL).
|
| path (str / Path): The JSONL file to save.
|
| DOCS: https://spacy.io/api/entityruler#to_disk
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| ent_ids
| All entity ids present in the match patterns `id` properties
|
| RETURNS (set): The string entity ids.
|
| DOCS: https://spacy.io/api/entityruler#ent_ids
|
| labels
| All labels present in the match patterns.
|
| RETURNS (set): The string labels.
|
| DOCS: https://spacy.io/api/entityruler#labels
|
| patterns
| Get all patterns that were added to the entity ruler.
|
| RETURNS (list): The original patterns, one dictionary per pattern.
|
| DOCS: https://spacy.io/api/entityruler#patterns
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.pipe.Pipe:
|
| __reduce__ = __reduce_cython__(...)
| Pipe.__reduce_cython__(self)
|
| __reduce_cython__(self)
| Pipe.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| Pipe.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| Pipe.__setstate_cython__(self, __pyx_state)
|
| get_error_handler(self) -> 'Callable'
| Pipe.get_error_handler(self) -> Callable
|
| Retrieve the error handler function.
|
| RETURNS (Callable): The error handler, or if it's not set a default function that just reraises.
|
| DOCS: https://spacy.io/api/pipe#get_error_handler
|
| pipe(self, stream: 'Iterable[Doc]', *, batch_size: 'int' = 128) -> 'Iterator[Doc]'
| Pipe.pipe(self, stream: Iterable[Doc], *, batch_size: int = 128) -> Iterator[Doc]
|
| Apply the pipe to a stream of documents. This usually happens under
| the hood when the nlp object is called on a text and all components are
| applied to the Doc.
|
| stream (Iterable[Doc]): A stream of documents.
| batch_size (int): The number of documents to buffer.
| YIELDS (Doc): Processed documents in order.
|
| DOCS: https://spacy.io/api/pipe#pipe
|
| score(self, examples: 'Iterable[Example]', **kwargs) -> 'Dict[str, Union[float, Dict[str, float]]]'
| Pipe.score(self, examples: Iterable[Example], **kwargs) -> Dict[str, Union[float, Dict[str, float]]]
|
| Score a batch of examples.
|
| examples (Iterable[Example]): The examples to score.
| RETURNS (Dict[str, Any]): The scores.
|
| DOCS: https://spacy.io/api/pipe#score
|
| set_error_handler(self, error_handler: 'Callable') -> 'None'
| Pipe.set_error_handler(self, error_handler: Callable) -> None
|
| Set an error handler function.
|
| error_handler (Callable[[str, Callable[[Doc], Doc], List[Doc], Exception], None]):
| Function that deals with a failing batch of documents. This callable function should take in
| the component's name, the component itself, the offending batch of documents, and the exception
| that was thrown.
|
| DOCS: https://spacy.io/api/pipe#set_error_handler
|
| ----------------------------------------------------------------------
| Static methods inherited from spacy.pipeline.pipe.Pipe:
|
| __new__(*args, **kwargs) class method of spacy.pipeline.pipe.Pipe
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.pipe.Pipe:
|
| hide_labels
| Pipe.hide_labels: bool
|
| is_trainable
| Pipe.is_trainable: bool
|
| label_data
| Optional JSON-serializable data that would be sufficient to recreate
| the label set if provided to the `pipe.initialize()` method.
|
| name
| name: str
class Lemmatizer(spacy.pipeline.pipe.Pipe)
| Lemmatizer(vocab: spacy.vocab.Vocab, model: Optional[thinc.model.Model], name: str = 'lemmatizer', *, mode: str = 'lookup', overwrite: bool = False, scorer: Optional[Callable] = <function lemmatizer_score at 0x0000022154B69EE0>) -> None
|
| The Lemmatizer supports simple part-of-speech-sensitive suffix rules and
| lookup tables.
|
| DOCS: https://spacy.io/api/lemmatizer
|
| Method resolution order:
| Lemmatizer
| spacy.pipeline.pipe.Pipe
| builtins.object
|
| Methods defined here:
|
| __call__(self, doc: spacy.tokens.doc.Doc) -> spacy.tokens.doc.Doc
| Apply the lemmatizer to one document.
|
| doc (Doc): The Doc to process.
| RETURNS (Doc): The processed Doc.
|
| DOCS: https://spacy.io/api/lemmatizer#call
|
| __init__(self, vocab: spacy.vocab.Vocab, model: Optional[thinc.model.Model], name: str = 'lemmatizer', *, mode: str = 'lookup', overwrite: bool = False, scorer: Optional[Callable] = <function lemmatizer_score at 0x0000022154B69EE0>) -> None
| Initialize a Lemmatizer.
|
| vocab (Vocab): The vocab.
| model (Model): A model (not yet implemented).
| name (str): The component name. Defaults to "lemmatizer".
| mode (str): The lemmatizer mode: "lookup", "rule". Defaults to "lookup".
| overwrite (bool): Whether to overwrite existing lemmas. Defaults to
| `False`.
| scorer (Optional[Callable]): The scoring method. Defaults to
| Scorer.score_token_attr for the attribute "lemma".
|
| DOCS: https://spacy.io/api/lemmatizer#init
|
| from_bytes(self, bytes_data: bytes, *, exclude: Iterable[str] = []) -> 'Lemmatizer'
| Load the pipe from a bytestring.
|
| bytes_data (bytes): The serialized pipe.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (Lemmatizer): The loaded Lemmatizer.
|
| DOCS: https://spacy.io/api/lemmatizer#from_bytes
|
| from_disk(self, path: Union[str, pathlib.Path], *, exclude: Iterable[str] = []) -> 'Lemmatizer'
| Load the pipe from disk. Modifies the object in place and returns it.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (Lemmatizer): The modified Lemmatizer object.
|
| DOCS: https://spacy.io/api/lemmatizer#from_disk
|
| initialize(self, get_examples: Optional[Callable[[], Iterable[spacy.training.example.Example]]] = None, *, nlp: Optional[spacy.language.Language] = None, lookups: Optional[spacy.lookups.Lookups] = None)
| Initialize the lemmatizer and load in data.
|
| get_examples (Callable[[], Iterable[Example]]): Function that
| returns a representative sample of gold-standard Example objects.
| nlp (Language): The current nlp object the component is part of.
| lookups (Lookups): The lookups object containing the (optional) tables
| such as "lemma_rules", "lemma_index", "lemma_exc" and
| "lemma_lookup". Defaults to None.
|
| is_base_form(self, token: spacy.tokens.token.Token) -> bool
| Check whether the token is a base form that does not need further
| analysis for lemmatization.
|
| token (Token): The token.
| RETURNS (bool): Whether the token is a base form.
|
| DOCS: https://spacy.io/api/lemmatizer#is_base_form
|
| lookup_lemmatize(self, token: spacy.tokens.token.Token) -> List[str]
| Lemmatize using a lookup-based approach.
|
| token (Token): The token to lemmatize.
| RETURNS (list): The available lemmas for the string.
|
| DOCS: https://spacy.io/api/lemmatizer#lookup_lemmatize
|
| rule_lemmatize(self, token: spacy.tokens.token.Token) -> List[str]
| Lemmatize using a rule-based approach.
|
| token (Token): The token to lemmatize.
| RETURNS (list): The available lemmas for the string.
|
| DOCS: https://spacy.io/api/lemmatizer#rule_lemmatize
|
| to_bytes(self, *, exclude: Iterable[str] = []) -> bytes
| Serialize the pipe to a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (bytes): The serialized object.
|
| DOCS: https://spacy.io/api/lemmatizer#to_bytes
|
| to_disk(self, path: Union[str, pathlib.Path], *, exclude: Iterable[str] = [])
| Serialize the pipe to disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
|
| DOCS: https://spacy.io/api/lemmatizer#to_disk
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| get_lookups_config(mode: str) -> Tuple[List[str], List[str]]
| Returns the lookups configuration settings for a given mode for use
| in Lemmatizer.load_lookups.
|
| mode (str): The lemmatizer mode.
| RETURNS (Tuple[List[str], List[str]]): The required and optional
| lookup tables for this mode.
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| mode
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.pipe.Pipe:
|
| __reduce__ = __reduce_cython__(...)
| Pipe.__reduce_cython__(self)
|
| __reduce_cython__(self)
| Pipe.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| Pipe.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| Pipe.__setstate_cython__(self, __pyx_state)
|
| get_error_handler(self) -> 'Callable'
| Pipe.get_error_handler(self) -> Callable
|
| Retrieve the error handler function.
|
| RETURNS (Callable): The error handler, or if it's not set a default function that just reraises.
|
| DOCS: https://spacy.io/api/pipe#get_error_handler
|
| pipe(self, stream: 'Iterable[Doc]', *, batch_size: 'int' = 128) -> 'Iterator[Doc]'
| Pipe.pipe(self, stream: Iterable[Doc], *, batch_size: int = 128) -> Iterator[Doc]
|
| Apply the pipe to a stream of documents. This usually happens under
| the hood when the nlp object is called on a text and all components are
| applied to the Doc.
|
| stream (Iterable[Doc]): A stream of documents.
| batch_size (int): The number of documents to buffer.
| YIELDS (Doc): Processed documents in order.
|
| DOCS: https://spacy.io/api/pipe#pipe
|
| score(self, examples: 'Iterable[Example]', **kwargs) -> 'Dict[str, Union[float, Dict[str, float]]]'
| Pipe.score(self, examples: Iterable[Example], **kwargs) -> Dict[str, Union[float, Dict[str, float]]]
|
| Score a batch of examples.
|
| examples (Iterable[Example]): The examples to score.
| RETURNS (Dict[str, Any]): The scores.
|
| DOCS: https://spacy.io/api/pipe#score
|
| set_error_handler(self, error_handler: 'Callable') -> 'None'
| Pipe.set_error_handler(self, error_handler: Callable) -> None
|
| Set an error handler function.
|
| error_handler (Callable[[str, Callable[[Doc], Doc], List[Doc], Exception], None]):
| Function that deals with a failing batch of documents. This callable function should take in
| the component's name, the component itself, the offending batch of documents, and the exception
| that was thrown.
|
| DOCS: https://spacy.io/api/pipe#set_error_handler
|
| ----------------------------------------------------------------------
| Static methods inherited from spacy.pipeline.pipe.Pipe:
|
| __new__(*args, **kwargs) class method of spacy.pipeline.pipe.Pipe
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.pipe.Pipe:
|
| hide_labels
| Pipe.hide_labels: bool
|
| is_trainable
| Pipe.is_trainable: bool
|
| label_data
| Optional JSON-serializable data that would be sufficient to recreate
| the label set if provided to the `pipe.initialize()` method.
|
| labels
| Pipe.labels: Tuple[str, ...]
|
| name
| name: str
class Morphologizer(spacy.pipeline.tagger.Tagger)
| Morphologizer(vocab: 'Vocab', model: 'Model', name: 'str' = 'morphologizer', *, overwrite: 'bool' = True, extend: 'bool' = False, label_smoothing: 'float' = 0.0, scorer: 'Optional[Callable]' = <cyfunction morphologizer_score at 0x0000022154BC8940>)
|
| Method resolution order:
| Morphologizer
| spacy.pipeline.tagger.Tagger
| spacy.pipeline.trainable_pipe.TrainablePipe
| spacy.pipeline.pipe.Pipe
| builtins.object
|
| Methods defined here:
|
| __init__(self, vocab: 'Vocab', model: 'Model', name: 'str' = 'morphologizer', *, overwrite: 'bool' = True, extend: 'bool' = False, label_smoothing: 'float' = 0.0, scorer: 'Optional[Callable]' = <cyfunction morphologizer_score at 0x0000022154BC8940>)
| Morphologizer.__init__(self, vocab: Vocab, model: Model, name: str = 'morphologizer', *, overwrite: bool = BACKWARD_OVERWRITE, extend: bool = BACKWARD_EXTEND, label_smoothing: float = 0.0, scorer: Optional[Callable] = morphologizer_score)
|
| Initialize a morphologizer.
|
| vocab (Vocab): The shared vocabulary.
| model (thinc.api.Model): The Thinc Model powering the pipeline component.
| name (str): The component instance name, used to add entries to the
| losses during training.
| scorer (Optional[Callable]): The scoring method. Defaults to
| Scorer.score_token_attr for the attributes "pos" and "morph" and
| Scorer.score_token_attr_per_feat for the attribute "morph".
|
| DOCS: https://spacy.io/api/morphologizer#init
|
| add_label(self, label)
| Morphologizer.add_label(self, label)
|
| Add a new label to the pipe.
|
| label (str): The label to add.
| RETURNS (int): 0 if label is already present, otherwise 1.
|
| DOCS: https://spacy.io/api/morphologizer#add_label
|
| get_loss(self, examples, scores)
| Morphologizer.get_loss(self, examples, scores)
|
| Find the loss and gradient of loss for the batch of documents and
| their predicted scores.
|
| examples (Iterable[Examples]): The batch of examples.
| scores: Scores representing the model's predictions.
| RETURNS (Tuple[float, float]): The loss and the gradient.
|
| DOCS: https://spacy.io/api/morphologizer#get_loss
|
| initialize(self, get_examples, *, nlp=None, labels=None)
| Morphologizer.initialize(self, get_examples, *, nlp=None, labels=None)
|
| Initialize the pipe for training, using a representative set
| of data examples.
|
| get_examples (Callable[[], Iterable[Example]]): Function that
| returns a representative sample of gold-standard Example objects.
| nlp (Language): The current nlp object the component is part of.
|
| DOCS: https://spacy.io/api/morphologizer#initialize
|
| set_annotations(self, docs, batch_tag_ids)
| Morphologizer.set_annotations(self, docs, batch_tag_ids)
|
| Modify a batch of documents, using pre-computed scores.
|
| docs (Iterable[Doc]): The documents to modify.
| batch_tag_ids: The IDs to set, produced by Morphologizer.predict.
|
| DOCS: https://spacy.io/api/morphologizer#set_annotations
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| label_data
| Morphologizer.label_data(self) -> Dict[str, Dict[str, Union[str, float, int, None]]]
|
| A dictionary with all labels data.
|
| labels
| Morphologizer.labels(self)
|
| RETURNS (Tuple[str]): The labels currently added to the component.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| POS_FEAT = 'POS'
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.tagger.Tagger:
|
| predict(self, docs)
| Tagger.predict(self, docs)
|
| Apply the pipeline's model to a batch of docs, without modifying them.
|
| docs (Iterable[Doc]): The documents to predict.
| RETURNS: The models prediction for each document.
|
| DOCS: https://spacy.io/api/tagger#predict
|
| rehearse(self, examples, *, drop=0.0, sgd=None, losses=None)
| Tagger.rehearse(self, examples, *, drop=0., sgd=None, losses=None)
|
| Perform a "rehearsal" update from a batch of data. Rehearsal updates
| teach the current model to make predictions similar to an initial model,
| to try to address the "catastrophic forgetting" problem. This feature is
| experimental.
|
| examples (Iterable[Example]): A batch of Example objects.
| drop (float): The dropout rate.
| sgd (thinc.api.Optimizer): The optimizer.
| losses (Dict[str, float]): Optional record of the loss during training.
| Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/tagger#rehearse
|
| update(self, examples, *, drop=0.0, sgd=None, losses=None)
| Tagger.update(self, examples, *, drop=0., sgd=None, losses=None)
|
| Learn from a batch of documents and gold-standard information,
| updating the pipe's model. Delegates to predict and get_loss.
|
| examples (Iterable[Example]): A batch of Example objects.
| drop (float): The dropout rate.
| sgd (thinc.api.Optimizer): The optimizer.
| losses (Dict[str, float]): Optional record of the loss during training.
| Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/tagger#update
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.tagger.Tagger:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __call__(...)
| TrainablePipe.__call__(self, Doc doc) -> Doc
|
| Apply the pipe to one document. The document is modified in place,
| and returned. This usually happens under the hood when the nlp object
| is called on a text and all components are applied to the Doc.
|
| docs (Doc): The Doc to process.
| RETURNS (Doc): The processed Doc.
|
| DOCS: https://spacy.io/api/pipe#call
|
| __reduce__ = __reduce_cython__(...)
| TrainablePipe.__reduce_cython__(self)
|
| __reduce_cython__(self)
| TrainablePipe.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| create_optimizer(self) -> 'Optimizer'
| TrainablePipe.create_optimizer(self) -> Optimizer
|
| Create an optimizer for the pipeline component.
|
| RETURNS (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#create_optimizer
|
| finish_update(self, sgd: 'Optimizer') -> 'None'
| TrainablePipe.finish_update(self, sgd: Optimizer) -> None
|
| Update parameters using the current parameter gradients.
| The Optimizer instance contains the functionality to perform
| the stochastic gradient descent.
|
| sgd (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#finish_update
|
| from_bytes(self, bytes_data, *, exclude=())
| TrainablePipe.from_bytes(self, bytes_data, *, exclude=tuple())
|
| Load the pipe from a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (TrainablePipe): The loaded object.
|
| DOCS: https://spacy.io/api/pipe#from_bytes
|
| from_disk(self, path, *, exclude=())
| TrainablePipe.from_disk(self, path, *, exclude=tuple())
|
| Load the pipe from disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (TrainablePipe): The loaded object.
|
| DOCS: https://spacy.io/api/pipe#from_disk
|
| pipe(self, stream: 'Iterable[Doc]', *, batch_size: 'int' = 128) -> 'Iterator[Doc]'
| TrainablePipe.pipe(self, stream: Iterable[Doc], *, batch_size: int = 128) -> Iterator[Doc]
|
| Apply the pipe to a stream of documents. This usually happens under
| the hood when the nlp object is called on a text and all components are
| applied to the Doc.
|
| stream (Iterable[Doc]): A stream of documents.
| batch_size (int): The number of documents to buffer.
| error_handler (Callable[[str, List[Doc], Exception], Any]): Function that
| deals with a failing batch of documents. The default function just reraises
| the exception.
| YIELDS (Doc): Processed documents in order.
|
| DOCS: https://spacy.io/api/pipe#pipe
|
| set_output(self, nO: 'int') -> 'None'
| TrainablePipe.set_output(self, nO: int) -> None
|
| to_bytes(self, *, exclude=())
| TrainablePipe.to_bytes(self, *, exclude=tuple())
|
| Serialize the pipe to a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (bytes): The serialized object.
|
| DOCS: https://spacy.io/api/pipe#to_bytes
|
| to_disk(self, path, *, exclude=())
| TrainablePipe.to_disk(self, path, *, exclude=tuple())
|
| Serialize the pipe to disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
|
| DOCS: https://spacy.io/api/pipe#to_disk
|
| use_params(self, params: 'dict')
| TrainablePipe.use_params(self, params: dict)
|
| Modify the pipe's model, to use the given parameter values. At the
| end of the context, the original parameters are restored.
|
| params (dict): The parameter values to use in the model.
|
| DOCS: https://spacy.io/api/pipe#use_params
|
| ----------------------------------------------------------------------
| Static methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __new__(*args, **kwargs) class method of spacy.pipeline.trainable_pipe.TrainablePipe
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| cfg
| cfg: object
|
| is_resizable
| TrainablePipe.is_resizable: bool
|
| is_trainable
| TrainablePipe.is_trainable: bool
|
| model
| model: object
|
| scorer
| scorer: object
|
| vocab
| vocab: spacy.vocab.Vocab
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.pipe.Pipe:
|
| get_error_handler(self) -> 'Callable'
| Pipe.get_error_handler(self) -> Callable
|
| Retrieve the error handler function.
|
| RETURNS (Callable): The error handler, or if it's not set a default function that just reraises.
|
| DOCS: https://spacy.io/api/pipe#get_error_handler
|
| score(self, examples: 'Iterable[Example]', **kwargs) -> 'Dict[str, Union[float, Dict[str, float]]]'
| Pipe.score(self, examples: Iterable[Example], **kwargs) -> Dict[str, Union[float, Dict[str, float]]]
|
| Score a batch of examples.
|
| examples (Iterable[Example]): The examples to score.
| RETURNS (Dict[str, Any]): The scores.
|
| DOCS: https://spacy.io/api/pipe#score
|
| set_error_handler(self, error_handler: 'Callable') -> 'None'
| Pipe.set_error_handler(self, error_handler: Callable) -> None
|
| Set an error handler function.
|
| error_handler (Callable[[str, Callable[[Doc], Doc], List[Doc], Exception], None]):
| Function that deals with a failing batch of documents. This callable function should take in
| the component's name, the component itself, the offending batch of documents, and the exception
| that was thrown.
|
| DOCS: https://spacy.io/api/pipe#set_error_handler
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.pipe.Pipe:
|
| hide_labels
| Pipe.hide_labels: bool
|
| name
| name: str
class MultiLabel_TextCategorizer(spacy.pipeline.textcat.TextCategorizer)
| MultiLabel_TextCategorizer(vocab: spacy.vocab.Vocab, model: thinc.model.Model, name: str = 'textcat_multilabel', *, threshold: float, scorer: Optional[Callable] = <function textcat_multilabel_score at 0x0000022154CAA840>) -> None
|
| Pipeline component for multi-label text classification.
|
| DOCS: https://spacy.io/api/textcategorizer
|
| Method resolution order:
| MultiLabel_TextCategorizer
| spacy.pipeline.textcat.TextCategorizer
| spacy.pipeline.trainable_pipe.TrainablePipe
| spacy.pipeline.pipe.Pipe
| builtins.object
|
| Methods defined here:
|
| __init__(self, vocab: spacy.vocab.Vocab, model: thinc.model.Model, name: str = 'textcat_multilabel', *, threshold: float, scorer: Optional[Callable] = <function textcat_multilabel_score at 0x0000022154CAA840>) -> None
| Initialize a text categorizer for multi-label classification.
|
| vocab (Vocab): The shared vocabulary.
| model (thinc.api.Model): The Thinc Model powering the pipeline component.
| name (str): The component instance name, used to add entries to the
| losses during training.
| threshold (float): Cutoff to consider a prediction "positive".
| scorer (Optional[Callable]): The scoring method.
|
| DOCS: https://spacy.io/api/textcategorizer#init
|
| initialize(self, get_examples: Callable[[], Iterable[spacy.training.example.Example]], *, nlp: Optional[spacy.language.Language] = None, labels: Optional[Iterable[str]] = None)
| Initialize the pipe for training, using a representative set
| of data examples.
|
| get_examples (Callable[[], Iterable[Example]]): Function that
| returns a representative sample of gold-standard Example objects.
| nlp (Language): The current nlp object the component is part of.
| labels: The labels to add to the component, typically generated by the
| `init labels` command. If no labels are provided, the get_examples
| callback is used to extract the labels from the data.
|
| DOCS: https://spacy.io/api/textcategorizer#initialize
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| support_missing_values
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.textcat.TextCategorizer:
|
| add_label(self, label: str) -> int
| Add a new label to the pipe.
|
| label (str): The label to add.
| RETURNS (int): 0 if label is already present, otherwise 1.
|
| DOCS: https://spacy.io/api/textcategorizer#add_label
|
| get_loss(self, examples: Iterable[spacy.training.example.Example], scores) -> Tuple[float, float]
| Find the loss and gradient of loss for the batch of documents and
| their predicted scores.
|
| examples (Iterable[Examples]): The batch of examples.
| scores: Scores representing the model's predictions.
| RETURNS (Tuple[float, float]): The loss and the gradient.
|
| DOCS: https://spacy.io/api/textcategorizer#get_loss
|
| predict(self, docs: Iterable[spacy.tokens.doc.Doc])
| Apply the pipeline's model to a batch of docs, without modifying them.
|
| docs (Iterable[Doc]): The documents to predict.
| RETURNS: The models prediction for each document.
|
| DOCS: https://spacy.io/api/textcategorizer#predict
|
| rehearse(self, examples: Iterable[spacy.training.example.Example], *, drop: float = 0.0, sgd: Optional[thinc.optimizers.Optimizer] = None, losses: Optional[Dict[str, float]] = None) -> Dict[str, float]
| Perform a "rehearsal" update from a batch of data. Rehearsal updates
| teach the current model to make predictions similar to an initial model,
| to try to address the "catastrophic forgetting" problem. This feature is
| experimental.
|
| examples (Iterable[Example]): A batch of Example objects.
| drop (float): The dropout rate.
| sgd (thinc.api.Optimizer): The optimizer.
| losses (Dict[str, float]): Optional record of the loss during training.
| Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/textcategorizer#rehearse
|
| set_annotations(self, docs: Iterable[spacy.tokens.doc.Doc], scores) -> None
| Modify a batch of Doc objects, using pre-computed scores.
|
| docs (Iterable[Doc]): The documents to modify.
| scores: The scores to set, produced by TextCategorizer.predict.
|
| DOCS: https://spacy.io/api/textcategorizer#set_annotations
|
| update(self, examples: Iterable[spacy.training.example.Example], *, drop: float = 0.0, sgd: Optional[thinc.optimizers.Optimizer] = None, losses: Optional[Dict[str, float]] = None) -> Dict[str, float]
| Learn from a batch of documents and gold-standard information,
| updating the pipe's model. Delegates to predict and get_loss.
|
| examples (Iterable[Example]): A batch of Example objects.
| drop (float): The dropout rate.
| sgd (thinc.api.Optimizer): The optimizer.
| losses (Dict[str, float]): Optional record of the loss during training.
| Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/textcategorizer#update
|
| ----------------------------------------------------------------------
| Readonly properties inherited from spacy.pipeline.textcat.TextCategorizer:
|
| label_data
| RETURNS (List[str]): Information about the component's labels.
|
| DOCS: https://spacy.io/api/textcategorizer#label_data
|
| labels
| RETURNS (Tuple[str]): The labels currently added to the component.
|
| DOCS: https://spacy.io/api/textcategorizer#labels
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.textcat.TextCategorizer:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __call__(...)
| TrainablePipe.__call__(self, Doc doc) -> Doc
|
| Apply the pipe to one document. The document is modified in place,
| and returned. This usually happens under the hood when the nlp object
| is called on a text and all components are applied to the Doc.
|
| docs (Doc): The Doc to process.
| RETURNS (Doc): The processed Doc.
|
| DOCS: https://spacy.io/api/pipe#call
|
| __reduce__ = __reduce_cython__(...)
| TrainablePipe.__reduce_cython__(self)
|
| __reduce_cython__(self)
| TrainablePipe.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| create_optimizer(self) -> 'Optimizer'
| TrainablePipe.create_optimizer(self) -> Optimizer
|
| Create an optimizer for the pipeline component.
|
| RETURNS (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#create_optimizer
|
| finish_update(self, sgd: 'Optimizer') -> 'None'
| TrainablePipe.finish_update(self, sgd: Optimizer) -> None
|
| Update parameters using the current parameter gradients.
| The Optimizer instance contains the functionality to perform
| the stochastic gradient descent.
|
| sgd (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#finish_update
|
| from_bytes(self, bytes_data, *, exclude=())
| TrainablePipe.from_bytes(self, bytes_data, *, exclude=tuple())
|
| Load the pipe from a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (TrainablePipe): The loaded object.
|
| DOCS: https://spacy.io/api/pipe#from_bytes
|
| from_disk(self, path, *, exclude=())
| TrainablePipe.from_disk(self, path, *, exclude=tuple())
|
| Load the pipe from disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (TrainablePipe): The loaded object.
|
| DOCS: https://spacy.io/api/pipe#from_disk
|
| pipe(self, stream: 'Iterable[Doc]', *, batch_size: 'int' = 128) -> 'Iterator[Doc]'
| TrainablePipe.pipe(self, stream: Iterable[Doc], *, batch_size: int = 128) -> Iterator[Doc]
|
| Apply the pipe to a stream of documents. This usually happens under
| the hood when the nlp object is called on a text and all components are
| applied to the Doc.
|
| stream (Iterable[Doc]): A stream of documents.
| batch_size (int): The number of documents to buffer.
| error_handler (Callable[[str, List[Doc], Exception], Any]): Function that
| deals with a failing batch of documents. The default function just reraises
| the exception.
| YIELDS (Doc): Processed documents in order.
|
| DOCS: https://spacy.io/api/pipe#pipe
|
| set_output(self, nO: 'int') -> 'None'
| TrainablePipe.set_output(self, nO: int) -> None
|
| to_bytes(self, *, exclude=())
| TrainablePipe.to_bytes(self, *, exclude=tuple())
|
| Serialize the pipe to a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (bytes): The serialized object.
|
| DOCS: https://spacy.io/api/pipe#to_bytes
|
| to_disk(self, path, *, exclude=())
| TrainablePipe.to_disk(self, path, *, exclude=tuple())
|
| Serialize the pipe to disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
|
| DOCS: https://spacy.io/api/pipe#to_disk
|
| use_params(self, params: 'dict')
| TrainablePipe.use_params(self, params: dict)
|
| Modify the pipe's model, to use the given parameter values. At the
| end of the context, the original parameters are restored.
|
| params (dict): The parameter values to use in the model.
|
| DOCS: https://spacy.io/api/pipe#use_params
|
| ----------------------------------------------------------------------
| Static methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __new__(*args, **kwargs) class method of spacy.pipeline.trainable_pipe.TrainablePipe
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| cfg
| cfg: object
|
| is_resizable
| TrainablePipe.is_resizable: bool
|
| is_trainable
| TrainablePipe.is_trainable: bool
|
| model
| model: object
|
| scorer
| scorer: object
|
| vocab
| vocab: spacy.vocab.Vocab
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.pipe.Pipe:
|
| get_error_handler(self) -> 'Callable'
| Pipe.get_error_handler(self) -> Callable
|
| Retrieve the error handler function.
|
| RETURNS (Callable): The error handler, or if it's not set a default function that just reraises.
|
| DOCS: https://spacy.io/api/pipe#get_error_handler
|
| score(self, examples: 'Iterable[Example]', **kwargs) -> 'Dict[str, Union[float, Dict[str, float]]]'
| Pipe.score(self, examples: Iterable[Example], **kwargs) -> Dict[str, Union[float, Dict[str, float]]]
|
| Score a batch of examples.
|
| examples (Iterable[Example]): The examples to score.
| RETURNS (Dict[str, Any]): The scores.
|
| DOCS: https://spacy.io/api/pipe#score
|
| set_error_handler(self, error_handler: 'Callable') -> 'None'
| Pipe.set_error_handler(self, error_handler: Callable) -> None
|
| Set an error handler function.
|
| error_handler (Callable[[str, Callable[[Doc], Doc], List[Doc], Exception], None]):
| Function that deals with a failing batch of documents. This callable function should take in
| the component's name, the component itself, the offending batch of documents, and the exception
| that was thrown.
|
| DOCS: https://spacy.io/api/pipe#set_error_handler
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.pipe.Pipe:
|
| hide_labels
| Pipe.hide_labels: bool
|
| name
| name: str
class Pipe(builtins.object)
| This class is a base class and not instantiated directly. It provides
| an interface for pipeline components to implement.
| Trainable pipeline components like the EntityRecognizer or TextCategorizer
| should inherit from the subclass 'TrainablePipe'.
|
| DOCS: https://spacy.io/api/pipe
|
| Methods defined here:
|
| __call__(...)
| Pipe.__call__(self, Doc doc) -> Doc
|
| Apply the pipe to one document. The document is modified in place,
| and returned. This usually happens under the hood when the nlp object
| is called on a text and all components are applied to the Doc.
|
| doc (Doc): The Doc to process.
| RETURNS (Doc): The processed Doc.
|
| DOCS: https://spacy.io/api/pipe#call
|
| __reduce__ = __reduce_cython__(...)
| Pipe.__reduce_cython__(self)
|
| __reduce_cython__(self)
| Pipe.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| Pipe.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| Pipe.__setstate_cython__(self, __pyx_state)
|
| get_error_handler(self) -> 'Callable'
| Pipe.get_error_handler(self) -> Callable
|
| Retrieve the error handler function.
|
| RETURNS (Callable): The error handler, or if it's not set a default function that just reraises.
|
| DOCS: https://spacy.io/api/pipe#get_error_handler
|
| initialize(self, get_examples: 'Callable[[], Iterable[Example]]', *, nlp: 'Language' = None)
| Pipe.initialize(self, get_examples: Callable[[], Iterable[Example]], *, nlp: Language = None)
|
| Initialize the pipe. For non-trainable components, this method
| is optional. For trainable components, which should inherit
| from the subclass TrainablePipe, the provided data examples
| should be used to ensure that the internal model is initialized
| properly and all input/output dimensions throughout the network are
| inferred.
|
| get_examples (Callable[[], Iterable[Example]]): Function that
| returns a representative sample of gold-standard Example objects.
| nlp (Language): The current nlp object the component is part of.
|
| DOCS: https://spacy.io/api/pipe#initialize
|
| pipe(self, stream: 'Iterable[Doc]', *, batch_size: 'int' = 128) -> 'Iterator[Doc]'
| Pipe.pipe(self, stream: Iterable[Doc], *, batch_size: int = 128) -> Iterator[Doc]
|
| Apply the pipe to a stream of documents. This usually happens under
| the hood when the nlp object is called on a text and all components are
| applied to the Doc.
|
| stream (Iterable[Doc]): A stream of documents.
| batch_size (int): The number of documents to buffer.
| YIELDS (Doc): Processed documents in order.
|
| DOCS: https://spacy.io/api/pipe#pipe
|
| score(self, examples: 'Iterable[Example]', **kwargs) -> 'Dict[str, Union[float, Dict[str, float]]]'
| Pipe.score(self, examples: Iterable[Example], **kwargs) -> Dict[str, Union[float, Dict[str, float]]]
|
| Score a batch of examples.
|
| examples (Iterable[Example]): The examples to score.
| RETURNS (Dict[str, Any]): The scores.
|
| DOCS: https://spacy.io/api/pipe#score
|
| set_error_handler(self, error_handler: 'Callable') -> 'None'
| Pipe.set_error_handler(self, error_handler: Callable) -> None
|
| Set an error handler function.
|
| error_handler (Callable[[str, Callable[[Doc], Doc], List[Doc], Exception], None]):
| Function that deals with a failing batch of documents. This callable function should take in
| the component's name, the component itself, the offending batch of documents, and the exception
| that was thrown.
|
| DOCS: https://spacy.io/api/pipe#set_error_handler
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| hide_labels
| Pipe.hide_labels: bool
|
| is_trainable
| Pipe.is_trainable: bool
|
| label_data
| Optional JSON-serializable data that would be sufficient to recreate
| the label set if provided to the `pipe.initialize()` method.
|
| labels
| Pipe.labels: Tuple[str, ...]
|
| name
| name: str
class SentenceRecognizer(spacy.pipeline.tagger.Tagger)
| SentenceRecognizer(vocab, model, name='senter', *, overwrite=False, scorer=<cyfunction senter_score at 0x0000022154BC87A0>)
|
| Pipeline component for sentence segmentation.
|
| DOCS: https://spacy.io/api/sentencerecognizer
|
| Method resolution order:
| SentenceRecognizer
| spacy.pipeline.tagger.Tagger
| spacy.pipeline.trainable_pipe.TrainablePipe
| spacy.pipeline.pipe.Pipe
| builtins.object
|
| Methods defined here:
|
| __init__(self, vocab, model, name='senter', *, overwrite=False, scorer=<cyfunction senter_score at 0x0000022154BC87A0>)
| SentenceRecognizer.__init__(self, vocab, model, name='senter', *, overwrite=BACKWARD_OVERWRITE, scorer=senter_score)
|
| Initialize a sentence recognizer.
|
| vocab (Vocab): The shared vocabulary.
| model (thinc.api.Model): The Thinc Model powering the pipeline component.
| name (str): The component instance name, used to add entries to the
| losses during training.
| scorer (Optional[Callable]): The scoring method. Defaults to
| Scorer.score_spans for the attribute "sents".
|
| DOCS: https://spacy.io/api/sentencerecognizer#init
|
| add_label(self, label, values=None)
| SentenceRecognizer.add_label(self, label, values=None)
|
| get_loss(self, examples, scores)
| SentenceRecognizer.get_loss(self, examples, scores)
|
| Find the loss and gradient of loss for the batch of documents and
| their predicted scores.
|
| examples (Iterable[Examples]): The batch of examples.
| scores: Scores representing the model's predictions.
| RETURNS (Tuple[float, float]): The loss and the gradient.
|
| DOCS: https://spacy.io/api/sentencerecognizer#get_loss
|
| initialize(self, get_examples, *, nlp=None)
| SentenceRecognizer.initialize(self, get_examples, *, nlp=None)
|
| Initialize the pipe for training, using a representative set
| of data examples.
|
| get_examples (Callable[[], Iterable[Example]]): Function that
| returns a representative sample of gold-standard Example objects.
| nlp (Language): The current nlp object the component is part of.
|
| DOCS: https://spacy.io/api/sentencerecognizer#initialize
|
| set_annotations(self, docs, batch_tag_ids)
| SentenceRecognizer.set_annotations(self, docs, batch_tag_ids)
|
| Modify a batch of documents, using pre-computed scores.
|
| docs (Iterable[Doc]): The documents to modify.
| batch_tag_ids: The IDs to set, produced by SentenceRecognizer.predict.
|
| DOCS: https://spacy.io/api/sentencerecognizer#set_annotations
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| hide_labels
| SentenceRecognizer.hide_labels(self)
|
| label_data
| SentenceRecognizer.label_data(self)
|
| labels
| SentenceRecognizer.labels(self)
|
| RETURNS (Tuple[str]): The labels.
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.tagger.Tagger:
|
| predict(self, docs)
| Tagger.predict(self, docs)
|
| Apply the pipeline's model to a batch of docs, without modifying them.
|
| docs (Iterable[Doc]): The documents to predict.
| RETURNS: The models prediction for each document.
|
| DOCS: https://spacy.io/api/tagger#predict
|
| rehearse(self, examples, *, drop=0.0, sgd=None, losses=None)
| Tagger.rehearse(self, examples, *, drop=0., sgd=None, losses=None)
|
| Perform a "rehearsal" update from a batch of data. Rehearsal updates
| teach the current model to make predictions similar to an initial model,
| to try to address the "catastrophic forgetting" problem. This feature is
| experimental.
|
| examples (Iterable[Example]): A batch of Example objects.
| drop (float): The dropout rate.
| sgd (thinc.api.Optimizer): The optimizer.
| losses (Dict[str, float]): Optional record of the loss during training.
| Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/tagger#rehearse
|
| update(self, examples, *, drop=0.0, sgd=None, losses=None)
| Tagger.update(self, examples, *, drop=0., sgd=None, losses=None)
|
| Learn from a batch of documents and gold-standard information,
| updating the pipe's model. Delegates to predict and get_loss.
|
| examples (Iterable[Example]): A batch of Example objects.
| drop (float): The dropout rate.
| sgd (thinc.api.Optimizer): The optimizer.
| losses (Dict[str, float]): Optional record of the loss during training.
| Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/tagger#update
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.tagger.Tagger:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __call__(...)
| TrainablePipe.__call__(self, Doc doc) -> Doc
|
| Apply the pipe to one document. The document is modified in place,
| and returned. This usually happens under the hood when the nlp object
| is called on a text and all components are applied to the Doc.
|
| docs (Doc): The Doc to process.
| RETURNS (Doc): The processed Doc.
|
| DOCS: https://spacy.io/api/pipe#call
|
| __reduce__ = __reduce_cython__(...)
| TrainablePipe.__reduce_cython__(self)
|
| __reduce_cython__(self)
| TrainablePipe.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| create_optimizer(self) -> 'Optimizer'
| TrainablePipe.create_optimizer(self) -> Optimizer
|
| Create an optimizer for the pipeline component.
|
| RETURNS (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#create_optimizer
|
| finish_update(self, sgd: 'Optimizer') -> 'None'
| TrainablePipe.finish_update(self, sgd: Optimizer) -> None
|
| Update parameters using the current parameter gradients.
| The Optimizer instance contains the functionality to perform
| the stochastic gradient descent.
|
| sgd (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#finish_update
|
| from_bytes(self, bytes_data, *, exclude=())
| TrainablePipe.from_bytes(self, bytes_data, *, exclude=tuple())
|
| Load the pipe from a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (TrainablePipe): The loaded object.
|
| DOCS: https://spacy.io/api/pipe#from_bytes
|
| from_disk(self, path, *, exclude=())
| TrainablePipe.from_disk(self, path, *, exclude=tuple())
|
| Load the pipe from disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (TrainablePipe): The loaded object.
|
| DOCS: https://spacy.io/api/pipe#from_disk
|
| pipe(self, stream: 'Iterable[Doc]', *, batch_size: 'int' = 128) -> 'Iterator[Doc]'
| TrainablePipe.pipe(self, stream: Iterable[Doc], *, batch_size: int = 128) -> Iterator[Doc]
|
| Apply the pipe to a stream of documents. This usually happens under
| the hood when the nlp object is called on a text and all components are
| applied to the Doc.
|
| stream (Iterable[Doc]): A stream of documents.
| batch_size (int): The number of documents to buffer.
| error_handler (Callable[[str, List[Doc], Exception], Any]): Function that
| deals with a failing batch of documents. The default function just reraises
| the exception.
| YIELDS (Doc): Processed documents in order.
|
| DOCS: https://spacy.io/api/pipe#pipe
|
| set_output(self, nO: 'int') -> 'None'
| TrainablePipe.set_output(self, nO: int) -> None
|
| to_bytes(self, *, exclude=())
| TrainablePipe.to_bytes(self, *, exclude=tuple())
|
| Serialize the pipe to a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (bytes): The serialized object.
|
| DOCS: https://spacy.io/api/pipe#to_bytes
|
| to_disk(self, path, *, exclude=())
| TrainablePipe.to_disk(self, path, *, exclude=tuple())
|
| Serialize the pipe to disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
|
| DOCS: https://spacy.io/api/pipe#to_disk
|
| use_params(self, params: 'dict')
| TrainablePipe.use_params(self, params: dict)
|
| Modify the pipe's model, to use the given parameter values. At the
| end of the context, the original parameters are restored.
|
| params (dict): The parameter values to use in the model.
|
| DOCS: https://spacy.io/api/pipe#use_params
|
| ----------------------------------------------------------------------
| Static methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __new__(*args, **kwargs) class method of spacy.pipeline.trainable_pipe.TrainablePipe
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| cfg
| cfg: object
|
| is_resizable
| TrainablePipe.is_resizable: bool
|
| is_trainable
| TrainablePipe.is_trainable: bool
|
| model
| model: object
|
| scorer
| scorer: object
|
| vocab
| vocab: spacy.vocab.Vocab
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.pipe.Pipe:
|
| get_error_handler(self) -> 'Callable'
| Pipe.get_error_handler(self) -> Callable
|
| Retrieve the error handler function.
|
| RETURNS (Callable): The error handler, or if it's not set a default function that just reraises.
|
| DOCS: https://spacy.io/api/pipe#get_error_handler
|
| score(self, examples: 'Iterable[Example]', **kwargs) -> 'Dict[str, Union[float, Dict[str, float]]]'
| Pipe.score(self, examples: Iterable[Example], **kwargs) -> Dict[str, Union[float, Dict[str, float]]]
|
| Score a batch of examples.
|
| examples (Iterable[Example]): The examples to score.
| RETURNS (Dict[str, Any]): The scores.
|
| DOCS: https://spacy.io/api/pipe#score
|
| set_error_handler(self, error_handler: 'Callable') -> 'None'
| Pipe.set_error_handler(self, error_handler: Callable) -> None
|
| Set an error handler function.
|
| error_handler (Callable[[str, Callable[[Doc], Doc], List[Doc], Exception], None]):
| Function that deals with a failing batch of documents. This callable function should take in
| the component's name, the component itself, the offending batch of documents, and the exception
| that was thrown.
|
| DOCS: https://spacy.io/api/pipe#set_error_handler
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.pipe.Pipe:
|
| name
| name: str
class Sentencizer(spacy.pipeline.pipe.Pipe)
| Sentencizer(name='sentencizer', *, punct_chars=None, overwrite=False, scorer=<cyfunction senter_score at 0x0000022154BC87A0>)
|
| Segment the Doc into sentences using a rule-based strategy.
|
| DOCS: https://spacy.io/api/sentencizer
|
| Method resolution order:
| Sentencizer
| spacy.pipeline.pipe.Pipe
| builtins.object
|
| Methods defined here:
|
| __call__(self, doc)
| Sentencizer.__call__(self, doc)
|
| Apply the sentencizer to a Doc and set Token.is_sent_start.
|
| doc (Doc): The document to process.
| RETURNS (Doc): The processed Doc.
|
| DOCS: https://spacy.io/api/sentencizer#call
|
| __init__(self, name='sentencizer', *, punct_chars=None, overwrite=False, scorer=<cyfunction senter_score at 0x0000022154BC87A0>)
| Sentencizer.__init__(self, name='sentencizer', *, punct_chars=None, overwrite=BACKWARD_OVERWRITE, scorer=senter_score)
|
| Initialize the sentencizer.
|
| punct_chars (list): Punctuation characters to split on. Will be
| serialized with the nlp object.
| scorer (Optional[Callable]): The scoring method. Defaults to
| Scorer.score_spans for the attribute "sents".
|
| DOCS: https://spacy.io/api/sentencizer#init
|
| from_bytes(self, bytes_data, *, exclude=())
| Sentencizer.from_bytes(self, bytes_data, *, exclude=tuple())
|
| Load the sentencizer from a bytestring.
|
| bytes_data (bytes): The data to load.
| returns (Sentencizer): The loaded object.
|
| DOCS: https://spacy.io/api/sentencizer#from_bytes
|
| from_disk(self, path, *, exclude=())
| Sentencizer.from_disk(self, path, *, exclude=tuple())
|
| Load the sentencizer from disk.
|
| DOCS: https://spacy.io/api/sentencizer#from_disk
|
| predict(self, docs)
| Sentencizer.predict(self, docs)
|
| Apply the pipe to a batch of docs, without modifying them.
|
| docs (Iterable[Doc]): The documents to predict.
| RETURNS: The predictions for each document.
|
| set_annotations(self, docs, batch_tag_ids)
| Sentencizer.set_annotations(self, docs, batch_tag_ids)
|
| Modify a batch of documents, using pre-computed scores.
|
| docs (Iterable[Doc]): The documents to modify.
| scores: The tag IDs produced by Sentencizer.predict.
|
| to_bytes(self, *, exclude=())
| Sentencizer.to_bytes(self, *, exclude=tuple())
|
| Serialize the sentencizer to a bytestring.
|
| RETURNS (bytes): The serialized object.
|
| DOCS: https://spacy.io/api/sentencizer#to_bytes
|
| to_disk(self, path, *, exclude=())
| Sentencizer.to_disk(self, path, *, exclude=tuple())
|
| Serialize the sentencizer to disk.
|
| DOCS: https://spacy.io/api/sentencizer#to_disk
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| default_punct_chars = ['!', '.', '?', '։', '؟', '۔', '܀', '܁', '܂', '߹...
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.pipe.Pipe:
|
| __reduce__ = __reduce_cython__(...)
| Pipe.__reduce_cython__(self)
|
| __reduce_cython__(self)
| Pipe.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| Pipe.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| Pipe.__setstate_cython__(self, __pyx_state)
|
| get_error_handler(self) -> 'Callable'
| Pipe.get_error_handler(self) -> Callable
|
| Retrieve the error handler function.
|
| RETURNS (Callable): The error handler, or if it's not set a default function that just reraises.
|
| DOCS: https://spacy.io/api/pipe#get_error_handler
|
| initialize(self, get_examples: 'Callable[[], Iterable[Example]]', *, nlp: 'Language' = None)
| Pipe.initialize(self, get_examples: Callable[[], Iterable[Example]], *, nlp: Language = None)
|
| Initialize the pipe. For non-trainable components, this method
| is optional. For trainable components, which should inherit
| from the subclass TrainablePipe, the provided data examples
| should be used to ensure that the internal model is initialized
| properly and all input/output dimensions throughout the network are
| inferred.
|
| get_examples (Callable[[], Iterable[Example]]): Function that
| returns a representative sample of gold-standard Example objects.
| nlp (Language): The current nlp object the component is part of.
|
| DOCS: https://spacy.io/api/pipe#initialize
|
| pipe(self, stream: 'Iterable[Doc]', *, batch_size: 'int' = 128) -> 'Iterator[Doc]'
| Pipe.pipe(self, stream: Iterable[Doc], *, batch_size: int = 128) -> Iterator[Doc]
|
| Apply the pipe to a stream of documents. This usually happens under
| the hood when the nlp object is called on a text and all components are
| applied to the Doc.
|
| stream (Iterable[Doc]): A stream of documents.
| batch_size (int): The number of documents to buffer.
| YIELDS (Doc): Processed documents in order.
|
| DOCS: https://spacy.io/api/pipe#pipe
|
| score(self, examples: 'Iterable[Example]', **kwargs) -> 'Dict[str, Union[float, Dict[str, float]]]'
| Pipe.score(self, examples: Iterable[Example], **kwargs) -> Dict[str, Union[float, Dict[str, float]]]
|
| Score a batch of examples.
|
| examples (Iterable[Example]): The examples to score.
| RETURNS (Dict[str, Any]): The scores.
|
| DOCS: https://spacy.io/api/pipe#score
|
| set_error_handler(self, error_handler: 'Callable') -> 'None'
| Pipe.set_error_handler(self, error_handler: Callable) -> None
|
| Set an error handler function.
|
| error_handler (Callable[[str, Callable[[Doc], Doc], List[Doc], Exception], None]):
| Function that deals with a failing batch of documents. This callable function should take in
| the component's name, the component itself, the offending batch of documents, and the exception
| that was thrown.
|
| DOCS: https://spacy.io/api/pipe#set_error_handler
|
| ----------------------------------------------------------------------
| Static methods inherited from spacy.pipeline.pipe.Pipe:
|
| __new__(*args, **kwargs) class method of spacy.pipeline.pipe.Pipe
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.pipe.Pipe:
|
| hide_labels
| Pipe.hide_labels: bool
|
| is_trainable
| Pipe.is_trainable: bool
|
| label_data
| Optional JSON-serializable data that would be sufficient to recreate
| the label set if provided to the `pipe.initialize()` method.
|
| labels
| Pipe.labels: Tuple[str, ...]
|
| name
| name: str
class SpanCategorizer(spacy.pipeline.trainable_pipe.TrainablePipe)
| SpanCategorizer(vocab: spacy.vocab.Vocab, model: thinc.model.Model[typing.Tuple[typing.List[spacy.tokens.doc.Doc], thinc.types.Ragged], thinc.types.Floats2d], suggester: spacy.pipeline.spancat.Suggester, name: str = 'spancat', *, add_negative_label: bool = False, spans_key: str = 'spans', negative_weight: Optional[float] = 1.0, allow_overlap: Optional[bool] = True, max_positive: Optional[int] = None, threshold: Optional[float] = 0.5, scorer: Optional[Callable] = <function spancat_score at 0x0000022154BAB060>) -> None
|
| Pipeline component to label spans of text.
|
| DOCS: https://spacy.io/api/spancategorizer
|
| Method resolution order:
| SpanCategorizer
| spacy.pipeline.trainable_pipe.TrainablePipe
| spacy.pipeline.pipe.Pipe
| builtins.object
|
| Methods defined here:
|
| __init__(self, vocab: spacy.vocab.Vocab, model: thinc.model.Model[typing.Tuple[typing.List[spacy.tokens.doc.Doc], thinc.types.Ragged], thinc.types.Floats2d], suggester: spacy.pipeline.spancat.Suggester, name: str = 'spancat', *, add_negative_label: bool = False, spans_key: str = 'spans', negative_weight: Optional[float] = 1.0, allow_overlap: Optional[bool] = True, max_positive: Optional[int] = None, threshold: Optional[float] = 0.5, scorer: Optional[Callable] = <function spancat_score at 0x0000022154BAB060>) -> None
| Initialize the multi-label or multi-class span categorizer.
|
| vocab (Vocab): The shared vocabulary.
| model (thinc.api.Model): The Thinc Model powering the pipeline component.
| For multi-class classification (single label per span) we recommend
| using a Softmax classifier as a the final layer, while for multi-label
| classification (multiple possible labels per span) we recommend Logistic.
| suggester (Callable[[Iterable[Doc], Optional[Ops]], Ragged]): A function that suggests spans.
| Spans are returned as a ragged array with two integer columns, for the
| start and end positions.
| name (str): The component instance name, used to add entries to the
| losses during training.
| spans_key (str): Key of the Doc.spans dict to save the spans under.
| During initialization and training, the component will look for
| spans on the reference document under the same key. Defaults to
| `"spans"`.
| add_negative_label (bool): Learn to predict a special 'negative_label'
| when a Span is not annotated.
| threshold (Optional[float]): Minimum probability to consider a prediction
| positive. Defaults to 0.5. Spans with a positive prediction will be saved
| on the Doc.
| max_positive (Optional[int]): Maximum number of labels to consider
| positive per span. Defaults to None, indicating no limit.
| negative_weight (float): Multiplier for the loss terms.
| Can be used to downweight the negative samples if there are too many
| when add_negative_label is True. Otherwise its unused.
| allow_overlap (bool): If True the data is assumed to contain overlapping spans.
| Otherwise it produces non-overlapping spans greedily prioritizing
| higher assigned label scores. Only used when max_positive is 1.
| scorer (Optional[Callable]): The scoring method. Defaults to
| Scorer.score_spans for the Doc.spans[spans_key] with overlapping
| spans allowed.
|
| DOCS: https://spacy.io/api/spancategorizer#init
|
| add_label(self, label: str) -> int
| Add a new label to the pipe.
|
| label (str): The label to add.
| RETURNS (int): 0 if label is already present, otherwise 1.
|
| DOCS: https://spacy.io/api/spancategorizer#add_label
|
| get_loss(self, examples: Iterable[spacy.training.example.Example], spans_scores: Tuple[thinc.types.Ragged, thinc.types.Floats2d]) -> Tuple[float, float]
| Find the loss and gradient of loss for the batch of documents and
| their predicted scores.
|
| examples (Iterable[Examples]): The batch of examples.
| spans_scores: Scores representing the model's predictions.
| RETURNS (Tuple[float, float]): The loss and the gradient.
|
| DOCS: https://spacy.io/api/spancategorizer#get_loss
|
| initialize(self, get_examples: Callable[[], Iterable[spacy.training.example.Example]], *, nlp: Optional[spacy.language.Language] = None, labels: Optional[List[str]] = None) -> None
| Initialize the pipe for training, using a representative set
| of data examples.
|
| get_examples (Callable[[], Iterable[Example]]): Function that
| returns a representative sample of gold-standard Example objects.
| nlp (Optional[Language]): The current nlp object the component is part of.
| labels (Optional[List[str]]): The labels to add to the component, typically generated by the
| `init labels` command. If no labels are provided, the get_examples
| callback is used to extract the labels from the data.
|
| DOCS: https://spacy.io/api/spancategorizer#initialize
|
| predict(self, docs: Iterable[spacy.tokens.doc.Doc])
| Apply the pipeline's model to a batch of docs, without modifying them.
|
| docs (Iterable[Doc]): The documents to predict.
| RETURNS: The models prediction for each document.
|
| DOCS: https://spacy.io/api/spancategorizer#predict
|
| set_annotations(self, docs: Iterable[spacy.tokens.doc.Doc], indices_scores) -> None
| Modify a batch of Doc objects, using pre-computed scores.
|
| docs (Iterable[Doc]): The documents to modify.
| scores: The scores to set, produced by SpanCategorizer.predict.
|
| DOCS: https://spacy.io/api/spancategorizer#set_annotations
|
| set_candidates(self, docs: Iterable[spacy.tokens.doc.Doc], *, candidates_key: str = 'candidates') -> None
| Use the spancat suggester to add a list of span candidates to a list of docs.
| This method is intended to be used for debugging purposes.
|
| docs (Iterable[Doc]): The documents to modify.
| candidates_key (str): Key of the Doc.spans dict to save the candidate spans under.
|
| DOCS: https://spacy.io/api/spancategorizer#set_candidates
|
| update(self, examples: Iterable[spacy.training.example.Example], *, drop: float = 0.0, sgd: Optional[thinc.optimizers.Optimizer] = None, losses: Optional[Dict[str, float]] = None) -> Dict[str, float]
| Learn from a batch of documents and gold-standard information,
| updating the pipe's model. Delegates to predict and get_loss.
|
| examples (Iterable[Example]): A batch of Example objects.
| drop (float): The dropout rate.
| sgd (thinc.api.Optimizer): The optimizer.
| losses (Dict[str, float]): Optional record of the loss during training.
| Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/spancategorizer#update
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| key
| Key of the doc.spans dict to save the spans under. During
| initialization and training, the component will look for spans on the
| reference document under the same key.
|
| label_data
| RETURNS (List[str]): Information about the component's labels.
|
| DOCS: https://spacy.io/api/spancategorizer#label_data
|
| labels
| RETURNS (Tuple[str]): The labels currently added to the component.
|
| DOCS: https://spacy.io/api/spancategorizer#labels
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __call__(...)
| TrainablePipe.__call__(self, Doc doc) -> Doc
|
| Apply the pipe to one document. The document is modified in place,
| and returned. This usually happens under the hood when the nlp object
| is called on a text and all components are applied to the Doc.
|
| docs (Doc): The Doc to process.
| RETURNS (Doc): The processed Doc.
|
| DOCS: https://spacy.io/api/pipe#call
|
| __reduce__ = __reduce_cython__(...)
| TrainablePipe.__reduce_cython__(self)
|
| __reduce_cython__(self)
| TrainablePipe.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| create_optimizer(self) -> 'Optimizer'
| TrainablePipe.create_optimizer(self) -> Optimizer
|
| Create an optimizer for the pipeline component.
|
| RETURNS (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#create_optimizer
|
| finish_update(self, sgd: 'Optimizer') -> 'None'
| TrainablePipe.finish_update(self, sgd: Optimizer) -> None
|
| Update parameters using the current parameter gradients.
| The Optimizer instance contains the functionality to perform
| the stochastic gradient descent.
|
| sgd (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#finish_update
|
| from_bytes(self, bytes_data, *, exclude=())
| TrainablePipe.from_bytes(self, bytes_data, *, exclude=tuple())
|
| Load the pipe from a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (TrainablePipe): The loaded object.
|
| DOCS: https://spacy.io/api/pipe#from_bytes
|
| from_disk(self, path, *, exclude=())
| TrainablePipe.from_disk(self, path, *, exclude=tuple())
|
| Load the pipe from disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (TrainablePipe): The loaded object.
|
| DOCS: https://spacy.io/api/pipe#from_disk
|
| pipe(self, stream: 'Iterable[Doc]', *, batch_size: 'int' = 128) -> 'Iterator[Doc]'
| TrainablePipe.pipe(self, stream: Iterable[Doc], *, batch_size: int = 128) -> Iterator[Doc]
|
| Apply the pipe to a stream of documents. This usually happens under
| the hood when the nlp object is called on a text and all components are
| applied to the Doc.
|
| stream (Iterable[Doc]): A stream of documents.
| batch_size (int): The number of documents to buffer.
| error_handler (Callable[[str, List[Doc], Exception], Any]): Function that
| deals with a failing batch of documents. The default function just reraises
| the exception.
| YIELDS (Doc): Processed documents in order.
|
| DOCS: https://spacy.io/api/pipe#pipe
|
| rehearse(self, examples: 'Iterable[Example]', *, sgd: 'Optimizer' = None, losses: 'Dict[str, float]' = None, **config) -> 'Dict[str, float]'
| TrainablePipe.rehearse(self, examples: Iterable[Example], *, sgd: Optimizer = None, losses: Dict[str, float] = None, **config) -> Dict[str, float]
|
| Perform a "rehearsal" update from a batch of data. Rehearsal updates
| teach the current model to make predictions similar to an initial model,
| to try to address the "catastrophic forgetting" problem. This feature is
| experimental.
|
| examples (Iterable[Example]): A batch of Example objects.
| sgd (thinc.api.Optimizer): The optimizer.
| losses (Dict[str, float]): Optional record of the loss during training.
| Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/pipe#rehearse
|
| set_output(self, nO: 'int') -> 'None'
| TrainablePipe.set_output(self, nO: int) -> None
|
| to_bytes(self, *, exclude=())
| TrainablePipe.to_bytes(self, *, exclude=tuple())
|
| Serialize the pipe to a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (bytes): The serialized object.
|
| DOCS: https://spacy.io/api/pipe#to_bytes
|
| to_disk(self, path, *, exclude=())
| TrainablePipe.to_disk(self, path, *, exclude=tuple())
|
| Serialize the pipe to disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
|
| DOCS: https://spacy.io/api/pipe#to_disk
|
| use_params(self, params: 'dict')
| TrainablePipe.use_params(self, params: dict)
|
| Modify the pipe's model, to use the given parameter values. At the
| end of the context, the original parameters are restored.
|
| params (dict): The parameter values to use in the model.
|
| DOCS: https://spacy.io/api/pipe#use_params
|
| ----------------------------------------------------------------------
| Static methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __new__(*args, **kwargs) class method of spacy.pipeline.trainable_pipe.TrainablePipe
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| cfg
| cfg: object
|
| is_resizable
| TrainablePipe.is_resizable: bool
|
| is_trainable
| TrainablePipe.is_trainable: bool
|
| model
| model: object
|
| scorer
| scorer: object
|
| vocab
| vocab: spacy.vocab.Vocab
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.pipe.Pipe:
|
| get_error_handler(self) -> 'Callable'
| Pipe.get_error_handler(self) -> Callable
|
| Retrieve the error handler function.
|
| RETURNS (Callable): The error handler, or if it's not set a default function that just reraises.
|
| DOCS: https://spacy.io/api/pipe#get_error_handler
|
| score(self, examples: 'Iterable[Example]', **kwargs) -> 'Dict[str, Union[float, Dict[str, float]]]'
| Pipe.score(self, examples: Iterable[Example], **kwargs) -> Dict[str, Union[float, Dict[str, float]]]
|
| Score a batch of examples.
|
| examples (Iterable[Example]): The examples to score.
| RETURNS (Dict[str, Any]): The scores.
|
| DOCS: https://spacy.io/api/pipe#score
|
| set_error_handler(self, error_handler: 'Callable') -> 'None'
| Pipe.set_error_handler(self, error_handler: Callable) -> None
|
| Set an error handler function.
|
| error_handler (Callable[[str, Callable[[Doc], Doc], List[Doc], Exception], None]):
| Function that deals with a failing batch of documents. This callable function should take in
| the component's name, the component itself, the offending batch of documents, and the exception
| that was thrown.
|
| DOCS: https://spacy.io/api/pipe#set_error_handler
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.pipe.Pipe:
|
| hide_labels
| Pipe.hide_labels: bool
|
| name
| name: str
class SpanFinder(spacy.pipeline.trainable_pipe.TrainablePipe)
| SpanFinder(nlp: spacy.language.Language, model: thinc.model.Model[typing.Iterable[spacy.tokens.doc.Doc], thinc.types.Floats2d], name: str = 'span_finder', *, spans_key: str = 'sc', threshold: float = 0.5, max_length: Optional[int] = None, min_length: Optional[int] = None, scorer: Optional[Callable] = <function span_finder_score at 0x0000022154BAA980>) -> None
|
| Pipeline that learns span boundaries.
|
| DOCS: https://spacy.io/api/spanfinder
|
| Method resolution order:
| SpanFinder
| spacy.pipeline.trainable_pipe.TrainablePipe
| spacy.pipeline.pipe.Pipe
| builtins.object
|
| Methods defined here:
|
| __init__(self, nlp: spacy.language.Language, model: thinc.model.Model[typing.Iterable[spacy.tokens.doc.Doc], thinc.types.Floats2d], name: str = 'span_finder', *, spans_key: str = 'sc', threshold: float = 0.5, max_length: Optional[int] = None, min_length: Optional[int] = None, scorer: Optional[Callable] = <function span_finder_score at 0x0000022154BAA980>) -> None
| Initialize the span finder.
| model (thinc.api.Model): The Thinc Model powering the pipeline
| component.
| name (str): The component instance name, used to add entries to the
| losses during training.
| threshold (float): Minimum probability to consider a prediction
| positive.
| scorer (Optional[Callable]): The scoring method.
| spans_key (str): Key of the doc.spans dict to save the spans under.
| During initialization and training, the component will look for
| spans on the reference document under the same key.
| max_length (Optional[int]): Maximum length of the produced spans,
| defaults to None meaning unlimited length.
| min_length (Optional[int]): Minimum length of the produced spans,
| defaults to None meaning shortest span length is 1.
|
| DOCS: https://spacy.io/api/spanfinder#init
|
| get_loss(self, examples, scores) -> Tuple[float, thinc.types.Floats2d]
| Find the loss and gradient of loss for the batch of documents and
| their predicted scores.
| examples (Iterable[Examples]): The batch of examples.
| scores: Scores representing the model's predictions.
| RETURNS (Tuple[float, Floats2d]): The loss and the gradient.
|
| DOCS: https://spacy.io/api/spanfinder#get_loss
|
| initialize(self, get_examples: Callable[[], Iterable[spacy.training.example.Example]], *, nlp: Optional[spacy.language.Language] = None) -> None
| Initialize the pipe for training, using a representative set
| of data examples.
| get_examples (Callable[[], Iterable[Example]]): Function that
| returns a representative sample of gold-standard Example objects.
| nlp (Optional[Language]): The current nlp object the component is part
| of.
|
| DOCS: https://spacy.io/api/spanfinder#initialize
|
| predict(self, docs: Iterable[spacy.tokens.doc.Doc])
| Apply the pipeline's model to a batch of docs, without modifying
| them.
|
| docs (Iterable[Doc]): The documents to predict.
| RETURNS: The models prediction for each document.
|
| DOCS: https://spacy.io/api/spanfinder#predict
|
| set_annotations(self, docs: Iterable[spacy.tokens.doc.Doc], scores: thinc.types.Floats2d) -> None
| Modify a batch of Doc objects, using pre-computed scores.
| docs (Iterable[Doc]): The documents to modify.
| scores: The scores to set, produced by SpanFinder predict method.
|
| DOCS: https://spacy.io/api/spanfinder#set_annotations
|
| update(self, examples: Iterable[spacy.training.example.Example], *, drop: float = 0.0, sgd: Optional[thinc.optimizers.Optimizer] = None, losses: Optional[Dict[str, float]] = None) -> Dict[str, float]
| Learn from a batch of documents and gold-standard information,
| updating the pipe's model. Delegates to predict and get_loss.
| examples (Iterable[Example]): A batch of Example objects.
| drop (float): The dropout rate.
| sgd (Optional[thinc.api.Optimizer]): The optimizer.
| losses (Optional[Dict[str, float]]): Optional record of the loss during
| training. Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/spanfinder#update
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __call__(...)
| TrainablePipe.__call__(self, Doc doc) -> Doc
|
| Apply the pipe to one document. The document is modified in place,
| and returned. This usually happens under the hood when the nlp object
| is called on a text and all components are applied to the Doc.
|
| docs (Doc): The Doc to process.
| RETURNS (Doc): The processed Doc.
|
| DOCS: https://spacy.io/api/pipe#call
|
| __reduce__ = __reduce_cython__(...)
| TrainablePipe.__reduce_cython__(self)
|
| __reduce_cython__(self)
| TrainablePipe.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| add_label(self, label: 'str') -> 'int'
| TrainablePipe.add_label(self, label: str) -> int
|
| Add an output label.
| For TrainablePipe components, it is possible to
| extend pretrained models with new labels, but care should be taken to
| avoid the "catastrophic forgetting" problem.
|
| label (str): The label to add.
| RETURNS (int): 0 if label is already present, otherwise 1.
|
| DOCS: https://spacy.io/api/pipe#add_label
|
| create_optimizer(self) -> 'Optimizer'
| TrainablePipe.create_optimizer(self) -> Optimizer
|
| Create an optimizer for the pipeline component.
|
| RETURNS (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#create_optimizer
|
| finish_update(self, sgd: 'Optimizer') -> 'None'
| TrainablePipe.finish_update(self, sgd: Optimizer) -> None
|
| Update parameters using the current parameter gradients.
| The Optimizer instance contains the functionality to perform
| the stochastic gradient descent.
|
| sgd (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#finish_update
|
| from_bytes(self, bytes_data, *, exclude=())
| TrainablePipe.from_bytes(self, bytes_data, *, exclude=tuple())
|
| Load the pipe from a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (TrainablePipe): The loaded object.
|
| DOCS: https://spacy.io/api/pipe#from_bytes
|
| from_disk(self, path, *, exclude=())
| TrainablePipe.from_disk(self, path, *, exclude=tuple())
|
| Load the pipe from disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (TrainablePipe): The loaded object.
|
| DOCS: https://spacy.io/api/pipe#from_disk
|
| pipe(self, stream: 'Iterable[Doc]', *, batch_size: 'int' = 128) -> 'Iterator[Doc]'
| TrainablePipe.pipe(self, stream: Iterable[Doc], *, batch_size: int = 128) -> Iterator[Doc]
|
| Apply the pipe to a stream of documents. This usually happens under
| the hood when the nlp object is called on a text and all components are
| applied to the Doc.
|
| stream (Iterable[Doc]): A stream of documents.
| batch_size (int): The number of documents to buffer.
| error_handler (Callable[[str, List[Doc], Exception], Any]): Function that
| deals with a failing batch of documents. The default function just reraises
| the exception.
| YIELDS (Doc): Processed documents in order.
|
| DOCS: https://spacy.io/api/pipe#pipe
|
| rehearse(self, examples: 'Iterable[Example]', *, sgd: 'Optimizer' = None, losses: 'Dict[str, float]' = None, **config) -> 'Dict[str, float]'
| TrainablePipe.rehearse(self, examples: Iterable[Example], *, sgd: Optimizer = None, losses: Dict[str, float] = None, **config) -> Dict[str, float]
|
| Perform a "rehearsal" update from a batch of data. Rehearsal updates
| teach the current model to make predictions similar to an initial model,
| to try to address the "catastrophic forgetting" problem. This feature is
| experimental.
|
| examples (Iterable[Example]): A batch of Example objects.
| sgd (thinc.api.Optimizer): The optimizer.
| losses (Dict[str, float]): Optional record of the loss during training.
| Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/pipe#rehearse
|
| set_output(self, nO: 'int') -> 'None'
| TrainablePipe.set_output(self, nO: int) -> None
|
| to_bytes(self, *, exclude=())
| TrainablePipe.to_bytes(self, *, exclude=tuple())
|
| Serialize the pipe to a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (bytes): The serialized object.
|
| DOCS: https://spacy.io/api/pipe#to_bytes
|
| to_disk(self, path, *, exclude=())
| TrainablePipe.to_disk(self, path, *, exclude=tuple())
|
| Serialize the pipe to disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
|
| DOCS: https://spacy.io/api/pipe#to_disk
|
| use_params(self, params: 'dict')
| TrainablePipe.use_params(self, params: dict)
|
| Modify the pipe's model, to use the given parameter values. At the
| end of the context, the original parameters are restored.
|
| params (dict): The parameter values to use in the model.
|
| DOCS: https://spacy.io/api/pipe#use_params
|
| ----------------------------------------------------------------------
| Static methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __new__(*args, **kwargs) class method of spacy.pipeline.trainable_pipe.TrainablePipe
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| cfg
| cfg: object
|
| is_resizable
| TrainablePipe.is_resizable: bool
|
| is_trainable
| TrainablePipe.is_trainable: bool
|
| model
| model: object
|
| scorer
| scorer: object
|
| vocab
| vocab: spacy.vocab.Vocab
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.pipe.Pipe:
|
| get_error_handler(self) -> 'Callable'
| Pipe.get_error_handler(self) -> Callable
|
| Retrieve the error handler function.
|
| RETURNS (Callable): The error handler, or if it's not set a default function that just reraises.
|
| DOCS: https://spacy.io/api/pipe#get_error_handler
|
| score(self, examples: 'Iterable[Example]', **kwargs) -> 'Dict[str, Union[float, Dict[str, float]]]'
| Pipe.score(self, examples: Iterable[Example], **kwargs) -> Dict[str, Union[float, Dict[str, float]]]
|
| Score a batch of examples.
|
| examples (Iterable[Example]): The examples to score.
| RETURNS (Dict[str, Any]): The scores.
|
| DOCS: https://spacy.io/api/pipe#score
|
| set_error_handler(self, error_handler: 'Callable') -> 'None'
| Pipe.set_error_handler(self, error_handler: Callable) -> None
|
| Set an error handler function.
|
| error_handler (Callable[[str, Callable[[Doc], Doc], List[Doc], Exception], None]):
| Function that deals with a failing batch of documents. This callable function should take in
| the component's name, the component itself, the offending batch of documents, and the exception
| that was thrown.
|
| DOCS: https://spacy.io/api/pipe#set_error_handler
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.pipe.Pipe:
|
| hide_labels
| Pipe.hide_labels: bool
|
| label_data
| Optional JSON-serializable data that would be sufficient to recreate
| the label set if provided to the `pipe.initialize()` method.
|
| labels
| Pipe.labels: Tuple[str, ...]
|
| name
| name: str
class SpanRuler(spacy.pipeline.pipe.Pipe)
| SpanRuler(nlp: spacy.language.Language, name: str = 'span_ruler', *, spans_key: Optional[str] = 'ruler', spans_filter: Optional[Callable[[Iterable[spacy.tokens.span.Span], Iterable[spacy.tokens.span.Span]], Iterable[spacy.tokens.span.Span]]] = None, annotate_ents: bool = False, ents_filter: Callable[[Iterable[spacy.tokens.span.Span], Iterable[spacy.tokens.span.Span]], Iterable[spacy.tokens.span.Span]] = <function filter_chain_spans at 0x000002215463A8E0>, phrase_matcher_attr: Union[str, int, NoneType] = None, matcher_fuzzy_compare: Callable = <cyfunction levenshtein_compare at 0x0000022154907380>, validate: bool = False, overwrite: bool = False, scorer: Optional[Callable] = functools.partial(<function overlapping_labeled_spans_score at 0x0000022154CA8AE0>, spans_key='ruler')) -> None
|
| The SpanRuler lets you add spans to the `Doc.spans` using token-based
| rules or exact phrase matches.
|
| DOCS: https://spacy.io/api/spanruler
| USAGE: https://spacy.io/usage/rule-based-matching#spanruler
|
| Method resolution order:
| SpanRuler
| spacy.pipeline.pipe.Pipe
| builtins.object
|
| Methods defined here:
|
| __call__(self, doc: spacy.tokens.doc.Doc) -> spacy.tokens.doc.Doc
| Find matches in document and add them as entities.
|
| doc (Doc): The Doc object in the pipeline.
| RETURNS (Doc): The Doc with added entities, if available.
|
| DOCS: https://spacy.io/api/spanruler#call
|
| __contains__(self, label: str) -> bool
| Whether a label is present in the patterns.
|
| __init__(self, nlp: spacy.language.Language, name: str = 'span_ruler', *, spans_key: Optional[str] = 'ruler', spans_filter: Optional[Callable[[Iterable[spacy.tokens.span.Span], Iterable[spacy.tokens.span.Span]], Iterable[spacy.tokens.span.Span]]] = None, annotate_ents: bool = False, ents_filter: Callable[[Iterable[spacy.tokens.span.Span], Iterable[spacy.tokens.span.Span]], Iterable[spacy.tokens.span.Span]] = <function filter_chain_spans at 0x000002215463A8E0>, phrase_matcher_attr: Union[str, int, NoneType] = None, matcher_fuzzy_compare: Callable = <cyfunction levenshtein_compare at 0x0000022154907380>, validate: bool = False, overwrite: bool = False, scorer: Optional[Callable] = functools.partial(<function overlapping_labeled_spans_score at 0x0000022154CA8AE0>, spans_key='ruler')) -> None
| Initialize the span ruler. If patterns are supplied here, they
| need to be a list of dictionaries with a `"label"` and `"pattern"`
| key. A pattern can either be a token pattern (list) or a phrase pattern
| (string). For example: `{'label': 'ORG', 'pattern': 'Apple'}`.
|
| nlp (Language): The shared nlp object to pass the vocab to the matchers
| and process phrase patterns.
| name (str): Instance name of the current pipeline component. Typically
| passed in automatically from the factory when the component is
| added. Used to disable the current span ruler while creating
| phrase patterns with the nlp object.
| spans_key (Optional[str]): The spans key to save the spans under. If
| `None`, no spans are saved. Defaults to "ruler".
| spans_filter (Optional[Callable[[Iterable[Span], Iterable[Span]], List[Span]]):
| The optional method to filter spans before they are assigned to
| doc.spans. Defaults to `None`.
| annotate_ents (bool): Whether to save spans to doc.ents. Defaults to
| `False`.
| ents_filter (Callable[[Iterable[Span], Iterable[Span]], List[Span]]):
| The method to filter spans before they are assigned to doc.ents.
| Defaults to `util.filter_chain_spans`.
| phrase_matcher_attr (Optional[Union[int, str]]): Token attribute to
| match on, passed to the internal PhraseMatcher as `attr`. Defaults
| to `None`.
| matcher_fuzzy_compare (Callable): The fuzzy comparison method for the
| internal Matcher. Defaults to
| spacy.matcher.levenshtein.levenshtein_compare.
| validate (bool): Whether patterns should be validated, passed to
| Matcher and PhraseMatcher as `validate`.
| overwrite (bool): Whether to remove any existing spans under this spans
| key if `spans_key` is set, and/or to remove any ents under `doc.ents` if
| `annotate_ents` is set. Defaults to `True`.
| scorer (Optional[Callable]): The scoring method. Defaults to
| spacy.pipeline.span_ruler.overlapping_labeled_spans_score.
|
| DOCS: https://spacy.io/api/spanruler#init
|
| __len__(self) -> int
| The number of all labels added to the span ruler.
|
| add_patterns(self, patterns: List[Dict[str, Union[str, List[Dict[str, Any]]]]]) -> None
| Add patterns to the span ruler. A pattern can either be a token
| pattern (list of dicts) or a phrase pattern (string). For example:
| {'label': 'ORG', 'pattern': 'Apple'}
| {'label': 'ORG', 'pattern': 'Apple', 'id': 'apple'}
| {'label': 'GPE', 'pattern': [{'lower': 'san'}, {'lower': 'francisco'}]}
|
| patterns (list): The patterns to add.
|
| DOCS: https://spacy.io/api/spanruler#add_patterns
|
| clear(self) -> None
| Reset all patterns.
|
| RETURNS: None
| DOCS: https://spacy.io/api/spanruler#clear
|
| from_bytes(self, bytes_data: bytes, *, exclude: Iterable[str] = []) -> 'SpanRuler'
| Load the span ruler from a bytestring.
|
| bytes_data (bytes): The bytestring to load.
| RETURNS (SpanRuler): The loaded span ruler.
|
| DOCS: https://spacy.io/api/spanruler#from_bytes
|
| from_disk(self, path: Union[str, pathlib.Path], *, exclude: Iterable[str] = []) -> 'SpanRuler'
| Load the span ruler from a directory.
|
| path (Union[str, Path]): A path to a directory.
| RETURNS (SpanRuler): The loaded span ruler.
|
| DOCS: https://spacy.io/api/spanruler#from_disk
|
| initialize(self, get_examples: Callable[[], Iterable[spacy.training.example.Example]], *, nlp: Optional[spacy.language.Language] = None, patterns: Optional[Sequence[Dict[str, Union[str, List[Dict[str, Any]]]]]] = None)
| Initialize the pipe for training.
|
| get_examples (Callable[[], Iterable[Example]]): Function that
| returns a representative sample of gold-standard Example objects.
| nlp (Language): The current nlp object the component is part of.
| patterns (Optional[Iterable[PatternType]]): The list of patterns.
|
| DOCS: https://spacy.io/api/spanruler#initialize
|
| match(self, doc: spacy.tokens.doc.Doc)
|
| remove(self, label: str) -> None
| Remove a pattern by its label.
|
| label (str): Label of the pattern to be removed.
| RETURNS: None
| DOCS: https://spacy.io/api/spanruler#remove
|
| remove_by_id(self, pattern_id: str) -> None
| Remove a pattern by its pattern ID.
|
| pattern_id (str): ID of the pattern to be removed.
| RETURNS: None
| DOCS: https://spacy.io/api/spanruler#remove_by_id
|
| set_annotations(self, doc, matches)
| Modify the document in place
|
| to_bytes(self, *, exclude: Iterable[str] = []) -> bytes
| Serialize the span ruler to a bytestring.
|
| RETURNS (bytes): The serialized patterns.
|
| DOCS: https://spacy.io/api/spanruler#to_bytes
|
| to_disk(self, path: Union[str, pathlib.Path], *, exclude: Iterable[str] = []) -> None
| Save the span ruler patterns to a directory.
|
| path (Union[str, Path]): A path to a directory.
|
| DOCS: https://spacy.io/api/spanruler#to_disk
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| ids
| All IDs present in the match patterns.
|
| RETURNS (set): The string IDs.
|
| DOCS: https://spacy.io/api/spanruler#ids
|
| key
| Key of the doc.spans dict to save the spans under.
|
| labels
| All labels present in the match patterns.
|
| RETURNS (set): The string labels.
|
| DOCS: https://spacy.io/api/spanruler#labels
|
| patterns
| Get all patterns that were added to the span ruler.
|
| RETURNS (list): The original patterns, one dictionary per pattern.
|
| DOCS: https://spacy.io/api/spanruler#patterns
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.pipe.Pipe:
|
| __reduce__ = __reduce_cython__(...)
| Pipe.__reduce_cython__(self)
|
| __reduce_cython__(self)
| Pipe.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| Pipe.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| Pipe.__setstate_cython__(self, __pyx_state)
|
| get_error_handler(self) -> 'Callable'
| Pipe.get_error_handler(self) -> Callable
|
| Retrieve the error handler function.
|
| RETURNS (Callable): The error handler, or if it's not set a default function that just reraises.
|
| DOCS: https://spacy.io/api/pipe#get_error_handler
|
| pipe(self, stream: 'Iterable[Doc]', *, batch_size: 'int' = 128) -> 'Iterator[Doc]'
| Pipe.pipe(self, stream: Iterable[Doc], *, batch_size: int = 128) -> Iterator[Doc]
|
| Apply the pipe to a stream of documents. This usually happens under
| the hood when the nlp object is called on a text and all components are
| applied to the Doc.
|
| stream (Iterable[Doc]): A stream of documents.
| batch_size (int): The number of documents to buffer.
| YIELDS (Doc): Processed documents in order.
|
| DOCS: https://spacy.io/api/pipe#pipe
|
| score(self, examples: 'Iterable[Example]', **kwargs) -> 'Dict[str, Union[float, Dict[str, float]]]'
| Pipe.score(self, examples: Iterable[Example], **kwargs) -> Dict[str, Union[float, Dict[str, float]]]
|
| Score a batch of examples.
|
| examples (Iterable[Example]): The examples to score.
| RETURNS (Dict[str, Any]): The scores.
|
| DOCS: https://spacy.io/api/pipe#score
|
| set_error_handler(self, error_handler: 'Callable') -> 'None'
| Pipe.set_error_handler(self, error_handler: Callable) -> None
|
| Set an error handler function.
|
| error_handler (Callable[[str, Callable[[Doc], Doc], List[Doc], Exception], None]):
| Function that deals with a failing batch of documents. This callable function should take in
| the component's name, the component itself, the offending batch of documents, and the exception
| that was thrown.
|
| DOCS: https://spacy.io/api/pipe#set_error_handler
|
| ----------------------------------------------------------------------
| Static methods inherited from spacy.pipeline.pipe.Pipe:
|
| __new__(*args, **kwargs) class method of spacy.pipeline.pipe.Pipe
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.pipe.Pipe:
|
| hide_labels
| Pipe.hide_labels: bool
|
| is_trainable
| Pipe.is_trainable: bool
|
| label_data
| Optional JSON-serializable data that would be sufficient to recreate
| the label set if provided to the `pipe.initialize()` method.
|
| name
| name: str
class Tagger(spacy.pipeline.trainable_pipe.TrainablePipe)
| Tagger(vocab, model, name='tagger', *, overwrite=False, scorer=<cyfunction tagger_score at 0x0000022154B835F0>, neg_prefix='!', label_smoothing=0.0)
|
| Pipeline component for part-of-speech tagging.
|
| DOCS: https://spacy.io/api/tagger
|
| Method resolution order:
| Tagger
| spacy.pipeline.trainable_pipe.TrainablePipe
| spacy.pipeline.pipe.Pipe
| builtins.object
|
| Methods defined here:
|
| __init__(self, vocab, model, name='tagger', *, overwrite=False, scorer=<cyfunction tagger_score at 0x0000022154B835F0>, neg_prefix='!', label_smoothing=0.0)
| Tagger.__init__(self, vocab, model, name='tagger', *, overwrite=BACKWARD_OVERWRITE, scorer=tagger_score, neg_prefix='!', label_smoothing=0.0)
|
| Initialize a part-of-speech tagger.
|
| vocab (Vocab): The shared vocabulary.
| model (thinc.api.Model): The Thinc Model powering the pipeline component.
| name (str): The component instance name, used to add entries to the
| losses during training.
| scorer (Optional[Callable]): The scoring method. Defaults to
| Scorer.score_token_attr for the attribute "tag".
|
| DOCS: https://spacy.io/api/tagger#init
|
| add_label(self, label)
| Tagger.add_label(self, label)
|
| Add a new label to the pipe.
|
| label (str): The label to add.
| RETURNS (int): 0 if label is already present, otherwise 1.
|
| DOCS: https://spacy.io/api/tagger#add_label
|
| get_loss(self, examples, scores)
| Tagger.get_loss(self, examples, scores)
|
| Find the loss and gradient of loss for the batch of documents and
| their predicted scores.
|
| examples (Iterable[Examples]): The batch of examples.
| scores: Scores representing the model's predictions.
| RETURNS (Tuple[float, float]): The loss and the gradient.
|
| DOCS: https://spacy.io/api/tagger#get_loss
|
| initialize(self, get_examples, *, nlp=None, labels=None)
| Tagger.initialize(self, get_examples, *, nlp=None, labels=None)
|
| Initialize the pipe for training, using a representative set
| of data examples.
|
| get_examples (Callable[[], Iterable[Example]]): Function that
| returns a representative sample of gold-standard Example objects..
| nlp (Language): The current nlp object the component is part of.
| labels: The labels to add to the component, typically generated by the
| `init labels` command. If no labels are provided, the get_examples
| callback is used to extract the labels from the data.
|
| DOCS: https://spacy.io/api/tagger#initialize
|
| predict(self, docs)
| Tagger.predict(self, docs)
|
| Apply the pipeline's model to a batch of docs, without modifying them.
|
| docs (Iterable[Doc]): The documents to predict.
| RETURNS: The models prediction for each document.
|
| DOCS: https://spacy.io/api/tagger#predict
|
| rehearse(self, examples, *, drop=0.0, sgd=None, losses=None)
| Tagger.rehearse(self, examples, *, drop=0., sgd=None, losses=None)
|
| Perform a "rehearsal" update from a batch of data. Rehearsal updates
| teach the current model to make predictions similar to an initial model,
| to try to address the "catastrophic forgetting" problem. This feature is
| experimental.
|
| examples (Iterable[Example]): A batch of Example objects.
| drop (float): The dropout rate.
| sgd (thinc.api.Optimizer): The optimizer.
| losses (Dict[str, float]): Optional record of the loss during training.
| Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/tagger#rehearse
|
| set_annotations(self, docs, batch_tag_ids)
| Tagger.set_annotations(self, docs, batch_tag_ids)
|
| Modify a batch of documents, using pre-computed scores.
|
| docs (Iterable[Doc]): The documents to modify.
| batch_tag_ids: The IDs to set, produced by Tagger.predict.
|
| DOCS: https://spacy.io/api/tagger#set_annotations
|
| update(self, examples, *, drop=0.0, sgd=None, losses=None)
| Tagger.update(self, examples, *, drop=0., sgd=None, losses=None)
|
| Learn from a batch of documents and gold-standard information,
| updating the pipe's model. Delegates to predict and get_loss.
|
| examples (Iterable[Example]): A batch of Example objects.
| drop (float): The dropout rate.
| sgd (thinc.api.Optimizer): The optimizer.
| losses (Dict[str, float]): Optional record of the loss during training.
| Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/tagger#update
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| label_data
| Tagger.label_data(self)
|
| Data about the labels currently added to the component.
|
| labels
| Tagger.labels(self)
|
| The labels currently added to the component. Note that even for a
| blank component, this will always include the built-in coarse-grained
| part-of-speech tags by default.
|
| RETURNS (Tuple[str]): The labels.
|
| DOCS: https://spacy.io/api/tagger#labels
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __call__(...)
| TrainablePipe.__call__(self, Doc doc) -> Doc
|
| Apply the pipe to one document. The document is modified in place,
| and returned. This usually happens under the hood when the nlp object
| is called on a text and all components are applied to the Doc.
|
| docs (Doc): The Doc to process.
| RETURNS (Doc): The processed Doc.
|
| DOCS: https://spacy.io/api/pipe#call
|
| __reduce__ = __reduce_cython__(...)
| TrainablePipe.__reduce_cython__(self)
|
| __reduce_cython__(self)
| TrainablePipe.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| create_optimizer(self) -> 'Optimizer'
| TrainablePipe.create_optimizer(self) -> Optimizer
|
| Create an optimizer for the pipeline component.
|
| RETURNS (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#create_optimizer
|
| finish_update(self, sgd: 'Optimizer') -> 'None'
| TrainablePipe.finish_update(self, sgd: Optimizer) -> None
|
| Update parameters using the current parameter gradients.
| The Optimizer instance contains the functionality to perform
| the stochastic gradient descent.
|
| sgd (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#finish_update
|
| from_bytes(self, bytes_data, *, exclude=())
| TrainablePipe.from_bytes(self, bytes_data, *, exclude=tuple())
|
| Load the pipe from a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (TrainablePipe): The loaded object.
|
| DOCS: https://spacy.io/api/pipe#from_bytes
|
| from_disk(self, path, *, exclude=())
| TrainablePipe.from_disk(self, path, *, exclude=tuple())
|
| Load the pipe from disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (TrainablePipe): The loaded object.
|
| DOCS: https://spacy.io/api/pipe#from_disk
|
| pipe(self, stream: 'Iterable[Doc]', *, batch_size: 'int' = 128) -> 'Iterator[Doc]'
| TrainablePipe.pipe(self, stream: Iterable[Doc], *, batch_size: int = 128) -> Iterator[Doc]
|
| Apply the pipe to a stream of documents. This usually happens under
| the hood when the nlp object is called on a text and all components are
| applied to the Doc.
|
| stream (Iterable[Doc]): A stream of documents.
| batch_size (int): The number of documents to buffer.
| error_handler (Callable[[str, List[Doc], Exception], Any]): Function that
| deals with a failing batch of documents. The default function just reraises
| the exception.
| YIELDS (Doc): Processed documents in order.
|
| DOCS: https://spacy.io/api/pipe#pipe
|
| set_output(self, nO: 'int') -> 'None'
| TrainablePipe.set_output(self, nO: int) -> None
|
| to_bytes(self, *, exclude=())
| TrainablePipe.to_bytes(self, *, exclude=tuple())
|
| Serialize the pipe to a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (bytes): The serialized object.
|
| DOCS: https://spacy.io/api/pipe#to_bytes
|
| to_disk(self, path, *, exclude=())
| TrainablePipe.to_disk(self, path, *, exclude=tuple())
|
| Serialize the pipe to disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
|
| DOCS: https://spacy.io/api/pipe#to_disk
|
| use_params(self, params: 'dict')
| TrainablePipe.use_params(self, params: dict)
|
| Modify the pipe's model, to use the given parameter values. At the
| end of the context, the original parameters are restored.
|
| params (dict): The parameter values to use in the model.
|
| DOCS: https://spacy.io/api/pipe#use_params
|
| ----------------------------------------------------------------------
| Static methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __new__(*args, **kwargs) class method of spacy.pipeline.trainable_pipe.TrainablePipe
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| cfg
| cfg: object
|
| is_resizable
| TrainablePipe.is_resizable: bool
|
| is_trainable
| TrainablePipe.is_trainable: bool
|
| model
| model: object
|
| scorer
| scorer: object
|
| vocab
| vocab: spacy.vocab.Vocab
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.pipe.Pipe:
|
| get_error_handler(self) -> 'Callable'
| Pipe.get_error_handler(self) -> Callable
|
| Retrieve the error handler function.
|
| RETURNS (Callable): The error handler, or if it's not set a default function that just reraises.
|
| DOCS: https://spacy.io/api/pipe#get_error_handler
|
| score(self, examples: 'Iterable[Example]', **kwargs) -> 'Dict[str, Union[float, Dict[str, float]]]'
| Pipe.score(self, examples: Iterable[Example], **kwargs) -> Dict[str, Union[float, Dict[str, float]]]
|
| Score a batch of examples.
|
| examples (Iterable[Example]): The examples to score.
| RETURNS (Dict[str, Any]): The scores.
|
| DOCS: https://spacy.io/api/pipe#score
|
| set_error_handler(self, error_handler: 'Callable') -> 'None'
| Pipe.set_error_handler(self, error_handler: Callable) -> None
|
| Set an error handler function.
|
| error_handler (Callable[[str, Callable[[Doc], Doc], List[Doc], Exception], None]):
| Function that deals with a failing batch of documents. This callable function should take in
| the component's name, the component itself, the offending batch of documents, and the exception
| that was thrown.
|
| DOCS: https://spacy.io/api/pipe#set_error_handler
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.pipe.Pipe:
|
| hide_labels
| Pipe.hide_labels: bool
|
| name
| name: str
class TextCategorizer(spacy.pipeline.trainable_pipe.TrainablePipe)
| TextCategorizer(vocab: spacy.vocab.Vocab, model: thinc.model.Model, name: str = 'textcat', *, threshold: float, scorer: Optional[Callable] = <function textcat_score at 0x0000022154CA9B20>) -> None
|
| Pipeline component for single-label text classification.
|
| DOCS: https://spacy.io/api/textcategorizer
|
| Method resolution order:
| TextCategorizer
| spacy.pipeline.trainable_pipe.TrainablePipe
| spacy.pipeline.pipe.Pipe
| builtins.object
|
| Methods defined here:
|
| __init__(self, vocab: spacy.vocab.Vocab, model: thinc.model.Model, name: str = 'textcat', *, threshold: float, scorer: Optional[Callable] = <function textcat_score at 0x0000022154CA9B20>) -> None
| Initialize a text categorizer for single-label classification.
|
| vocab (Vocab): The shared vocabulary.
| model (thinc.api.Model): The Thinc Model powering the pipeline component.
| name (str): The component instance name, used to add entries to the
| losses during training.
| threshold (float): Unused, not needed for single-label (exclusive
| classes) classification.
| scorer (Optional[Callable]): The scoring method. Defaults to
| Scorer.score_cats for the attribute "cats".
|
| DOCS: https://spacy.io/api/textcategorizer#init
|
| add_label(self, label: str) -> int
| Add a new label to the pipe.
|
| label (str): The label to add.
| RETURNS (int): 0 if label is already present, otherwise 1.
|
| DOCS: https://spacy.io/api/textcategorizer#add_label
|
| get_loss(self, examples: Iterable[spacy.training.example.Example], scores) -> Tuple[float, float]
| Find the loss and gradient of loss for the batch of documents and
| their predicted scores.
|
| examples (Iterable[Examples]): The batch of examples.
| scores: Scores representing the model's predictions.
| RETURNS (Tuple[float, float]): The loss and the gradient.
|
| DOCS: https://spacy.io/api/textcategorizer#get_loss
|
| initialize(self, get_examples: Callable[[], Iterable[spacy.training.example.Example]], *, nlp: Optional[spacy.language.Language] = None, labels: Optional[Iterable[str]] = None, positive_label: Optional[str] = None) -> None
| Initialize the pipe for training, using a representative set
| of data examples.
|
| get_examples (Callable[[], Iterable[Example]]): Function that
| returns a representative sample of gold-standard Example objects.
| nlp (Language): The current nlp object the component is part of.
| labels (Optional[Iterable[str]]): The labels to add to the component, typically generated by the
| `init labels` command. If no labels are provided, the get_examples
| callback is used to extract the labels from the data.
| positive_label (Optional[str]): The positive label for a binary task with exclusive classes,
| `None` otherwise and by default.
|
| DOCS: https://spacy.io/api/textcategorizer#initialize
|
| predict(self, docs: Iterable[spacy.tokens.doc.Doc])
| Apply the pipeline's model to a batch of docs, without modifying them.
|
| docs (Iterable[Doc]): The documents to predict.
| RETURNS: The models prediction for each document.
|
| DOCS: https://spacy.io/api/textcategorizer#predict
|
| rehearse(self, examples: Iterable[spacy.training.example.Example], *, drop: float = 0.0, sgd: Optional[thinc.optimizers.Optimizer] = None, losses: Optional[Dict[str, float]] = None) -> Dict[str, float]
| Perform a "rehearsal" update from a batch of data. Rehearsal updates
| teach the current model to make predictions similar to an initial model,
| to try to address the "catastrophic forgetting" problem. This feature is
| experimental.
|
| examples (Iterable[Example]): A batch of Example objects.
| drop (float): The dropout rate.
| sgd (thinc.api.Optimizer): The optimizer.
| losses (Dict[str, float]): Optional record of the loss during training.
| Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/textcategorizer#rehearse
|
| set_annotations(self, docs: Iterable[spacy.tokens.doc.Doc], scores) -> None
| Modify a batch of Doc objects, using pre-computed scores.
|
| docs (Iterable[Doc]): The documents to modify.
| scores: The scores to set, produced by TextCategorizer.predict.
|
| DOCS: https://spacy.io/api/textcategorizer#set_annotations
|
| update(self, examples: Iterable[spacy.training.example.Example], *, drop: float = 0.0, sgd: Optional[thinc.optimizers.Optimizer] = None, losses: Optional[Dict[str, float]] = None) -> Dict[str, float]
| Learn from a batch of documents and gold-standard information,
| updating the pipe's model. Delegates to predict and get_loss.
|
| examples (Iterable[Example]): A batch of Example objects.
| drop (float): The dropout rate.
| sgd (thinc.api.Optimizer): The optimizer.
| losses (Dict[str, float]): Optional record of the loss during training.
| Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/textcategorizer#update
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| label_data
| RETURNS (List[str]): Information about the component's labels.
|
| DOCS: https://spacy.io/api/textcategorizer#label_data
|
| labels
| RETURNS (Tuple[str]): The labels currently added to the component.
|
| DOCS: https://spacy.io/api/textcategorizer#labels
|
| support_missing_values
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __call__(...)
| TrainablePipe.__call__(self, Doc doc) -> Doc
|
| Apply the pipe to one document. The document is modified in place,
| and returned. This usually happens under the hood when the nlp object
| is called on a text and all components are applied to the Doc.
|
| docs (Doc): The Doc to process.
| RETURNS (Doc): The processed Doc.
|
| DOCS: https://spacy.io/api/pipe#call
|
| __reduce__ = __reduce_cython__(...)
| TrainablePipe.__reduce_cython__(self)
|
| __reduce_cython__(self)
| TrainablePipe.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| create_optimizer(self) -> 'Optimizer'
| TrainablePipe.create_optimizer(self) -> Optimizer
|
| Create an optimizer for the pipeline component.
|
| RETURNS (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#create_optimizer
|
| finish_update(self, sgd: 'Optimizer') -> 'None'
| TrainablePipe.finish_update(self, sgd: Optimizer) -> None
|
| Update parameters using the current parameter gradients.
| The Optimizer instance contains the functionality to perform
| the stochastic gradient descent.
|
| sgd (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#finish_update
|
| from_bytes(self, bytes_data, *, exclude=())
| TrainablePipe.from_bytes(self, bytes_data, *, exclude=tuple())
|
| Load the pipe from a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (TrainablePipe): The loaded object.
|
| DOCS: https://spacy.io/api/pipe#from_bytes
|
| from_disk(self, path, *, exclude=())
| TrainablePipe.from_disk(self, path, *, exclude=tuple())
|
| Load the pipe from disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (TrainablePipe): The loaded object.
|
| DOCS: https://spacy.io/api/pipe#from_disk
|
| pipe(self, stream: 'Iterable[Doc]', *, batch_size: 'int' = 128) -> 'Iterator[Doc]'
| TrainablePipe.pipe(self, stream: Iterable[Doc], *, batch_size: int = 128) -> Iterator[Doc]
|
| Apply the pipe to a stream of documents. This usually happens under
| the hood when the nlp object is called on a text and all components are
| applied to the Doc.
|
| stream (Iterable[Doc]): A stream of documents.
| batch_size (int): The number of documents to buffer.
| error_handler (Callable[[str, List[Doc], Exception], Any]): Function that
| deals with a failing batch of documents. The default function just reraises
| the exception.
| YIELDS (Doc): Processed documents in order.
|
| DOCS: https://spacy.io/api/pipe#pipe
|
| set_output(self, nO: 'int') -> 'None'
| TrainablePipe.set_output(self, nO: int) -> None
|
| to_bytes(self, *, exclude=())
| TrainablePipe.to_bytes(self, *, exclude=tuple())
|
| Serialize the pipe to a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (bytes): The serialized object.
|
| DOCS: https://spacy.io/api/pipe#to_bytes
|
| to_disk(self, path, *, exclude=())
| TrainablePipe.to_disk(self, path, *, exclude=tuple())
|
| Serialize the pipe to disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
|
| DOCS: https://spacy.io/api/pipe#to_disk
|
| use_params(self, params: 'dict')
| TrainablePipe.use_params(self, params: dict)
|
| Modify the pipe's model, to use the given parameter values. At the
| end of the context, the original parameters are restored.
|
| params (dict): The parameter values to use in the model.
|
| DOCS: https://spacy.io/api/pipe#use_params
|
| ----------------------------------------------------------------------
| Static methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __new__(*args, **kwargs) class method of spacy.pipeline.trainable_pipe.TrainablePipe
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| cfg
| cfg: object
|
| is_resizable
| TrainablePipe.is_resizable: bool
|
| is_trainable
| TrainablePipe.is_trainable: bool
|
| model
| model: object
|
| scorer
| scorer: object
|
| vocab
| vocab: spacy.vocab.Vocab
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.pipe.Pipe:
|
| get_error_handler(self) -> 'Callable'
| Pipe.get_error_handler(self) -> Callable
|
| Retrieve the error handler function.
|
| RETURNS (Callable): The error handler, or if it's not set a default function that just reraises.
|
| DOCS: https://spacy.io/api/pipe#get_error_handler
|
| score(self, examples: 'Iterable[Example]', **kwargs) -> 'Dict[str, Union[float, Dict[str, float]]]'
| Pipe.score(self, examples: Iterable[Example], **kwargs) -> Dict[str, Union[float, Dict[str, float]]]
|
| Score a batch of examples.
|
| examples (Iterable[Example]): The examples to score.
| RETURNS (Dict[str, Any]): The scores.
|
| DOCS: https://spacy.io/api/pipe#score
|
| set_error_handler(self, error_handler: 'Callable') -> 'None'
| Pipe.set_error_handler(self, error_handler: Callable) -> None
|
| Set an error handler function.
|
| error_handler (Callable[[str, Callable[[Doc], Doc], List[Doc], Exception], None]):
| Function that deals with a failing batch of documents. This callable function should take in
| the component's name, the component itself, the offending batch of documents, and the exception
| that was thrown.
|
| DOCS: https://spacy.io/api/pipe#set_error_handler
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.pipe.Pipe:
|
| hide_labels
| Pipe.hide_labels: bool
|
| name
| name: str
class Tok2Vec(spacy.pipeline.trainable_pipe.TrainablePipe)
| Tok2Vec(vocab: spacy.vocab.Vocab, model: thinc.model.Model, name: str = 'tok2vec') -> None
|
| Apply a "token-to-vector" model and set its outputs in the doc.tensor
| attribute. This is mostly useful to share a single subnetwork between multiple
| components, e.g. to have one embedding and CNN network shared between a
| parser, tagger and NER.
|
| In order to use the `Tok2Vec` predictions, subsequent components should use
| the `Tok2VecListener` layer as the tok2vec subnetwork of their model. This
| layer will read data from the `doc.tensor` attribute during prediction.
| During training, the `Tok2Vec` component will save its prediction and backprop
| callback for each batch, so that the subsequent components can backpropagate
| to the shared weights. This implementation is used because it allows us to
| avoid relying on object identity within the models to achieve the parameter
| sharing.
|
| Method resolution order:
| Tok2Vec
| spacy.pipeline.trainable_pipe.TrainablePipe
| spacy.pipeline.pipe.Pipe
| builtins.object
|
| Methods defined here:
|
| __init__(self, vocab: spacy.vocab.Vocab, model: thinc.model.Model, name: str = 'tok2vec') -> None
| Initialize a tok2vec component.
|
| vocab (Vocab): The shared vocabulary.
| model (thinc.api.Model[List[Doc], List[Floats2d]]):
| The Thinc Model powering the pipeline component. It should take
| a list of Doc objects as input, and output a list of 2d float arrays.
| name (str): The component instance name.
|
| DOCS: https://spacy.io/api/tok2vec#init
|
| add_label(self, label)
| TrainablePipe.add_label(self, label: str) -> int
|
| Add an output label.
| For TrainablePipe components, it is possible to
| extend pretrained models with new labels, but care should be taken to
| avoid the "catastrophic forgetting" problem.
|
| label (str): The label to add.
| RETURNS (int): 0 if label is already present, otherwise 1.
|
| DOCS: https://spacy.io/api/pipe#add_label
|
| add_listener(self, listener: 'Tok2VecListener', component_name: str) -> None
| Add a listener for a downstream component. Usually internals.
|
| find_listeners(self, component) -> None
| Walk over a model of a processing component, looking for layers that
| are Tok2vecListener subclasses that have an upstream_name that matches
| this component. Listeners can also set their upstream_name attribute to
| the wildcard string '*' to match any `Tok2Vec`.
|
| You're unlikely to ever need multiple `Tok2Vec` components, so it's
| fine to leave your listeners upstream_name on '*'.
|
| get_loss(self, examples, scores) -> None
| TrainablePipe.get_loss(self, examples: Iterable[Example], scores) -> Tuple[float, float]
|
| Find the loss and gradient of loss for the batch of documents and
| their predicted scores.
|
| examples (Iterable[Examples]): The batch of examples.
| scores: Scores representing the model's predictions.
| RETURNS (Tuple[float, float]): The loss and the gradient.
|
| DOCS: https://spacy.io/api/pipe#get_loss
|
| initialize(self, get_examples: Callable[[], Iterable[spacy.training.example.Example]], *, nlp: Optional[spacy.language.Language] = None)
| Initialize the pipe for training, using a representative set
| of data examples.
|
| get_examples (Callable[[], Iterable[Example]]): Function that
| returns a representative sample of gold-standard Example objects.
| nlp (Language): The current nlp object the component is part of.
|
| DOCS: https://spacy.io/api/tok2vec#initialize
|
| predict(self, docs: Iterable[spacy.tokens.doc.Doc])
| Apply the pipeline's model to a batch of docs, without modifying them.
| Returns a single tensor for a batch of documents.
|
| docs (Iterable[Doc]): The documents to predict.
| RETURNS: Vector representations for each token in the documents.
|
| DOCS: https://spacy.io/api/tok2vec#predict
|
| remove_listener(self, listener: 'Tok2VecListener', component_name: str) -> bool
| Remove a listener for a downstream component. Usually internals.
|
| set_annotations(self, docs: Sequence[spacy.tokens.doc.Doc], tokvecses) -> None
| Modify a batch of documents, using pre-computed scores.
|
| docs (Iterable[Doc]): The documents to modify.
| tokvecses: The tensors to set, produced by Tok2Vec.predict.
|
| DOCS: https://spacy.io/api/tok2vec#set_annotations
|
| update(self, examples: Iterable[spacy.training.example.Example], *, drop: float = 0.0, sgd: Optional[thinc.optimizers.Optimizer] = None, losses: Optional[Dict[str, float]] = None)
| Learn from a batch of documents and gold-standard information,
| updating the pipe's model.
|
| examples (Iterable[Example]): A batch of Example objects.
| drop (float): The dropout rate.
| sgd (thinc.api.Optimizer): The optimizer.
| losses (Dict[str, float]): Optional record of the loss during training.
| Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/tok2vec#update
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| listeners
| RETURNS (List[Tok2VecListener]): The listener models listening to this
| component. Usually internals.
|
| listening_components
| RETURNS (List[str]): The downstream components listening to this
| component. Usually internals.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __call__(...)
| TrainablePipe.__call__(self, Doc doc) -> Doc
|
| Apply the pipe to one document. The document is modified in place,
| and returned. This usually happens under the hood when the nlp object
| is called on a text and all components are applied to the Doc.
|
| docs (Doc): The Doc to process.
| RETURNS (Doc): The processed Doc.
|
| DOCS: https://spacy.io/api/pipe#call
|
| __reduce__ = __reduce_cython__(...)
| TrainablePipe.__reduce_cython__(self)
|
| __reduce_cython__(self)
| TrainablePipe.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| create_optimizer(self) -> 'Optimizer'
| TrainablePipe.create_optimizer(self) -> Optimizer
|
| Create an optimizer for the pipeline component.
|
| RETURNS (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#create_optimizer
|
| finish_update(self, sgd: 'Optimizer') -> 'None'
| TrainablePipe.finish_update(self, sgd: Optimizer) -> None
|
| Update parameters using the current parameter gradients.
| The Optimizer instance contains the functionality to perform
| the stochastic gradient descent.
|
| sgd (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#finish_update
|
| from_bytes(self, bytes_data, *, exclude=())
| TrainablePipe.from_bytes(self, bytes_data, *, exclude=tuple())
|
| Load the pipe from a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (TrainablePipe): The loaded object.
|
| DOCS: https://spacy.io/api/pipe#from_bytes
|
| from_disk(self, path, *, exclude=())
| TrainablePipe.from_disk(self, path, *, exclude=tuple())
|
| Load the pipe from disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (TrainablePipe): The loaded object.
|
| DOCS: https://spacy.io/api/pipe#from_disk
|
| pipe(self, stream: 'Iterable[Doc]', *, batch_size: 'int' = 128) -> 'Iterator[Doc]'
| TrainablePipe.pipe(self, stream: Iterable[Doc], *, batch_size: int = 128) -> Iterator[Doc]
|
| Apply the pipe to a stream of documents. This usually happens under
| the hood when the nlp object is called on a text and all components are
| applied to the Doc.
|
| stream (Iterable[Doc]): A stream of documents.
| batch_size (int): The number of documents to buffer.
| error_handler (Callable[[str, List[Doc], Exception], Any]): Function that
| deals with a failing batch of documents. The default function just reraises
| the exception.
| YIELDS (Doc): Processed documents in order.
|
| DOCS: https://spacy.io/api/pipe#pipe
|
| rehearse(self, examples: 'Iterable[Example]', *, sgd: 'Optimizer' = None, losses: 'Dict[str, float]' = None, **config) -> 'Dict[str, float]'
| TrainablePipe.rehearse(self, examples: Iterable[Example], *, sgd: Optimizer = None, losses: Dict[str, float] = None, **config) -> Dict[str, float]
|
| Perform a "rehearsal" update from a batch of data. Rehearsal updates
| teach the current model to make predictions similar to an initial model,
| to try to address the "catastrophic forgetting" problem. This feature is
| experimental.
|
| examples (Iterable[Example]): A batch of Example objects.
| sgd (thinc.api.Optimizer): The optimizer.
| losses (Dict[str, float]): Optional record of the loss during training.
| Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/pipe#rehearse
|
| set_output(self, nO: 'int') -> 'None'
| TrainablePipe.set_output(self, nO: int) -> None
|
| to_bytes(self, *, exclude=())
| TrainablePipe.to_bytes(self, *, exclude=tuple())
|
| Serialize the pipe to a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (bytes): The serialized object.
|
| DOCS: https://spacy.io/api/pipe#to_bytes
|
| to_disk(self, path, *, exclude=())
| TrainablePipe.to_disk(self, path, *, exclude=tuple())
|
| Serialize the pipe to disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
|
| DOCS: https://spacy.io/api/pipe#to_disk
|
| use_params(self, params: 'dict')
| TrainablePipe.use_params(self, params: dict)
|
| Modify the pipe's model, to use the given parameter values. At the
| end of the context, the original parameters are restored.
|
| params (dict): The parameter values to use in the model.
|
| DOCS: https://spacy.io/api/pipe#use_params
|
| ----------------------------------------------------------------------
| Static methods inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| __new__(*args, **kwargs) class method of spacy.pipeline.trainable_pipe.TrainablePipe
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.trainable_pipe.TrainablePipe:
|
| cfg
| cfg: object
|
| is_resizable
| TrainablePipe.is_resizable: bool
|
| is_trainable
| TrainablePipe.is_trainable: bool
|
| model
| model: object
|
| scorer
| scorer: object
|
| vocab
| vocab: spacy.vocab.Vocab
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.pipe.Pipe:
|
| get_error_handler(self) -> 'Callable'
| Pipe.get_error_handler(self) -> Callable
|
| Retrieve the error handler function.
|
| RETURNS (Callable): The error handler, or if it's not set a default function that just reraises.
|
| DOCS: https://spacy.io/api/pipe#get_error_handler
|
| score(self, examples: 'Iterable[Example]', **kwargs) -> 'Dict[str, Union[float, Dict[str, float]]]'
| Pipe.score(self, examples: Iterable[Example], **kwargs) -> Dict[str, Union[float, Dict[str, float]]]
|
| Score a batch of examples.
|
| examples (Iterable[Example]): The examples to score.
| RETURNS (Dict[str, Any]): The scores.
|
| DOCS: https://spacy.io/api/pipe#score
|
| set_error_handler(self, error_handler: 'Callable') -> 'None'
| Pipe.set_error_handler(self, error_handler: Callable) -> None
|
| Set an error handler function.
|
| error_handler (Callable[[str, Callable[[Doc], Doc], List[Doc], Exception], None]):
| Function that deals with a failing batch of documents. This callable function should take in
| the component's name, the component itself, the offending batch of documents, and the exception
| that was thrown.
|
| DOCS: https://spacy.io/api/pipe#set_error_handler
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.pipe.Pipe:
|
| hide_labels
| Pipe.hide_labels: bool
|
| label_data
| Optional JSON-serializable data that would be sufficient to recreate
| the label set if provided to the `pipe.initialize()` method.
|
| labels
| Pipe.labels: Tuple[str, ...]
|
| name
| name: str
class TrainablePipe(spacy.pipeline.pipe.Pipe)
| TrainablePipe(vocab: Vocab, model: Model, name: str, **cfg)
|
| This class is a base class and not instantiated directly. Trainable
| pipeline components like the EntityRecognizer or TextCategorizer inherit
| from it and it defines the interface that components should follow to
| function as trainable components in a spaCy pipeline.
|
| DOCS: https://spacy.io/api/pipe
|
| Method resolution order:
| TrainablePipe
| spacy.pipeline.pipe.Pipe
| builtins.object
|
| Methods defined here:
|
| __call__(...)
| TrainablePipe.__call__(self, Doc doc) -> Doc
|
| Apply the pipe to one document. The document is modified in place,
| and returned. This usually happens under the hood when the nlp object
| is called on a text and all components are applied to the Doc.
|
| docs (Doc): The Doc to process.
| RETURNS (Doc): The processed Doc.
|
| DOCS: https://spacy.io/api/pipe#call
|
| __init__(...)
| Initialize a pipeline component.
|
| vocab (Vocab): The shared vocabulary.
| model (thinc.api.Model): The Thinc Model powering the pipeline component.
| name (str): The component instance name.
| **cfg: Additional settings and config parameters.
|
| DOCS: https://spacy.io/api/pipe#init
|
| __reduce__ = __reduce_cython__(...)
| TrainablePipe.__reduce_cython__(self)
|
| __reduce_cython__(self)
| TrainablePipe.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| TrainablePipe.__setstate_cython__(self, __pyx_state)
|
| add_label(self, label: 'str') -> 'int'
| TrainablePipe.add_label(self, label: str) -> int
|
| Add an output label.
| For TrainablePipe components, it is possible to
| extend pretrained models with new labels, but care should be taken to
| avoid the "catastrophic forgetting" problem.
|
| label (str): The label to add.
| RETURNS (int): 0 if label is already present, otherwise 1.
|
| DOCS: https://spacy.io/api/pipe#add_label
|
| create_optimizer(self) -> 'Optimizer'
| TrainablePipe.create_optimizer(self) -> Optimizer
|
| Create an optimizer for the pipeline component.
|
| RETURNS (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#create_optimizer
|
| finish_update(self, sgd: 'Optimizer') -> 'None'
| TrainablePipe.finish_update(self, sgd: Optimizer) -> None
|
| Update parameters using the current parameter gradients.
| The Optimizer instance contains the functionality to perform
| the stochastic gradient descent.
|
| sgd (thinc.api.Optimizer): The optimizer.
|
| DOCS: https://spacy.io/api/pipe#finish_update
|
| from_bytes(self, bytes_data, *, exclude=())
| TrainablePipe.from_bytes(self, bytes_data, *, exclude=tuple())
|
| Load the pipe from a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (TrainablePipe): The loaded object.
|
| DOCS: https://spacy.io/api/pipe#from_bytes
|
| from_disk(self, path, *, exclude=())
| TrainablePipe.from_disk(self, path, *, exclude=tuple())
|
| Load the pipe from disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (TrainablePipe): The loaded object.
|
| DOCS: https://spacy.io/api/pipe#from_disk
|
| get_loss(self, examples: 'Iterable[Example]', scores) -> 'Tuple[float, float]'
| TrainablePipe.get_loss(self, examples: Iterable[Example], scores) -> Tuple[float, float]
|
| Find the loss and gradient of loss for the batch of documents and
| their predicted scores.
|
| examples (Iterable[Examples]): The batch of examples.
| scores: Scores representing the model's predictions.
| RETURNS (Tuple[float, float]): The loss and the gradient.
|
| DOCS: https://spacy.io/api/pipe#get_loss
|
| initialize(self, get_examples: 'Callable[[], Iterable[Example]]', *, nlp: 'Language' = None)
| TrainablePipe.initialize(self, get_examples: Callable[[], Iterable[Example]], *, nlp: Language = None)
|
| Initialize the pipe for training, using data examples if available.
| This method needs to be implemented by each TrainablePipe component,
| ensuring the internal model (if available) is initialized properly
| using the provided sample of Example objects.
|
| get_examples (Callable[[], Iterable[Example]]): Function that
| returns a representative sample of gold-standard Example objects.
| nlp (Language): The current nlp object the component is part of.
|
| DOCS: https://spacy.io/api/pipe#initialize
|
| pipe(self, stream: 'Iterable[Doc]', *, batch_size: 'int' = 128) -> 'Iterator[Doc]'
| TrainablePipe.pipe(self, stream: Iterable[Doc], *, batch_size: int = 128) -> Iterator[Doc]
|
| Apply the pipe to a stream of documents. This usually happens under
| the hood when the nlp object is called on a text and all components are
| applied to the Doc.
|
| stream (Iterable[Doc]): A stream of documents.
| batch_size (int): The number of documents to buffer.
| error_handler (Callable[[str, List[Doc], Exception], Any]): Function that
| deals with a failing batch of documents. The default function just reraises
| the exception.
| YIELDS (Doc): Processed documents in order.
|
| DOCS: https://spacy.io/api/pipe#pipe
|
| predict(self, docs: 'Iterable[Doc]')
| TrainablePipe.predict(self, docs: Iterable[Doc])
|
| Apply the pipeline's model to a batch of docs, without modifying them.
| Returns a single tensor for a batch of documents.
|
| docs (Iterable[Doc]): The documents to predict.
| RETURNS: Vector representations of the predictions.
|
| DOCS: https://spacy.io/api/pipe#predict
|
| rehearse(self, examples: 'Iterable[Example]', *, sgd: 'Optimizer' = None, losses: 'Dict[str, float]' = None, **config) -> 'Dict[str, float]'
| TrainablePipe.rehearse(self, examples: Iterable[Example], *, sgd: Optimizer = None, losses: Dict[str, float] = None, **config) -> Dict[str, float]
|
| Perform a "rehearsal" update from a batch of data. Rehearsal updates
| teach the current model to make predictions similar to an initial model,
| to try to address the "catastrophic forgetting" problem. This feature is
| experimental.
|
| examples (Iterable[Example]): A batch of Example objects.
| sgd (thinc.api.Optimizer): The optimizer.
| losses (Dict[str, float]): Optional record of the loss during training.
| Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/pipe#rehearse
|
| set_annotations(self, docs: 'Iterable[Doc]', scores)
| TrainablePipe.set_annotations(self, docs: Iterable[Doc], scores)
|
| Modify a batch of documents, using pre-computed scores.
|
| docs (Iterable[Doc]): The documents to modify.
| scores: The scores to assign.
|
| DOCS: https://spacy.io/api/pipe#set_annotations
|
| set_output(self, nO: 'int') -> 'None'
| TrainablePipe.set_output(self, nO: int) -> None
|
| to_bytes(self, *, exclude=())
| TrainablePipe.to_bytes(self, *, exclude=tuple())
|
| Serialize the pipe to a bytestring.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (bytes): The serialized object.
|
| DOCS: https://spacy.io/api/pipe#to_bytes
|
| to_disk(self, path, *, exclude=())
| TrainablePipe.to_disk(self, path, *, exclude=tuple())
|
| Serialize the pipe to disk.
|
| path (str / Path): Path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
|
| DOCS: https://spacy.io/api/pipe#to_disk
|
| update(self, examples: "Iterable['Example']", *, drop: 'float' = 0.0, sgd: 'Optimizer' = None, losses: 'Optional[Dict[str, float]]' = None) -> 'Dict[str, float]'
| TrainablePipe.update(self, examples: Iterable['Example'], *, drop: float = 0.0, sgd: Optimizer = None, losses: Optional[Dict[str, float]] = None) -> Dict[str, float]
|
| Learn from a batch of documents and gold-standard information,
| updating the pipe's model. Delegates to predict and get_loss.
|
| examples (Iterable[Example]): A batch of Example objects.
| drop (float): The dropout rate.
| sgd (thinc.api.Optimizer): The optimizer.
| losses (Dict[str, float]): Optional record of the loss during training.
| Updated using the component name as the key.
| RETURNS (Dict[str, float]): The updated losses dictionary.
|
| DOCS: https://spacy.io/api/pipe#update
|
| use_params(self, params: 'dict')
| TrainablePipe.use_params(self, params: dict)
|
| Modify the pipe's model, to use the given parameter values. At the
| end of the context, the original parameters are restored.
|
| params (dict): The parameter values to use in the model.
|
| DOCS: https://spacy.io/api/pipe#use_params
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| cfg
| cfg: object
|
| is_resizable
| TrainablePipe.is_resizable: bool
|
| is_trainable
| TrainablePipe.is_trainable: bool
|
| model
| model: object
|
| scorer
| scorer: object
|
| vocab
| vocab: spacy.vocab.Vocab
|
| ----------------------------------------------------------------------
| Methods inherited from spacy.pipeline.pipe.Pipe:
|
| get_error_handler(self) -> 'Callable'
| Pipe.get_error_handler(self) -> Callable
|
| Retrieve the error handler function.
|
| RETURNS (Callable): The error handler, or if it's not set a default function that just reraises.
|
| DOCS: https://spacy.io/api/pipe#get_error_handler
|
| score(self, examples: 'Iterable[Example]', **kwargs) -> 'Dict[str, Union[float, Dict[str, float]]]'
| Pipe.score(self, examples: Iterable[Example], **kwargs) -> Dict[str, Union[float, Dict[str, float]]]
|
| Score a batch of examples.
|
| examples (Iterable[Example]): The examples to score.
| RETURNS (Dict[str, Any]): The scores.
|
| DOCS: https://spacy.io/api/pipe#score
|
| set_error_handler(self, error_handler: 'Callable') -> 'None'
| Pipe.set_error_handler(self, error_handler: Callable) -> None
|
| Set an error handler function.
|
| error_handler (Callable[[str, Callable[[Doc], Doc], List[Doc], Exception], None]):
| Function that deals with a failing batch of documents. This callable function should take in
| the component's name, the component itself, the offending batch of documents, and the exception
| that was thrown.
|
| DOCS: https://spacy.io/api/pipe#set_error_handler
|
| ----------------------------------------------------------------------
| Data descriptors inherited from spacy.pipeline.pipe.Pipe:
|
| hide_labels
| Pipe.hide_labels: bool
|
| label_data
| Optional JSON-serializable data that would be sufficient to recreate
| the label set if provided to the `pipe.initialize()` method.
|
| labels
| Pipe.labels: Tuple[str, ...]
|
| name
| name: str
FUNCTIONS
merge_entities(doc: spacy.tokens.doc.Doc)
Merge entities into a single token.
doc (Doc): The Doc object.
RETURNS (Doc): The Doc object with merged entities.
DOCS: https://spacy.io/api/pipeline-functions#merge_entities
merge_noun_chunks(doc: spacy.tokens.doc.Doc) -> spacy.tokens.doc.Doc
Merge noun chunks into a single token.
doc (Doc): The Doc object.
RETURNS (Doc): The Doc object with merged noun chunks.
DOCS: https://spacy.io/api/pipeline-functions#merge_noun_chunks
merge_subtokens(doc: spacy.tokens.doc.Doc, label: str = 'subtok') -> spacy.tokens.doc.Doc
Merge subtokens into a single token.
doc (Doc): The Doc object.
label (str): The subtoken dependency label.
RETURNS (Doc): The Doc object with merged subtokens.
DOCS: https://spacy.io/api/pipeline-functions#merge_subtokens
DATA
__all__ = ['AttributeRuler', 'DependencyParser', 'EditTreeLemmatizer',...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\pipeline\__init__.py
spacy.populate_registry
Python Library Documentation: function populate_registry in module spacy.registrations
populate_registry() -> None
Populate the registry with all necessary components.
This function should be called before accessing the registry, to ensure
it's populated. The function uses a global flag to prevent repopulation.
spacy.prefer_gpu
Python Library Documentation: function prefer_gpu in module thinc.util
prefer_gpu(gpu_id: int = 0) -> bool
Use GPU if it's available. Returns True if so, False otherwise.
spacy.registrations
Python Library Documentation: module spacy.registrations in spacy
NAME
spacy.registrations - Centralized registry population for spaCy config
DESCRIPTION
This module centralizes registry decorations to prevent circular import issues
with Cython annotation changes from __future__ import annotations. Functions
remain in their original locations, but decoration is moved here.
Component definitions and registrations are in spacy/pipeline/factories.py
FUNCTIONS
populate_registry() -> None
Populate the registry with all necessary components.
This function should be called before accessing the registry, to ensure
it's populated. The function uses a global flag to prevent repopulation.
DATA
REGISTRY_POPULATED = False
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\registrations.py
spacy.registry
Python Library Documentation: class registry in module spacy.util
class registry(thinc.config.registry)
| Method resolution order:
| registry
| thinc.config.registry
| confection._registry.registry
| builtins.object
|
| Class methods defined here:
|
| ensure_populated() -> None
| Ensure the registry is populated with all necessary components.
|
| find(registry_name: str, func_name: str) -> Dict[str, Union[str, int, NoneType]]
| Find information about a registered function, including the
| module and path to the file it's defined in, the line number and the
| docstring, if available.
|
| registry_name (str): Name of the catalogue registry.
| func_name (str): Name of the registered function.
| RETURNS (Dict[str, Optional[Union[str, int]]]): The function info.
|
| get(registry_name: str, func_name: str) -> Callable
| Get a registered function from the registry.
|
| get_registry_names() -> List[str]
| List all available registries.
|
| has(registry_name: str, func_name: str) -> bool
| Check whether a function is available in a registry.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| architectures = <catalogue.Registry object>
|
| augmenters = <catalogue.Registry object>
|
| batchers = <catalogue.Registry object>
|
| callbacks = <catalogue.Registry object>
|
| cli = <catalogue.Registry object>
|
| displacy_colors = <catalogue.Registry object>
|
| factories = <catalogue.Registry object>
|
| languages = <catalogue.Registry object>
|
| lemmatizers = <catalogue.Registry object>
|
| loggers = <catalogue.Registry object>
|
| lookups = <catalogue.Registry object>
|
| misc = <catalogue.Registry object>
|
| models = <catalogue.Registry object>
|
| readers = <catalogue.Registry object>
|
| scorers = <catalogue.Registry object>
|
| tokenizers = <catalogue.Registry object>
|
| vectors = <catalogue.Registry object>
|
| ----------------------------------------------------------------------
| Class methods inherited from thinc.config.registry:
|
| create(registry_name: str, entry_points: bool = False) -> None
| Create a new custom registry.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from thinc.config.registry:
|
| datasets = <catalogue.Registry object>
|
| initializers = <catalogue.Registry object>
|
| layers = <catalogue.Registry object>
|
| losses = <catalogue.Registry object>
|
| ops = <catalogue.Registry object>
|
| optimizers = <catalogue.Registry object>
|
| schedules = <catalogue.Registry object>
|
| ----------------------------------------------------------------------
| Class methods inherited from confection._registry.registry:
|
| fill(config: Union[confection._config.Config, Dict[str, Dict[str, Any]]], *, schema=None, overrides: Dict[str, Any] = {}, interpolate: bool = False, validate: bool = True) -> confection._config.Config
|
| get_constructor(obj: Dict[str, Any]) -> Tuple[str, str]
|
| is_promise(obj: Any) -> bool
| Check whether an object is a "promise", i.e. contains a reference
| to a registered function (via a key starting with `"@"`.
|
| parse_args(obj: Dict[str, Any]) -> Tuple[List[Any], Dict[str, Any]]
|
| resolve(config: Union[confection._config.Config, Dict[str, Dict[str, Any]]], *, schema=None, overrides: Dict[str, Any] = {}, validate: bool = True) -> Dict[str, Any]
|
| ----------------------------------------------------------------------
| Data descriptors inherited from confection._registry.registry:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
spacy.require_cpu
Python Library Documentation: function require_cpu in module thinc.util
require_cpu() -> bool
Use CPU through best available backend.
spacy.require_gpu
Python Library Documentation: function require_gpu in module thinc.util require_gpu(gpu_id: int = 0) -> bool
spacy.schemas
Python Library Documentation: module spacy.schemas in spacy
NAME
spacy.schemas
CLASSES
builtins.str(builtins.object)
TokenPatternOperatorSimple(builtins.str, enum.Enum)
enum.Enum(builtins.object)
TokenPatternOperatorSimple(builtins.str, enum.Enum)
pydantic.main.BaseModel(builtins.object)
ConfigSchema
ConfigSchemaInit
ConfigSchemaNlp
ConfigSchemaPretrain
ConfigSchemaPretrainEmpty
ConfigSchemaTraining
DocJSONSchema
ModelMetaSchema
RecommendationSchema
RecommendationTrf
RecommendationTrfItem
TokenPattern
TokenPatternNumber
TokenPatternSchema
TokenPatternString
class ConfigSchema(pydantic.main.BaseModel)
| ConfigSchema(*, training: spacy.schemas.ConfigSchemaTraining, nlp: spacy.schemas.ConfigSchemaNlp, pretraining: Union[spacy.schemas.ConfigSchemaPretrain, spacy.schemas.ConfigSchemaPretrainEmpty] = {}, components: Dict[str, Dict[str, Any]], corpora: Dict[str, Union[Callable[[spacy.language.Language, str], Iterable[spacy.training.example.Example]], confection._registry.Promise]], initialize: spacy.schemas.ConfigSchemaInit, **extra_data: Any) -> None
|
| Method resolution order:
| ConfigSchema
| pydantic.main.BaseModel
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'components': typing.Dict[str, typing.Dict[str, typ...
|
| __class_vars__ = set()
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'definitions': [{'cls': <class 'confection...
|
| __pydantic_custom_init__ = False
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {'components': FieldInfo(annotation=Dict[str, Di...
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = None
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="ConfigSchema", validat...
|
| __signature__ = <Signature (*, training: spacy.schemas.ConfigSch...mas...
|
| model_config = {'arbitrary_types_allowed': True, 'extra': 'allow'}
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __init__(self, /, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_args__(self) -> '_repr.ReprArgs'
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| 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(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]'
|
| json(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, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| 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.
|
| Returns:
| New model instance.
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| 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.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| from_orm(obj: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| 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.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| 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.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| 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.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_obj(obj: 'Any') -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {'components': FieldInfo(annotation=Dict[str, Dict[str,...
class ConfigSchemaInit(pydantic.main.BaseModel)
| ConfigSchemaInit(*, vocab_data: Optional[Annotated[str, Strict(strict=True)]], lookups: Optional[spacy.lookups.Lookups], vectors: Optional[Annotated[str, Strict(strict=True)]], init_tok2vec: Optional[Annotated[str, Strict(strict=True)]], tokenizer: Dict[Annotated[str, Strict(strict=True)], Any], components: Dict[Annotated[str, Strict(strict=True)], Dict[Annotated[str, Strict(strict=True)], Any]], before_init: Optional[Callable[[spacy.language.Language], spacy.language.Language]], after_init: Optional[Callable[[spacy.language.Language], spacy.language.Language]]) -> None
|
| Method resolution order:
| ConfigSchemaInit
| pydantic.main.BaseModel
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'after_init': typing.Optional[typing.Callable[[Forw...
|
| __class_vars__ = set()
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'cls': <class 'spacy.schemas.ConfigSchemaI...
|
| __pydantic_custom_init__ = False
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {'after_init': FieldInfo(annotation=Union[Callab...
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = None
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="ConfigSchemaInit", val...
|
| __signature__ = <Signature (*, vocab_data: Optional[Annotated[st...ge....
|
| model_config = {'arbitrary_types_allowed': True, 'extra': 'forbid'}
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __init__(self, /, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_args__(self) -> '_repr.ReprArgs'
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| 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(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]'
|
| json(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, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| 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.
|
| Returns:
| New model instance.
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| 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.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| from_orm(obj: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| 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.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| 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.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| 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.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_obj(obj: 'Any') -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {'after_init': FieldInfo(annotation=Union[Callable[list...
class ConfigSchemaNlp(pydantic.main.BaseModel)
| ConfigSchemaNlp(*, lang: Annotated[str, Strict(strict=True)], pipeline: List[Annotated[str, Strict(strict=True)]], disabled: List[Annotated[str, Strict(strict=True)]], tokenizer: Callable, before_creation: Optional[Callable[[Type[spacy.language.Language]], Type[spacy.language.Language]]], after_creation: Optional[Callable[[spacy.language.Language], spacy.language.Language]], after_pipeline_creation: Optional[Callable[[spacy.language.Language], spacy.language.Language]], batch_size: Optional[int], vectors: Callable) -> None
|
| Method resolution order:
| ConfigSchemaNlp
| pydantic.main.BaseModel
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'after_creation': typing.Optional[typing.Callable[[...
|
| __class_vars__ = set()
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'cls': <class 'spacy.schemas.ConfigSchemaN...
|
| __pydantic_custom_init__ = False
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {'after_creation': FieldInfo(annotation=Union[Ca...
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = None
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="ConfigSchemaNlp", vali...
|
| __signature__ = <Signature (*, lang: Annotated[str, Strict(stric..._si...
|
| model_config = {'arbitrary_types_allowed': True, 'extra': 'forbid'}
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __init__(self, /, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_args__(self) -> '_repr.ReprArgs'
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| 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(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]'
|
| json(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, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| 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.
|
| Returns:
| New model instance.
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| 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.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| from_orm(obj: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| 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.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| 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.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| 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.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_obj(obj: 'Any') -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {'after_creation': FieldInfo(annotation=Union[Callable[...
class ConfigSchemaPretrain(pydantic.main.BaseModel)
| ConfigSchemaPretrain(*, max_epochs: Annotated[int, Strict(strict=True)], dropout: Annotated[float, Strict(strict=True)], n_save_every: Optional[Annotated[int, Strict(strict=True)]], n_save_epoch: Optional[Annotated[int, Strict(strict=True)]], optimizer: thinc.optimizers.Optimizer, corpus: Annotated[str, Strict(strict=True)], batcher: Union[Callable[[Iterable[~ItemT]], Iterable[List[~ItemT]]], confection._registry.Promise], component: str, layer: str, objective: Callable[[spacy.vocab.Vocab, thinc.model.Model], thinc.model.Model]) -> None
|
| Method resolution order:
| ConfigSchemaPretrain
| pydantic.main.BaseModel
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'batcher': typing.Union[typing.Callable[[typing.Ite...
|
| __class_vars__ = set()
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'cls': <class 'spacy.schemas.ConfigSchemaP...
|
| __pydantic_custom_init__ = False
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {'batcher': FieldInfo(annotation=Union[Callable[...
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = None
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="ConfigSchemaPretrain",...
|
| __signature__ = <Signature (*, max_epochs: Annotated[int, Strict... th...
|
| model_config = {'arbitrary_types_allowed': True, 'extra': 'forbid'}
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __init__(self, /, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_args__(self) -> '_repr.ReprArgs'
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| 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(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]'
|
| json(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, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| 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.
|
| Returns:
| New model instance.
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| 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.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| from_orm(obj: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| 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.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| 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.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| 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.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_obj(obj: 'Any') -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {'batcher': FieldInfo(annotation=Union[Callable[list, I...
class ConfigSchemaPretrainEmpty(pydantic.main.BaseModel)
| ConfigSchemaPretrainEmpty() -> None
|
| Method resolution order:
| ConfigSchemaPretrainEmpty
| pydantic.main.BaseModel
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| __class_vars__ = set()
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'cls': <class 'spacy.schemas.ConfigSchemaP...
|
| __pydantic_custom_init__ = False
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {}
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = None
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="ConfigSchemaPretrainEm...
|
| __signature__ = <Signature () -> None>
|
| model_config = {'extra': 'forbid'}
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __init__(self, /, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_args__(self) -> '_repr.ReprArgs'
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| 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(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]'
|
| json(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, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| 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.
|
| Returns:
| New model instance.
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| 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.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| from_orm(obj: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| 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.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| 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.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| 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.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_obj(obj: 'Any') -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {}
class ConfigSchemaTraining(pydantic.main.BaseModel)
| ConfigSchemaTraining(*, dev_corpus: Annotated[str, Strict(strict=True)], train_corpus: Annotated[str, Strict(strict=True)], batcher: Union[Callable[[Iterable[~ItemT]], Iterable[List[~ItemT]]], confection._registry.Promise], dropout: Annotated[float, Strict(strict=True)], patience: Annotated[int, Strict(strict=True)], max_epochs: Annotated[int, Strict(strict=True)], max_steps: Annotated[int, Strict(strict=True)], eval_frequency: Annotated[int, Strict(strict=True)], seed: Optional[Annotated[int, Strict(strict=True)]], gpu_allocator: Optional[Annotated[str, Strict(strict=True)]], accumulate_gradient: Annotated[int, Strict(strict=True)], score_weights: Dict[Annotated[str, Strict(strict=True)], Union[Annotated[int, Strict(strict=True)], Annotated[float, Strict(strict=True)], NoneType]], optimizer: thinc.optimizers.Optimizer, logger: Union[Callable[[spacy.language.Language], Tuple[Callable[[Dict[str, Any]], NoneType], Callable]], confection._registry.Promise], frozen_components: List[str], annotating_components: List[str], before_to_disk: Optional[Callable[[spacy.language.Language], spacy.language.Language]], before_update: Optional[Callable[[spacy.language.Language, Dict[str, Any]], NoneType]]) -> None
|
| Method resolution order:
| ConfigSchemaTraining
| pydantic.main.BaseModel
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'accumulate_gradient': typing.Annotated[int, Strict...
|
| __class_vars__ = set()
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'definitions': [{'cls': <class 'confection...
|
| __pydantic_custom_init__ = False
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {'accumulate_gradient': FieldInfo(annotation=int...
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = None
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="ConfigSchemaTraining",...
|
| __signature__ = <Signature (*, dev_corpus: Annotated[str, Strict...e.L...
|
| model_config = {'arbitrary_types_allowed': True, 'extra': 'forbid'}
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __init__(self, /, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_args__(self) -> '_repr.ReprArgs'
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| 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(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]'
|
| json(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, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| 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.
|
| Returns:
| New model instance.
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| 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.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| from_orm(obj: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| 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.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| 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.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| 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.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_obj(obj: 'Any') -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {'accumulate_gradient': FieldInfo(annotation=int, requi...
class DocJSONSchema(pydantic.main.BaseModel)
| DocJSONSchema(*, cats: Optional[Dict[Annotated[str, Strict(strict=True)], Annotated[float, Strict(strict=True)]]] = None, ents: Optional[List[Dict[Annotated[str, Strict(strict=True)], Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)]]]]] = None, sents: Optional[List[Dict[Annotated[str, Strict(strict=True)], Annotated[int, Strict(strict=True)]]]] = None, text: Annotated[str, Strict(strict=True)], spans: Optional[Dict[Annotated[str, Strict(strict=True)], List[Dict[Annotated[str, Strict(strict=True)], Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)]]]]]] = None, tokens: List[Dict[Annotated[str, Strict(strict=True)], Union[Annotated[int, Strict(strict=True)], Annotated[str, Strict(strict=True)]]]], _: Optional[Dict[Annotated[str, Strict(strict=True)], Any]] = None, underscore_token: Optional[Dict[Annotated[str, Strict(strict=True)], List[Dict[Annotated[str, Strict(strict=True)], Any]]]] = None, underscore_span: Optional[Dict[Annotated[str, Strict(strict=True)], List[Dict[Annotated[str, Strict(strict=True)], Any]]]] = None) -> None
|
| JSON/dict format for JSON representation of Doc objects.
|
| Method resolution order:
| DocJSONSchema
| pydantic.main.BaseModel
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'cats': typing.Optional[typing.Dict[typing.Annotate...
|
| __class_vars__ = set()
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'cls': <class 'spacy.schemas.DocJSONSchema...
|
| __pydantic_custom_init__ = False
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {'cats': FieldInfo(annotation=Union[Dict[Annotat...
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = None
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="DocJSONSchema", valida...
|
| __signature__ = <Signature (*, cats: Optional[Dict[Annotated[str...r, ...
|
| model_config = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __init__(self, /, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_args__(self) -> '_repr.ReprArgs'
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| 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(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]'
|
| json(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, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| 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.
|
| Returns:
| New model instance.
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| 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.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| from_orm(obj: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| 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.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| 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.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| 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.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_obj(obj: 'Any') -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {'cats': FieldInfo(annotation=Union[Dict[Annotated[str,...
class ModelMetaSchema(pydantic.main.BaseModel)
| ModelMetaSchema(*, lang: Annotated[str, Strict(strict=True)], name: Annotated[str, Strict(strict=True)], version: Annotated[str, Strict(strict=True)], spacy_version: Annotated[str, Strict(strict=True)] = '', parent_package: Annotated[str, Strict(strict=True)] = 'spacy', requirements: List[Annotated[str, Strict(strict=True)]] = [], pipeline: List[Annotated[str, Strict(strict=True)]] = [], description: Annotated[str, Strict(strict=True)] = '', license: Annotated[str, Strict(strict=True)] = '', author: Annotated[str, Strict(strict=True)] = '', email: Annotated[str, Strict(strict=True)] = '', url: Annotated[str, Strict(strict=True)] = '', sources: Union[List[Annotated[str, Strict(strict=True)]], List[Dict[str, str]], NoneType] = None, vectors: Dict[str, Any] = {}, labels: Dict[str, List[str]] = {}, performance: Dict[str, Any] = {}, spacy_git_version: Annotated[str, Strict(strict=True)] = '') -> None
|
| Method resolution order:
| ModelMetaSchema
| pydantic.main.BaseModel
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'author': typing.Annotated[str, Strict(strict=True)...
|
| __class_vars__ = set()
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'cls': <class 'spacy.schemas.ModelMetaSche...
|
| __pydantic_custom_init__ = False
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {'author': FieldInfo(annotation=str, required=Fa...
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = None
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="ModelMetaSchema", vali...
|
| __signature__ = <Signature (*, lang: Annotated[str, Strict(stric...nno...
|
| model_config = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __init__(self, /, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_args__(self) -> '_repr.ReprArgs'
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| 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(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]'
|
| json(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, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| 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.
|
| Returns:
| New model instance.
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| 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.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| from_orm(obj: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| 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.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| 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.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| 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.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_obj(obj: 'Any') -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {'author': FieldInfo(annotation=str, required=False, de...
class RecommendationSchema(pydantic.main.BaseModel)
| RecommendationSchema(*, word_vectors: Optional[str] = None, transformer: Optional[spacy.schemas.RecommendationTrf] = None, has_letters: bool = True) -> None
|
| Method resolution order:
| RecommendationSchema
| pydantic.main.BaseModel
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'has_letters': <class 'bool'>, 'transformer': typin...
|
| __class_vars__ = set()
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'definitions': [{'cls': <class 'spacy.sche...
|
| __pydantic_custom_init__ = False
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {'has_letters': FieldInfo(annotation=bool, requi...
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = None
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="RecommendationSchema",...
|
| __signature__ = <Signature (*, word_vectors: Optional[str] = Non...onT...
|
| model_config = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __init__(self, /, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_args__(self) -> '_repr.ReprArgs'
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| 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(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]'
|
| json(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, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| 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.
|
| Returns:
| New model instance.
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| 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.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| from_orm(obj: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| 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.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| 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.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| 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.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_obj(obj: 'Any') -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {'has_letters': FieldInfo(annotation=bool, required=Fal...
class RecommendationTrf(pydantic.main.BaseModel)
| RecommendationTrf(*, efficiency: spacy.schemas.RecommendationTrfItem, accuracy: spacy.schemas.RecommendationTrfItem) -> None
|
| Method resolution order:
| RecommendationTrf
| pydantic.main.BaseModel
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'accuracy': <class 'spacy.schemas.RecommendationTrf...
|
| __class_vars__ = set()
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'definitions': [{'cls': <class 'spacy.sche...
|
| __pydantic_custom_init__ = False
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {'accuracy': FieldInfo(annotation=Recommendation...
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = None
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="RecommendationTrf", va...
|
| __signature__ = <Signature (*, efficiency: spacy.schemas.Recomme...cy:...
|
| model_config = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __init__(self, /, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_args__(self) -> '_repr.ReprArgs'
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| 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(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]'
|
| json(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, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| 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.
|
| Returns:
| New model instance.
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| 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.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| from_orm(obj: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| 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.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| 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.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| 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.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_obj(obj: 'Any') -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {'accuracy': FieldInfo(annotation=RecommendationTrfItem...
class RecommendationTrfItem(pydantic.main.BaseModel)
| RecommendationTrfItem(*, name: str, size_factor: int) -> None
|
| Method resolution order:
| RecommendationTrfItem
| pydantic.main.BaseModel
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'name': <class 'str'>, 'size_factor': <class 'int'>...
|
| __class_vars__ = set()
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'cls': <class 'spacy.schemas.Recommendatio...
|
| __pydantic_custom_init__ = False
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {'name': FieldInfo(annotation=str, required=True...
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = None
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="RecommendationTrfItem"...
|
| __signature__ = <Signature (*, name: str, size_factor: int) -> None>
|
| model_config = {}
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __init__(self, /, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_args__(self) -> '_repr.ReprArgs'
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| 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(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]'
|
| json(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, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| 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.
|
| Returns:
| New model instance.
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| 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.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| from_orm(obj: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| 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.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| 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.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| 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.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_obj(obj: 'Any') -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {'name': FieldInfo(annotation=str, required=True), 'siz...
class TokenPattern(pydantic.main.BaseModel)
| TokenPattern(*, ORTH: Union[spacy.schemas.TokenPatternString, Annotated[str, Strict(strict=True)], NoneType] = None, TEXT: Union[spacy.schemas.TokenPatternString, Annotated[str, Strict(strict=True)], NoneType] = None, LOWER: Union[spacy.schemas.TokenPatternString, Annotated[str, Strict(strict=True)], NoneType] = None, POS: Union[spacy.schemas.TokenPatternString, Annotated[str, Strict(strict=True)], NoneType] = None, TAG: Union[spacy.schemas.TokenPatternString, Annotated[str, Strict(strict=True)], NoneType] = None, MORPH: Union[spacy.schemas.TokenPatternString, Annotated[str, Strict(strict=True)], NoneType] = None, DEP: Union[spacy.schemas.TokenPatternString, Annotated[str, Strict(strict=True)], NoneType] = None, LEMMA: Union[spacy.schemas.TokenPatternString, Annotated[str, Strict(strict=True)], NoneType] = None, SHAPE: Union[spacy.schemas.TokenPatternString, Annotated[str, Strict(strict=True)], NoneType] = None, ENT_TYPE: Union[spacy.schemas.TokenPatternString, Annotated[str, Strict(strict=True)], NoneType] = None, ENT_IOB: Optional[Literal['', 'I', 'O', 'B', 0, 1, 2, 3]] = None, ENT_ID: Union[spacy.schemas.TokenPatternString, Annotated[str, Strict(strict=True)], NoneType] = None, ENT_KB_ID: Union[spacy.schemas.TokenPatternString, Annotated[str, Strict(strict=True)], NoneType] = None, NORM: Union[spacy.schemas.TokenPatternString, Annotated[str, Strict(strict=True)], NoneType] = None, LENGTH: Union[spacy.schemas.TokenPatternNumber, Annotated[int, Strict(strict=True)], Annotated[float, Strict(strict=True)], NoneType] = None, SPACY: Optional[Annotated[bool, Strict(strict=True)]] = None, IS_ALPHA: Optional[Annotated[bool, Strict(strict=True)]] = None, IS_ASCII: Optional[Annotated[bool, Strict(strict=True)]] = None, IS_DIGIT: Optional[Annotated[bool, Strict(strict=True)]] = None, IS_LOWER: Optional[Annotated[bool, Strict(strict=True)]] = None, IS_UPPER: Optional[Annotated[bool, Strict(strict=True)]] = None, IS_TITLE: Optional[Annotated[bool, Strict(strict=True)]] = None, IS_PUNCT: Optional[Annotated[bool, Strict(strict=True)]] = None, IS_SPACE: Optional[Annotated[bool, Strict(strict=True)]] = None, IS_BRACKET: Optional[Annotated[bool, Strict(strict=True)]] = None, IS_QUOTE: Optional[Annotated[bool, Strict(strict=True)]] = None, IS_LEFT_PUNCT: Optional[Annotated[bool, Strict(strict=True)]] = None, IS_RIGHT_PUNCT: Optional[Annotated[bool, Strict(strict=True)]] = None, IS_CURRENCY: Optional[Annotated[bool, Strict(strict=True)]] = None, IS_STOP: Optional[Annotated[bool, Strict(strict=True)]] = None, IS_SENT_START: Optional[Annotated[bool, Strict(strict=True)]] = None, SENT_START: Optional[Annotated[bool, Strict(strict=True)]] = None, LIKE_NUM: Optional[Annotated[bool, Strict(strict=True)]] = None, LIKE_URL: Optional[Annotated[bool, Strict(strict=True)]] = None, LIKE_EMAIL: Optional[Annotated[bool, Strict(strict=True)]] = None, OP: Union[spacy.schemas.TokenPatternOperatorSimple, Annotated[str, StringConstraints(strip_whitespace=None, to_upper=None, to_lower=None, strict=None, min_length=None, max_length=None, pattern='^(\\{\\d+\\}|\\{\\d+,\\d*\\}|\\{\\d*,\\d+\\})$', ascii_only=None)], NoneType] = None, _: Optional[Dict[Annotated[str, Strict(strict=True)], Union[spacy.schemas.TokenPatternString, spacy.schemas.TokenPatternNumber, str, int, float, list, bool]]] = None) -> None
|
| Method resolution order:
| TokenPattern
| pydantic.main.BaseModel
| builtins.object
|
| Class methods defined here:
|
| raise_for_none(v)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'dep': typing.Union[spacy.schemas.TokenPatternStrin...
|
| __class_vars__ = set()
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'definitions': [{'cls': <class 'spacy.sche...
|
| __pydantic_custom_init__ = False
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {'dep': FieldInfo(annotation=Union[TokenPatternS...
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = None
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="TokenPattern", validat...
|
| __signature__ = <Signature (*, ORTH: Union[spacy.schemas.TokenPa..., s...
|
| model_config = {'alias_generator': <function TokenPattern.<lambda>>, '...
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __init__(self, /, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_args__(self) -> '_repr.ReprArgs'
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| 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(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]'
|
| json(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, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| 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.
|
| Returns:
| New model instance.
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| 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.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| from_orm(obj: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| 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.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| 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.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| 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.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_obj(obj: 'Any') -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {'dep': FieldInfo(annotation=Union[TokenPatternString, ...
class TokenPatternNumber(pydantic.main.BaseModel)
| TokenPatternNumber(*, regex: Optional[Annotated[str, Strict(strict=True)]] = None, IN: Optional[List[Annotated[int, Strict(strict=True)]]] = None, not_in: Optional[List[Annotated[int, Strict(strict=True)]]] = None, is_subset: Optional[List[Annotated[int, Strict(strict=True)]]] = None, is_superset: Optional[List[Annotated[int, Strict(strict=True)]]] = None, intersects: Optional[List[Annotated[int, Strict(strict=True)]]] = None, EQ: Union[Annotated[int, Strict(strict=True)], Annotated[float, Strict(strict=True)], NoneType] = None, NEQ: Union[Annotated[int, Strict(strict=True)], Annotated[float, Strict(strict=True)], NoneType] = None, GEQ: Union[Annotated[int, Strict(strict=True)], Annotated[float, Strict(strict=True)], NoneType] = None, LEQ: Union[Annotated[int, Strict(strict=True)], Annotated[float, Strict(strict=True)], NoneType] = None, GT: Union[Annotated[int, Strict(strict=True)], Annotated[float, Strict(strict=True)], NoneType] = None, LT: Union[Annotated[int, Strict(strict=True)], Annotated[float, Strict(strict=True)], NoneType] = None) -> None
|
| Method resolution order:
| TokenPatternNumber
| pydantic.main.BaseModel
| builtins.object
|
| Class methods defined here:
|
| raise_for_none(v)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'EQ': typing.Union[typing.Annotated[int, Strict(str...
|
| __class_vars__ = set()
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'cls': <class 'spacy.schemas.TokenPatternN...
|
| __pydantic_custom_init__ = False
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {'EQ': FieldInfo(annotation=Union[Annotated[int,...
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = None
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="TokenPatternNumber", v...
|
| __signature__ = <Signature (*, regex: Optional[Annotated[str, St... St...
|
| model_config = {'extra': 'forbid', 'populate_by_name': True, 'validate...
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __init__(self, /, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_args__(self) -> '_repr.ReprArgs'
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| 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(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]'
|
| json(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, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| 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.
|
| Returns:
| New model instance.
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| 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.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| from_orm(obj: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| 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.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| 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.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| 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.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_obj(obj: 'Any') -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {'EQ': FieldInfo(annotation=Union[Annotated[int, Strict...
class TokenPatternOperatorSimple(builtins.str, enum.Enum)
| TokenPatternOperatorSimple(*values)
|
| Method resolution order:
| TokenPatternOperatorSimple
| builtins.str
| enum.Enum
| builtins.object
|
| Methods defined here:
|
| __format__(self, format_spec) from enum.Enum
| Default object formatter.
|
| Return str(self) if format_spec is empty. Raise TypeError otherwise.
|
| __new__(cls, value) from enum.Enum
| Create and return a new object. See help(type) for accurate signature.
|
| __repr__(self) from enum.Enum
| Return repr(self).
|
| __str__(self) from enum.Enum
| Return str(self).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| exclamation = <TokenPatternOperatorSimple.exclamation: '!'>
|
| plus = <TokenPatternOperatorSimple.plus: '+'>
|
| question = <TokenPatternOperatorSimple.question: '?'>
|
| star = <TokenPatternOperatorSimple.star: '*'>
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.str:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getitem__(self, key, /)
| Return self[key].
|
| __getnewargs__(...)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mod__(self, value, /)
| Return self%value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmod__(self, value, /)
| Return value%self.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __sizeof__(self, /)
| Return the size of the string in memory, in bytes.
|
| capitalize(self, /)
| Return a capitalized version of the string.
|
| More specifically, make the first character have upper case and the rest lower
| case.
|
| casefold(self, /)
| Return a version of the string suitable for caseless comparisons.
|
| center(self, width, fillchar=' ', /)
| Return a centered string of length width.
|
| Padding is done using the specified fill character (default is a space).
|
| count(...)
| S.count(sub[, start[, end]]) -> int
|
| Return the number of non-overlapping occurrences of substring sub in
| string S[start:end]. Optional arguments start and end are
| interpreted as in slice notation.
|
| encode(self, /, encoding='utf-8', errors='strict')
| Encode the string using the codec registered for encoding.
|
| encoding
| The encoding in which to encode the string.
| errors
| The error handling scheme to use for encoding errors.
| The default is 'strict' meaning that encoding errors raise a
| UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
| 'xmlcharrefreplace' as well as any other name registered with
| codecs.register_error that can handle UnicodeEncodeErrors.
|
| endswith(...)
| S.endswith(suffix[, start[, end]]) -> bool
|
| Return True if S ends with the specified suffix, False otherwise.
| With optional start, test S beginning at that position.
| With optional end, stop comparing S at that position.
| suffix can also be a tuple of strings to try.
|
| expandtabs(self, /, tabsize=8)
| Return a copy where all tab characters are expanded using spaces.
|
| If tabsize is not given, a tab size of 8 characters is assumed.
|
| find(...)
| S.find(sub[, start[, end]]) -> int
|
| Return the lowest index in S where substring sub is found,
| such that sub is contained within S[start:end]. Optional
| arguments start and end are interpreted as in slice notation.
|
| Return -1 on failure.
|
| format(...)
| S.format(*args, **kwargs) -> str
|
| Return a formatted version of S, using substitutions from args and kwargs.
| The substitutions are identified by braces ('{' and '}').
|
| format_map(...)
| S.format_map(mapping) -> str
|
| Return a formatted version of S, using substitutions from mapping.
| The substitutions are identified by braces ('{' and '}').
|
| index(...)
| S.index(sub[, start[, end]]) -> int
|
| Return the lowest index in S where substring sub is found,
| such that sub is contained within S[start:end]. Optional
| arguments start and end are interpreted as in slice notation.
|
| Raises ValueError when the substring is not found.
|
| isalnum(self, /)
| Return True if the string is an alpha-numeric string, False otherwise.
|
| A string is alpha-numeric if all characters in the string are alpha-numeric and
| there is at least one character in the string.
|
| isalpha(self, /)
| Return True if the string is an alphabetic string, False otherwise.
|
| A string is alphabetic if all characters in the string are alphabetic and there
| is at least one character in the string.
|
| isascii(self, /)
| Return True if all characters in the string are ASCII, False otherwise.
|
| ASCII characters have code points in the range U+0000-U+007F.
| Empty string is ASCII too.
|
| isdecimal(self, /)
| Return True if the string is a decimal string, False otherwise.
|
| A string is a decimal string if all characters in the string are decimal and
| there is at least one character in the string.
|
| isdigit(self, /)
| Return True if the string is a digit string, False otherwise.
|
| A string is a digit string if all characters in the string are digits and there
| is at least one character in the string.
|
| isidentifier(self, /)
| Return True if the string is a valid Python identifier, False otherwise.
|
| Call keyword.iskeyword(s) to test whether string s is a reserved identifier,
| such as "def" or "class".
|
| islower(self, /)
| Return True if the string is a lowercase string, False otherwise.
|
| A string is lowercase if all cased characters in the string are lowercase and
| there is at least one cased character in the string.
|
| isnumeric(self, /)
| Return True if the string is a numeric string, False otherwise.
|
| A string is numeric if all characters in the string are numeric and there is at
| least one character in the string.
|
| isprintable(self, /)
| Return True if the string is printable, False otherwise.
|
| A string is printable if all of its characters are considered printable in
| repr() or if it is empty.
|
| isspace(self, /)
| Return True if the string is a whitespace string, False otherwise.
|
| A string is whitespace if all characters in the string are whitespace and there
| is at least one character in the string.
|
| istitle(self, /)
| Return True if the string is a title-cased string, False otherwise.
|
| In a title-cased string, upper- and title-case characters may only
| follow uncased characters and lowercase characters only cased ones.
|
| isupper(self, /)
| Return True if the string is an uppercase string, False otherwise.
|
| A string is uppercase if all cased characters in the string are uppercase and
| there is at least one cased character in the string.
|
| join(self, iterable, /)
| Concatenate any number of strings.
|
| The string whose method is called is inserted in between each given string.
| The result is returned as a new string.
|
| Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
|
| ljust(self, width, fillchar=' ', /)
| Return a left-justified string of length width.
|
| Padding is done using the specified fill character (default is a space).
|
| lower(self, /)
| Return a copy of the string converted to lowercase.
|
| lstrip(self, chars=None, /)
| Return a copy of the string with leading whitespace removed.
|
| If chars is given and not None, remove characters in chars instead.
|
| partition(self, sep, /)
| Partition the string into three parts using the given separator.
|
| This will search for the separator in the string. If the separator is found,
| returns a 3-tuple containing the part before the separator, the separator
| itself, and the part after it.
|
| If the separator is not found, returns a 3-tuple containing the original string
| and two empty strings.
|
| removeprefix(self, prefix, /)
| Return a str with the given prefix string removed if present.
|
| If the string starts with the prefix string, return string[len(prefix):].
| Otherwise, return a copy of the original string.
|
| removesuffix(self, suffix, /)
| Return a str with the given suffix string removed if present.
|
| If the string ends with the suffix string and that suffix is not empty,
| return string[:-len(suffix)]. Otherwise, return a copy of the original
| string.
|
| replace(self, old, new, count=-1, /)
| Return a copy with all occurrences of substring old replaced by new.
|
| count
| Maximum number of occurrences to replace.
| -1 (the default value) means replace all occurrences.
|
| If the optional argument count is given, only the first count occurrences are
| replaced.
|
| rfind(...)
| S.rfind(sub[, start[, end]]) -> int
|
| Return the highest index in S where substring sub is found,
| such that sub is contained within S[start:end]. Optional
| arguments start and end are interpreted as in slice notation.
|
| Return -1 on failure.
|
| rindex(...)
| S.rindex(sub[, start[, end]]) -> int
|
| Return the highest index in S where substring sub is found,
| such that sub is contained within S[start:end]. Optional
| arguments start and end are interpreted as in slice notation.
|
| Raises ValueError when the substring is not found.
|
| rjust(self, width, fillchar=' ', /)
| Return a right-justified string of length width.
|
| Padding is done using the specified fill character (default is a space).
|
| rpartition(self, sep, /)
| Partition the string into three parts using the given separator.
|
| This will search for the separator in the string, starting at the end. If
| the separator is found, returns a 3-tuple containing the part before the
| separator, the separator itself, and the part after it.
|
| If the separator is not found, returns a 3-tuple containing two empty strings
| and the original string.
|
| rsplit(self, /, sep=None, maxsplit=-1)
| Return a list of the substrings in the string, using sep as the separator string.
|
| sep
| The separator used to split the string.
|
| When set to None (the default value), will split on any whitespace
| character (including \n \r \t \f and spaces) and will discard
| empty strings from the result.
| maxsplit
| Maximum number of splits.
| -1 (the default value) means no limit.
|
| Splitting starts at the end of the string and works to the front.
|
| rstrip(self, chars=None, /)
| Return a copy of the string with trailing whitespace removed.
|
| If chars is given and not None, remove characters in chars instead.
|
| split(self, /, sep=None, maxsplit=-1)
| Return a list of the substrings in the string, using sep as the separator string.
|
| sep
| The separator used to split the string.
|
| When set to None (the default value), will split on any whitespace
| character (including \n \r \t \f and spaces) and will discard
| empty strings from the result.
| maxsplit
| Maximum number of splits.
| -1 (the default value) means no limit.
|
| Splitting starts at the front of the string and works to the end.
|
| Note, str.split() is mainly useful for data that has been intentionally
| delimited. With natural text that includes punctuation, consider using
| the regular expression module.
|
| splitlines(self, /, keepends=False)
| Return a list of the lines in the string, breaking at line boundaries.
|
| Line breaks are not included in the resulting list unless keepends is given and
| true.
|
| startswith(...)
| S.startswith(prefix[, start[, end]]) -> bool
|
| Return True if S starts with the specified prefix, False otherwise.
| With optional start, test S beginning at that position.
| With optional end, stop comparing S at that position.
| prefix can also be a tuple of strings to try.
|
| strip(self, chars=None, /)
| Return a copy of the string with leading and trailing whitespace removed.
|
| If chars is given and not None, remove characters in chars instead.
|
| swapcase(self, /)
| Convert uppercase characters to lowercase and lowercase characters to uppercase.
|
| title(self, /)
| Return a version of the string where each word is titlecased.
|
| More specifically, words start with uppercased characters and all remaining
| cased characters have lower case.
|
| translate(self, table, /)
| Replace each character in the string using the given translation table.
|
| table
| Translation table, which must be a mapping of Unicode ordinals to
| Unicode ordinals, strings, or None.
|
| The table must implement lookup/indexing via __getitem__, for instance a
| dictionary or list. If this operation raises LookupError, the character is
| left untouched. Characters mapped to None are deleted.
|
| upper(self, /)
| Return a copy of the string converted to uppercase.
|
| zfill(self, width, /)
| Pad a numeric string with zeros on the left, to fill a field of the given width.
|
| The string is never truncated.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.str:
|
| maketrans(...)
| Return a translation table usable for str.translate().
|
| If there is only one argument, it must be a dictionary mapping Unicode
| ordinals (integers) or characters to Unicode ordinals, strings or None.
| Character keys will be then converted to ordinals.
| If there are two arguments, they must be strings of equal length, and
| in the resulting dictionary, each character in x will be mapped to the
| character at the same position in y. If there is a third argument, it
| must be a string, whose characters will be mapped to None in the result.
|
| ----------------------------------------------------------------------
| Methods inherited from enum.Enum:
|
| __dir__(self)
| Returns public methods and other interesting attributes.
|
| __init__(self, *args, **kwds)
| Initialize self. See help(type(self)) for accurate signature.
|
| __reduce_ex__(self, proto)
| Helper for pickle.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from enum.Enum:
|
| name
| The name of the Enum member.
|
| value
| The value of the Enum member.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from enum.EnumType:
|
| __members__
| Returns a mapping of member name->value.
|
| This mapping lists all enum members, including aliases. Note that this
| is a read-only view of the internal mapping.
class TokenPatternSchema(pydantic.main.BaseModel)
| TokenPatternSchema(*, pattern: Annotated[List[spacy.schemas.TokenPattern], MinLen(min_length=1)]) -> None
|
| Method resolution order:
| TokenPatternSchema
| pydantic.main.BaseModel
| builtins.object
|
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'pattern': typing.List[spacy.schemas.TokenPattern]}
|
| __class_vars__ = set()
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'definitions': [{'cls': <class 'spacy.sche...
|
| __pydantic_custom_init__ = False
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {'pattern': FieldInfo(annotation=List[TokenPatte...
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = None
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=PolymorphismTram...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="TokenPatternSchema", v...
|
| __signature__ = <Signature (*, pattern: Annotated[List[spacy.schemas.T...
|
| model_config = {'extra': 'forbid'}
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __init__(self, /, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_args__(self) -> '_repr.ReprArgs'
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| 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(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]'
|
| json(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, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| 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.
|
| Returns:
| New model instance.
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| 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.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| from_orm(obj: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| 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.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| 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.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| 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.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_obj(obj: 'Any') -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {'pattern': FieldInfo(annotation=List[TokenPattern], re...
class TokenPatternString(pydantic.main.BaseModel)
| TokenPatternString(*, regex: Union[Annotated[str, Strict(strict=True)], spacy.schemas.TokenPatternString, NoneType] = None, IN: Optional[List[Annotated[str, Strict(strict=True)]]] = None, not_in: Optional[List[Annotated[str, Strict(strict=True)]]] = None, is_subset: Optional[List[Annotated[str, Strict(strict=True)]]] = None, is_superset: Optional[List[Annotated[str, Strict(strict=True)]]] = None, intersects: Optional[List[Annotated[str, Strict(strict=True)]]] = None, fuzzy: Union[Annotated[str, Strict(strict=True)], spacy.schemas.TokenPatternString, NoneType] = None, fuzzy1: Union[Annotated[str, Strict(strict=True)], spacy.schemas.TokenPatternString, NoneType] = None, fuzzy2: Union[Annotated[str, Strict(strict=True)], spacy.schemas.TokenPatternString, NoneType] = None, fuzzy3: Union[Annotated[str, Strict(strict=True)], spacy.schemas.TokenPatternString, NoneType] = None, fuzzy4: Union[Annotated[str, Strict(strict=True)], spacy.schemas.TokenPatternString, NoneType] = None, fuzzy5: Union[Annotated[str, Strict(strict=True)], spacy.schemas.TokenPatternString, NoneType] = None, fuzzy6: Union[Annotated[str, Strict(strict=True)], spacy.schemas.TokenPatternString, NoneType] = None, fuzzy7: Union[Annotated[str, Strict(strict=True)], spacy.schemas.TokenPatternString, NoneType] = None, fuzzy8: Union[Annotated[str, Strict(strict=True)], spacy.schemas.TokenPatternString, NoneType] = None, fuzzy9: Union[Annotated[str, Strict(strict=True)], spacy.schemas.TokenPatternString, NoneType] = None) -> None
|
| Method resolution order:
| TokenPatternString
| pydantic.main.BaseModel
| builtins.object
|
| Class methods defined here:
|
| raise_for_none(v)
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'FUZZY': typing.Union[typing.Annotated[str, Strict(...
|
| __class_vars__ = set()
|
| __private_attributes__ = {}
|
| __pydantic_complete__ = True
|
| __pydantic_computed_fields__ = {}
|
| __pydantic_core_schema__ = {'definitions': [{'cls': <class 'spacy.sche...
|
| __pydantic_custom_init__ = False
|
| __pydantic_decorators__ = DecoratorInfos(validators={}, field_validato...
|
| __pydantic_extra_info__ = None
|
| __pydantic_fields__ = {'FUZZY': FieldInfo(annotation=Union[Annotated[s...
|
| __pydantic_generic_metadata__ = {'args': (), 'origin': None, 'paramete...
|
| __pydantic_parent_namespace__ = None
|
| __pydantic_post_init__ = None
|
| __pydantic_serializer__ = SchemaSerializer(serializer=Recursive(
| D...
|
| __pydantic_setattr_handlers__ = {}
|
| __pydantic_validator__ = SchemaValidator(title="TokenPatternString", v...
|
| __signature__ = <Signature (*, regex: Union[Annotated[str, Stric...as....
|
| model_config = {'extra': 'forbid', 'populate_by_name': True, 'validate...
|
| ----------------------------------------------------------------------
| Methods inherited from pydantic.main.BaseModel:
|
| __copy__(self) -> 'Self'
| Returns a shallow copy of the model.
|
| __deepcopy__(self, memo: 'dict[int, Any] | None' = None) -> 'Self'
| Returns a deep copy of the model.
|
| __delattr__(self, item: 'str') -> 'Any'
| Implement delattr(self, name).
|
| __eq__(self, other: 'Any') -> 'bool'
| Return self==value.
|
| __getattr__(self, item: 'str') -> 'Any'
|
| __getstate__(self) -> 'dict[Any, Any]'
| Helper for pickle.
|
| __init__(self, /, **data: 'Any') -> 'None'
| Create a new model by parsing and validating input data from keyword arguments.
|
| Raises [`ValidationError`][pydantic_core.ValidationError] if the input data cannot be
| validated to form a valid model.
|
| `self` is explicitly positional-only to allow `self` as a field name.
|
| __iter__(self) -> 'TupleGenerator'
| So `dict(model)` works.
|
| __pretty__(self, fmt: 'Callable[[Any], Any]', **kwargs: 'Any') -> 'Generator[Any]' from pydantic._internal._repr.Representation
| Used by devtools (https://python-devtools.helpmanual.io/) to pretty print objects.
|
| __replace__(self, **changes: 'Any') -> 'Self'
| # Because we make use of `@dataclass_transform()`, `__replace__` is already synthesized by
| # type checkers, so we define the implementation in this `if not TYPE_CHECKING:` block:
|
| __repr__(self) -> 'str'
| Return repr(self).
|
| __repr_args__(self) -> '_repr.ReprArgs'
|
| __repr_name__(self) -> 'str' from pydantic._internal._repr.Representation
| Name of the instance's class, used in __repr__.
|
| __repr_recursion__(self, object: 'Any') -> 'str' from pydantic._internal._repr.Representation
| Returns the string representation of a recursive object.
|
| __repr_str__(self, join_str: 'str') -> 'str' from pydantic._internal._repr.Representation
|
| __rich_repr__(self) -> 'RichReprResult' from pydantic._internal._repr.Representation
| Used by Rich (https://rich.readthedocs.io/en/stable/pretty.html) to pretty print objects.
|
| __setattr__(self, name: 'str', value: 'Any') -> 'None'
| Implement setattr(self, name, value).
|
| __setstate__(self, state: 'dict[Any, Any]') -> 'None'
|
| __str__(self) -> 'str'
| Return str(self).
|
| copy(self, *, include: 'AbstractSetIntStr | MappingIntStrAny | None' = None, exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None, update: 'Dict[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| Returns a copy of the model.
|
| !!! warning "Deprecated"
| This method is now deprecated; use `model_copy` instead.
|
| If you need `include` or `exclude`, use:
|
| ```python {test="skip" lint="skip"}
| data = self.model_dump(include=include, exclude=exclude, round_trip=True)
| data = {**data, **(update or {})}
| copied = self.model_validate(data)
| ```
|
| 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(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]'
|
| json(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, encoder: 'Callable[[Any], Any] | None' = PydanticUndefined, models_as_dict: 'bool' = PydanticUndefined, **dumps_kwargs: 'Any') -> 'str'
|
| model_copy(self, *, update: 'Mapping[str, Any] | None' = None, deep: 'bool' = False) -> 'Self'
| !!! abstract "Usage Documentation"
| [`model_copy`](../concepts/models.md#model-copy)
|
| Returns a copy of the model.
|
| !!! note
| The underlying instance's [`__dict__`][object.__dict__] attribute is copied. This
| might have unexpected side effects if you store anything in it, on top of the model
| fields (e.g. the value of [cached properties][functools.cached_property]).
|
| 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.
|
| Returns:
| New model instance.
|
| model_dump(self, *, mode: "Literal['json', 'python'] | str" = 'python', include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'dict[str, Any]'
| !!! abstract "Usage Documentation"
| [`model_dump`](../concepts/serialization.md#python-mode)
|
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A dictionary representation of the model.
|
| model_dump_json(self, *, indent: 'int | None' = None, ensure_ascii: 'bool' = False, include: 'IncEx | None' = None, exclude: 'IncEx | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, exclude_unset: 'bool' = False, exclude_defaults: 'bool' = False, exclude_none: 'bool' = False, exclude_computed_fields: 'bool' = False, round_trip: 'bool' = False, warnings: "bool | Literal['none', 'warn', 'error']" = True, fallback: 'Callable[[Any], Any] | None' = None, serialize_as_any: 'bool' = False, polymorphic_serialization: 'bool | None' = None) -> 'str'
| !!! abstract "Usage Documentation"
| [`model_dump_json`](../concepts/serialization.md#json-mode)
|
| 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.
| ensure_ascii: If `True`, the output is guaranteed to have all incoming non-ASCII characters escaped.
| If `False` (the default), these characters will be output as-is.
| 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`.
| exclude_computed_fields: Whether to exclude computed fields.
| While this can be useful for round-tripping, it is usually recommended to use the dedicated
| `round_trip` parameter instead.
| 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].
| fallback: A function to call when an unknown value is encountered. If not provided,
| a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
| serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
| polymorphic_serialization: Whether to use model and dataclass polymorphic serialization for this call.
|
| Returns:
| A JSON string representation of the model.
|
| model_post_init(self, context: 'Any', /) -> 'None'
| Override this method to perform additional initialization after `__init__` and `model_construct`.
| This is useful if you want to do some validation that requires the entire model to be initialized.
|
| ----------------------------------------------------------------------
| Class methods inherited from pydantic.main.BaseModel:
|
| __class_getitem__(typevar_values: 'type[Any] | tuple[type[Any], ...]') -> 'type[BaseModel] | _forward_ref.PydanticRecursiveRef'
|
| __get_pydantic_core_schema__(source: 'type[BaseModel]', handler: 'GetCoreSchemaHandler', /) -> 'CoreSchema'
|
| __get_pydantic_json_schema__(core_schema: 'CoreSchema', handler: 'GetJsonSchemaHandler', /) -> 'JsonSchemaValue'
| Hook into generating the model's JSON schema.
|
| Args:
| core_schema: A `pydantic-core` CoreSchema.
| You can ignore this argument and call the handler with a new CoreSchema,
| wrap this CoreSchema (`{'type': 'nullable', 'schema': current_schema}`),
| or just call the handler with the original schema.
| handler: Call into Pydantic's internal JSON schema generation.
| This will raise a `pydantic.errors.PydanticInvalidForJsonSchema` if JSON schema
| generation fails.
| Since this gets called by `BaseModel.model_json_schema` you can override the
| `schema_generator` argument to that function to change JSON schema generation globally
| for a type.
|
| Returns:
| A JSON schema, as a Python object.
|
| __pydantic_init_subclass__(**kwargs: 'Any') -> 'None'
| This is intended to behave just like `__init_subclass__`, but is called by `ModelMetaclass`
| only after basic class initialization is complete. In particular, attributes like `model_fields` will
| be present when this is called, but forward annotations are not guaranteed to be resolved yet,
| meaning that creating an instance of the class may fail.
|
| This is necessary because `__init_subclass__` will always be called by `type.__new__`,
| and it would require a prohibitively large refactor to the `ModelMetaclass` to ensure that
| `type.__new__` was called in such a manner that the class would already be sufficiently initialized.
|
| This will receive the same `kwargs` that would be passed to the standard `__init_subclass__`, namely,
| any kwargs passed to the class definition that aren't used internally by Pydantic.
|
| Args:
| **kwargs: Any keyword arguments passed to the class definition that aren't used internally
| by Pydantic.
|
| Note:
| You may want to override [`__pydantic_on_complete__()`][pydantic.main.BaseModel.__pydantic_on_complete__]
| instead, which is called once the class and its fields are fully initialized and ready for validation.
|
| __pydantic_on_complete__() -> 'None'
| This is called once the class and its fields are fully initialized and ready to be used.
|
| This typically happens when the class is created (just before
| [`__pydantic_init_subclass__()`][pydantic.main.BaseModel.__pydantic_init_subclass__] is called on the superclass),
| except when forward annotations are used that could not immediately be resolved.
| In that case, it will be called later, when the model is rebuilt automatically or explicitly using
| [`model_rebuild()`][pydantic.main.BaseModel.model_rebuild].
|
| construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
|
| from_orm(obj: 'Any') -> 'Self'
|
| model_construct(_fields_set: 'set[str] | None' = None, **values: 'Any') -> 'Self'
| 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.
|
| model_json_schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: 'JsonSchemaMode' = 'validation', *, union_format: "Literal['any_of', 'primitive_type_array']" = 'any_of') -> 'dict[str, Any]'
| Generates a JSON schema for a model class.
|
| Args:
| by_alias: Whether to use attribute aliases or not.
| ref_template: The reference template.
| union_format: The format to use when combining schemas from unions together. Can be one of:
|
| - `'any_of'`: Use the [`anyOf`](https://json-schema.org/understanding-json-schema/reference/combining#anyOf)
| keyword to combine schemas (the default).
| - `'primitive_type_array'`: Use the [`type`](https://json-schema.org/understanding-json-schema/reference/type)
| keyword as an array of strings, containing each type of the combination. If any of the schemas is not a primitive
| type (`string`, `boolean`, `null`, `integer` or `number`) or contains constraints/metadata, falls back to
| `any_of`.
| 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.
|
| model_parametrized_name(params: 'tuple[type[Any], ...]') -> 'str'
| Compute the class name for parametrizations of generic classes.
|
| This method can be overridden to achieve a custom naming scheme for generic BaseModels.
|
| Args:
| params: Tuple of types of the class. Given a generic class
| `Model` with 2 type variables and a concrete model `Model[str, int]`,
| the value `(str, int)` would be passed to `params`.
|
| Returns:
| String representing the new class where `params` are passed to `cls` as type variables.
|
| Raises:
| TypeError: Raised when trying to generate concrete names for non-generic models.
|
| model_rebuild(*, force: 'bool' = False, raise_errors: 'bool' = True, _parent_namespace_depth: 'int' = 2, _types_namespace: 'MappingNamespace | None' = None) -> 'bool | None'
| Try to rebuild the pydantic-core schema for the model.
|
| This may be necessary when one of the annotations is a ForwardRef which could not be resolved during
| the initial attempt to build the schema, and automatic rebuilding fails.
|
| Args:
| force: Whether to force the rebuilding of the model schema, defaults to `False`.
| raise_errors: Whether to raise errors, defaults to `True`.
| _parent_namespace_depth: The depth level of the parent namespace, defaults to 2.
| _types_namespace: The types namespace, defaults to `None`.
|
| Returns:
| Returns `None` if the schema is already "complete" and rebuilding was not required.
| If rebuilding _was_ required, returns `True` if rebuilding was successful, otherwise `False`.
|
| model_validate(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, from_attributes: 'bool | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| Validate a pydantic model instance.
|
| Args:
| obj: The object to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| from_attributes: Whether to extract data from object attributes.
| context: Additional context to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Raises:
| ValidationError: If the object could not be validated.
|
| Returns:
| The validated model instance.
|
| model_validate_json(json_data: 'str | bytes | bytearray', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| !!! abstract "Usage Documentation"
| [JSON Parsing](../concepts/json.md#json-parsing)
|
| Validate the given JSON data against the Pydantic model.
|
| Args:
| json_data: The JSON data to validate.
| strict: Whether to enforce types strictly.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| Raises:
| ValidationError: If `json_data` is not a JSON string or the object could not be validated.
|
| model_validate_strings(obj: 'Any', *, strict: 'bool | None' = None, extra: 'ExtraValues | None' = None, context: 'Any | None' = None, by_alias: 'bool | None' = None, by_name: 'bool | None' = None) -> 'Self'
| 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.
| extra: Whether to ignore, allow, or forbid extra data during model validation.
| See the [`extra` configuration value][pydantic.ConfigDict.extra] for details.
| context: Extra variables to pass to the validator.
| by_alias: Whether to use the field's alias when validating against the provided input data.
| by_name: Whether to use the field's name when validating against the provided input data.
|
| Returns:
| The validated Pydantic model.
|
| parse_file(path: 'str | Path', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| parse_obj(obj: 'Any') -> 'Self'
|
| parse_raw(b: 'str | bytes', *, content_type: 'str | None' = None, encoding: 'str' = 'utf8', proto: 'DeprecatedParseProtocol | None' = None, allow_pickle: 'bool' = False) -> 'Self'
|
| schema(by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}') -> 'Dict[str, Any]'
|
| schema_json(*, by_alias: 'bool' = True, ref_template: 'str' = '#/$defs/{model}', **dumps_kwargs: 'Any') -> 'str'
|
| update_forward_refs(**localns: 'Any') -> 'None'
|
| validate(value: 'Any') -> 'Self'
|
| ----------------------------------------------------------------------
| Readonly properties inherited from pydantic.main.BaseModel:
|
| __fields_set__
|
| model_extra
| Get extra fields set during validation.
|
| Returns:
| A dictionary of extra fields, or `None` if `config.extra` is not set to `"allow"`.
|
| model_fields_set
| Returns the set of fields that have been explicitly set on this model instance.
|
| Returns:
| A set of strings representing the fields that have been set,
| i.e. that were not filled from defaults.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from pydantic.main.BaseModel:
|
| __dict__
| dictionary for instance variables
|
| __pydantic_extra__
|
| __pydantic_fields_set__
|
| __pydantic_private__
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from pydantic.main.BaseModel:
|
| __hash__ = None
|
| __pydantic_root_model__ = False
|
| model_computed_fields = {}
|
| model_fields = {'FUZZY': FieldInfo(annotation=Union[Annotated[str, Str...
FUNCTIONS
get_arg_model(func: Callable, *, exclude: Iterable[str] = (), name: str = 'ArgModel', strict: bool = True) -> type[pydantic.main.BaseModel]
Generate a pydantic model for function arguments.
func (Callable): The function to generate the schema for.
exclude (Iterable[str]): Parameter names to ignore.
name (str): Name of created model class.
strict (bool): Don't allow extra arguments if no variable keyword arguments
are allowed on the function.
RETURNS (type[BaseModel]): A pydantic model.
validate(schema: Type[pydantic.main.BaseModel], obj: Dict[str, Any]) -> List[str]
Validate data against a given pydantic schema.
obj (Dict[str, Any]): JSON-serializable data to validate.
schema (pydantic.BaseModel): The schema to validate against.
RETURNS (List[str]): A list of error messages, if available.
validate_init_settings(func: Callable, settings: Dict[str, Any], *, section: Optional[str] = None, name: str = '', exclude: Iterable[str] = ('get_examples', 'nlp')) -> Dict[str, Any]
Validate initialization settings against the expected arguments in
the method signature. Will parse values if possible (e.g. int to string)
and return the updated settings dict. Will raise a ConfigValidationError
if types don't match or required values are missing.
func (Callable): The initialize method of a given component etc.
settings (Dict[str, Any]): The settings from the respective [initialize] block.
section (str): Initialize section, for error message.
name (str): Name of the block in the section.
exclude (Iterable[str]): Parameter names to exclude from schema.
RETURNS (Dict[str, Any]): The validated settings.
validate_token_pattern(obj: list) -> List[str]
DATA
ArgSchemaConfig = {'arbitrary_types_allowed': True, 'extra': 'forbid'}
ArgSchemaConfigExtra = {'arbitrary_types_allowed': True, 'extra': 'for...
Batcher = typing.Union[typing.Callable[[typing.Iterable[~I...ing.List[...
CONFIG_SCHEMAS = {'initialize': <class 'spacy.schemas.ConfigSchemaInit...
Callable = typing.Callable
Deprecated alias to collections.abc.Callable.
Callable[[int], str] signifies a function that takes a single
parameter of type int and returns a str.
The subscription syntax must always be used with exactly two
values: the argument list and the return type.
The argument list must be a list of types, a ParamSpec,
Concatenate or ellipsis. The return type must be a single type.
There is no syntax to indicate optional or keyword arguments;
such function types are rarely used as callback types.
Dict = typing.Dict
A generic version of dict.
IobValue = typing.Literal['', 'I', 'O', 'B', 0, 1, 2, 3]
ItemT = ~ItemT
Iterable = typing.Iterable
A generic version of collections.abc.Iterable.
List = typing.List
A generic version of list.
Literal = typing.Literal
Special typing form to define literal types (a.k.a. value types).
This form can be used to indicate to type checkers that the corresponding
variable or function parameter has a value equivalent to the provided
literal (or one of several literals)::
def validate_simple(data: Any) -> Literal[True]: # always returns True
...
MODE = Literal['r', 'rb', 'w', 'wb']
def open_helper(file: str, mode: MODE) -> str:
...
open_helper('/some/path', 'r') # Passes type check
open_helper('/other/path', 'typo') # Error in type checker
Literal[...] cannot be subclassed. At runtime, an arbitrary value
is allowed as type argument to Literal[...], but type checkers may
impose restrictions.
Logger = typing.Union[typing.Callable[[ForwardRef('Langua... typing.Ca...
NAMES = ['', 'IS_ALPHA', 'IS_ASCII', 'IS_DIGIT', 'IS_LOWER', 'IS_PUNCT...
NumberValue = typing.Union[spacy.schemas.TokenPatternNumber, t...)], t...
Optional = typing.Optional
Optional[X] is equivalent to Union[X, None].
Reader = typing.Union[typing.Callable[[ForwardRef('Langua...rdRef('Exa...
StrictBool = typing.Annotated[bool, Strict(strict=True)]
StrictFloat = typing.Annotated[float, Strict(strict=True)]
StrictInt = typing.Annotated[int, Strict(strict=True)]
StrictStr = typing.Annotated[str, Strict(strict=True)]
StringValue = typing.Union[spacy.schemas.TokenPatternString, typing.An...
TYPE_CHECKING = False
TokenPatternOperator = typing.Union[spacy.schemas.TokenPatternOperator...
TokenPatternOperatorMinMax = typing.Annotated[str, StringConstraints(s...
Tuple = typing.Tuple
Deprecated alias to builtins.tuple.
Tuple[X, Y] is the cross-product type of X and Y.
Example: Tuple[T1, T2] is a tuple of two elements corresponding
to type variables T1 and T2. Tuple[int, float, str] is a tuple
of an int, a float and a string.
To specify a variable-length tuple of homogeneous type, use Tuple[T, ...].
Type = typing.Type
Deprecated alias to builtins.type.
builtins.type or typing.Type can be used to annotate class objects.
For example, suppose we have the following classes::
class User: ... # Abstract base for User classes
class BasicUser(User): ...
class ProUser(User): ...
class TeamUser(User): ...
And a function that takes a class argument that's a subclass of
User and returns an instance of the corresponding class::
def new_user[U](user_class: Type[U]) -> U:
user = user_class()
# (Here we could write the user object to a database)
return user
joe = new_user(BasicUser)
At this point the type checker knows that joe has type BasicUser.
UnderscoreValue = typing.Union[spacy.schemas.TokenPatternString, s.......
Union = typing.Union
Union type; Union[X, Y] means either X or Y.
On Python 3.10 and higher, the | operator
can also be used to denote unions;
X | Y means the same thing to the type checker as Union[X, Y].
To define a union, use e.g. Union[int, str]. Details:
- The arguments must be types and there must be at least one.
- None as an argument is a special case and is replaced by
type(None).
- Unions of unions are flattened, e.g.::
assert Union[Union[int, str], float] == Union[int, str, float]
- Unions of a single argument vanish, e.g.::
assert Union[int] == int # The constructor actually returns int
- Redundant arguments are skipped, e.g.::
assert Union[int, str, int] == Union[int, str]
- When comparing unions, the argument order is ignored, e.g.::
assert Union[int, str] == Union[str, int]
- You cannot subclass or instantiate a union.
- You can use Optional[X] as a shorthand for Union[X, None].
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\schemas.py
spacy.scorer
Python Library Documentation: module spacy.scorer in spacy
NAME
spacy.scorer
CLASSES
builtins.object
PRFScore
ROCAUCScore
Scorer
class PRFScore(builtins.object)
| PRFScore(*, tp: int = 0, fp: int = 0, fn: int = 0) -> None
|
| A precision / recall / F score.
|
| Methods defined here:
|
| __add__(self, other)
|
| __iadd__(self, other)
|
| __init__(self, *, tp: int = 0, fp: int = 0, fn: int = 0) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __len__(self) -> int
|
| score_set(self, cand: set, gold: set) -> None
|
| to_dict(self) -> Dict[str, float]
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| fscore
|
| precision
|
| recall
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class ROCAUCScore(builtins.object)
| ROCAUCScore() -> None
|
| An AUC ROC score. This is only defined for binary classification.
| Use the method is_binary before calculating the score, otherwise it
| may throw an error.
|
| Methods defined here:
|
| __init__(self) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| is_binary(self)
|
| score_set(self, cand, gold) -> None
|
| ----------------------------------------------------------------------
| Readonly properties defined here:
|
| score
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Scorer(builtins.object)
| Scorer(nlp: Optional[ForwardRef('Language')] = None, default_lang: str = 'xx', default_pipeline: Iterable[str] = ('senter', 'tagger', 'morphologizer', 'parser', 'ner', 'textcat'), **cfg) -> None
|
| Compute evaluation scores.
|
| Methods defined here:
|
| __init__(self, nlp: Optional[ForwardRef('Language')] = None, default_lang: str = 'xx', default_pipeline: Iterable[str] = ('senter', 'tagger', 'morphologizer', 'parser', 'ner', 'textcat'), **cfg) -> None
| Initialize the Scorer.
|
| DOCS: https://spacy.io/api/scorer#init
|
| score(self, examples: Iterable[spacy.training.example.Example], *, per_component: bool = False) -> Dict[str, Any]
| Evaluate a list of Examples.
|
| examples (Iterable[Example]): The predicted annotations + correct annotations.
| per_component (bool): Whether to return the scores keyed by component
| name. Defaults to False.
| RETURNS (Dict): A dictionary of scores.
|
| DOCS: https://spacy.io/api/scorer#score
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| score_cats(examples: Iterable[spacy.training.example.Example], attr: str, *, getter: Callable[[spacy.tokens.doc.Doc, str], Any] = <built-in function getattr>, labels: Iterable[str] = [], multi_label: bool = True, positive_label: Optional[str] = None, threshold: Optional[float] = None, **cfg) -> Dict[str, Any]
| Returns PRF and ROC AUC scores for a doc-level attribute with a
| dict with scores for each label like Doc.cats. The reported overall
| score depends on the scorer settings.
|
| examples (Iterable[Example]): Examples to score
| attr (str): The attribute to score.
| getter (Callable[[Doc, str], Any]): Defaults to getattr. If provided,
| getter(doc, attr) should return the values for the individual doc.
| labels (Iterable[str]): The set of possible labels. Defaults to [].
| multi_label (bool): Whether the attribute allows multiple labels.
| Defaults to True. When set to False (exclusive labels), missing
| gold labels are interpreted as 0.0 and the threshold is set to 0.0.
| positive_label (str): The positive label for a binary task with
| exclusive classes. Defaults to None.
| threshold (float): Cutoff to consider a prediction "positive". Defaults
| to 0.5 for multi-label, and 0.0 (i.e. whatever's highest scoring)
| otherwise.
| RETURNS (Dict[str, Any]): A dictionary containing the scores, with
| inapplicable scores as None:
| for all:
| attr_score (one of attr_micro_f / attr_macro_f / attr_macro_auc),
| attr_score_desc (text description of the overall score),
| attr_micro_p,
| attr_micro_r,
| attr_micro_f,
| attr_macro_p,
| attr_macro_r,
| attr_macro_f,
| attr_macro_auc,
| attr_f_per_type,
| attr_auc_per_type
|
| DOCS: https://spacy.io/api/scorer#score_cats
|
| score_deps(examples: Iterable[spacy.training.example.Example], attr: str, *, getter: Callable[[spacy.tokens.token.Token, str], Any] = <built-in function getattr>, head_attr: str = 'head', head_getter: Callable[[spacy.tokens.token.Token, str], spacy.tokens.token.Token] = <built-in function getattr>, ignore_labels: Iterable[str] = [], missing_values: Set[Any] = frozenset({None, 0, ''}), **cfg) -> Dict[str, Any]
| Returns the UAS, LAS, and LAS per type scores for dependency
| parses.
|
| examples (Iterable[Example]): Examples to score
| attr (str): The attribute containing the dependency label.
| getter (Callable[[Token, str], Any]): Defaults to getattr. If provided,
| getter(token, attr) should return the value of the attribute for an
| individual token.
| head_attr (str): The attribute containing the head token. Defaults to
| 'head'.
| head_getter (Callable[[Token, str], Token]): Defaults to getattr. If provided,
| head_getter(token, attr) should return the value of the head for an
| individual token.
| ignore_labels (Tuple): Labels to ignore while scoring (e.g., punct).
| missing_values (Set[Any]): Attribute values to treat as missing annotation
| in the reference annotation.
| RETURNS (Dict[str, Any]): A dictionary containing the scores:
| attr_uas, attr_las, and attr_las_per_type.
|
| DOCS: https://spacy.io/api/scorer#score_deps
|
| score_links(examples: Iterable[spacy.training.example.Example], *, negative_labels: Iterable[str], **cfg) -> Dict[str, Any]
| Returns PRF for predicted links on the entity level.
| To disentangle the performance of the NEL from the NER,
| this method only evaluates NEL links for entities that overlap
| between the gold reference and the predictions.
|
| examples (Iterable[Example]): Examples to score
| negative_labels (Iterable[str]): The string values that refer to no annotation (e.g. "NIL")
| RETURNS (Dict[str, Any]): A dictionary containing the scores.
|
| DOCS: https://spacy.io/api/scorer#score_links
|
| score_spans(examples: Iterable[spacy.training.example.Example], attr: str, *, getter: Callable[[spacy.tokens.doc.Doc, str], Iterable[spacy.tokens.span.Span]] = <built-in function getattr>, has_annotation: Optional[Callable[[spacy.tokens.doc.Doc], bool]] = None, labeled: bool = True, allow_overlap: bool = False, **cfg) -> Dict[str, Any]
| Returns PRF scores for labeled spans.
|
| examples (Iterable[Example]): Examples to score
| attr (str): The attribute to score.
| getter (Callable[[Doc, str], Iterable[Span]]): Defaults to getattr. If
| provided, getter(doc, attr) should return the spans for the
| individual doc.
| has_annotation (Optional[Callable[[Doc], bool]]) should return whether a `Doc`
| has annotation for this `attr`. Docs without annotation are skipped for
| scoring purposes.
| labeled (bool): Whether or not to include label information in
| the evaluation. If set to 'False', two spans will be considered
| equal if their start and end match, irrespective of their label.
| allow_overlap (bool): Whether or not to allow overlapping spans.
| If set to 'False', the alignment will automatically resolve conflicts.
| RETURNS (Dict[str, Any]): A dictionary containing the PRF scores under
| the keys attr_p/r/f and the per-type PRF scores under attr_per_type.
|
| DOCS: https://spacy.io/api/scorer#score_spans
|
| score_token_attr(examples: Iterable[spacy.training.example.Example], attr: str, *, getter: Callable[[spacy.tokens.token.Token, str], Any] = <built-in function getattr>, missing_values: Set[Any] = frozenset({None, 0, ''}), **cfg) -> Dict[str, Any]
| Returns an accuracy score for a token-level attribute.
|
| examples (Iterable[Example]): Examples to score
| attr (str): The attribute to score.
| getter (Callable[[Token, str], Any]): Defaults to getattr. If provided,
| getter(token, attr) should return the value of the attribute for an
| individual token.
| missing_values (Set[Any]): Attribute values to treat as missing annotation
| in the reference annotation.
| RETURNS (Dict[str, Any]): A dictionary containing the accuracy score
| under the key attr_acc.
|
| DOCS: https://spacy.io/api/scorer#score_token_attr
|
| score_token_attr_per_feat(examples: Iterable[spacy.training.example.Example], attr: str, *, getter: Callable[[spacy.tokens.token.Token, str], Any] = <built-in function getattr>, missing_values: Set[Any] = frozenset({None, 0, ''}), **cfg) -> Dict[str, Any]
| Return micro PRF and PRF scores per feat for a token attribute in
| UFEATS format.
|
| examples (Iterable[Example]): Examples to score
| attr (str): The attribute to score.
| getter (Callable[[Token, str], Any]): Defaults to getattr. If provided,
| getter(token, attr) should return the value of the attribute for an
| individual token.
| missing_values (Set[Any]): Attribute values to treat as missing
| annotation in the reference annotation.
| RETURNS (dict): A dictionary containing the micro PRF scores under the
| key attr_micro_p/r/f and the per-feat PRF scores under
| attr_per_feat.
|
| score_tokenization(examples: Iterable[spacy.training.example.Example], **cfg) -> Dict[str, Any]
| Returns accuracy and PRF scores for tokenization.
| * token_acc: # correct tokens / # gold tokens
| * token_p/r/f: PRF for token character spans
|
| examples (Iterable[Example]): Examples to score
| RETURNS (Dict[str, Any]): A dictionary containing the scores
| token_acc/p/r/f.
|
| DOCS: https://spacy.io/api/scorer#score_tokenization
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
get_ner_prf(examples: Iterable[spacy.training.example.Example], **kwargs) -> Dict[str, Any]
Compute micro-PRF and per-entity PRF scores for a sequence of examples.
trapezoid(y, x=None, dx=1.0, axis=-1)
Integrate along the given axis using the composite trapezoidal rule.
If `x` is provided, the integration happens in sequence along its
elements - they are not sorted.
Integrate `y` (`x`) along each 1d slice on the given axis, compute
:math:`\int y(x) dx`.
When `x` is specified, this integrates along the parametric curve,
computing :math:`\int_t y(t) dt =
\int_t y(t) \left.\frac{dx}{dt}\right|_{x=x(t)} dt`.
Parameters
----------
y : array_like
Input array to integrate.
x : array_like, optional
The sample points corresponding to the `y` values. If `x` is None,
the sample points are assumed to be evenly spaced `dx` apart. The
default is None.
dx : scalar, optional
The spacing between sample points when `x` is None. The default is 1.
axis : int, optional
The axis along which to integrate.
Returns
-------
trapezoid : float or ndarray
Definite integral of `y` = n-dimensional array as approximated along
a single axis by the trapezoidal rule. If `y` is a 1-dimensional array,
then the result is a float. If `n` is greater than 1, then the result
is an `n`-1 dimensional array.
See Also
--------
cumulative_trapezoid, simpson, romb
Notes
-----
Image [2]_ illustrates trapezoidal rule -- y-axis locations of points
will be taken from `y` array, by default x-axis distances between
points will be 1.0, alternatively they can be provided with `x` array
or with `dx` scalar. Return value will be equal to combined area under
the red lines.
References
----------
.. [1] Wikipedia page: https://en.wikipedia.org/wiki/Trapezoidal_rule
.. [2] Illustration image:
https://en.wikipedia.org/wiki/File:Composite_trapezoidal_rule_illustration.png
Examples
--------
Use the trapezoidal rule on evenly spaced points:
>>> import numpy as np
>>> from scipy import integrate
>>> integrate.trapezoid([1, 2, 3])
4.0
The spacing between sample points can be selected by either the
``x`` or ``dx`` arguments:
>>> integrate.trapezoid([1, 2, 3], x=[4, 6, 8])
8.0
>>> integrate.trapezoid([1, 2, 3], dx=2)
8.0
Using a decreasing ``x`` corresponds to integrating in reverse:
>>> integrate.trapezoid([1, 2, 3], x=[8, 6, 4])
-8.0
More generally ``x`` is used to integrate along a parametric curve. We can
estimate the integral :math:`\int_0^1 x^2 = 1/3` using:
>>> x = np.linspace(0, 1, num=50)
>>> y = x**2
>>> integrate.trapezoid(y, x)
0.33340274885464394
Or estimate the area of a circle, noting we repeat the sample which closes
the curve:
>>> theta = np.linspace(0, 2 * np.pi, num=1000, endpoint=True)
>>> integrate.trapezoid(np.cos(theta), x=np.sin(theta))
3.141571941375841
``trapezoid`` can be applied along a specified axis to do multiple
computations in one call:
>>> a = np.arange(6).reshape(2, 3)
>>> a
array([[0, 1, 2],
[3, 4, 5]])
>>> integrate.trapezoid(a, axis=0)
array([1.5, 2.5, 3.5])
>>> integrate.trapezoid(a, axis=1)
array([2., 8.])
DATA
Callable = typing.Callable
Deprecated alias to collections.abc.Callable.
Callable[[int], str] signifies a function that takes a single
parameter of type int and returns a str.
The subscription syntax must always be used with exactly two
values: the argument list and the return type.
The argument list must be a list of types, a ParamSpec,
Concatenate or ellipsis. The return type must be a single type.
There is no syntax to indicate optional or keyword arguments;
such function types are rarely used as callback types.
DEFAULT_PIPELINE = ('senter', 'tagger', 'morphologizer', 'parser', 'ne...
Dict = typing.Dict
A generic version of dict.
Iterable = typing.Iterable
A generic version of collections.abc.Iterable.
List = typing.List
A generic version of list.
MISSING_VALUES = frozenset({None, 0, ''})
Optional = typing.Optional
Optional[X] is equivalent to Union[X, None].
Set = typing.Set
A generic version of set.
TYPE_CHECKING = False
Tuple = typing.Tuple
Deprecated alias to builtins.tuple.
Tuple[X, Y] is the cross-product type of X and Y.
Example: Tuple[T1, T2] is a tuple of two elements corresponding
to type variables T1 and T2. Tuple[int, float, str] is a tuple
of an int, a float and a string.
To specify a variable-length tuple of homogeneous type, use Tuple[T, ...].
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\scorer.py
spacy.setup_default_warnings
Python Library Documentation: function setup_default_warnings in module spacy.errors setup_default_warnings()
spacy.strings
Python Library Documentation: module spacy.strings in spacy
NAME
spacy.strings
CLASSES
builtins.object
StringStore
class StringStore(builtins.object)
| StringStore(strings=None, freeze=False)
|
| Look up strings by 64-bit hashes.
|
| DOCS: https://spacy.io/api/stringstore
|
| Methods defined here:
|
| __contains__(...)
| StringStore.__contains__(self, string_or_id)
|
| Check whether a string or ID is in the store.
|
| string_or_id (str or int): The string to check.
| RETURNS (bool): Whether the store contains the string.
|
| __getitem__(...)
| StringStore.__getitem__(self, string_or_id)
|
| Retrieve a string from a given hash, or vice versa.
|
| string_or_id (bytes, str or uint64): The value to encode.
| Returns (str / uint64): The value to be retrieved.
|
| __init__(...)
| Create the StringStore.
|
| strings (iterable): A sequence of unicode strings to add to the store.
|
| __iter__(...)
| StringStore.__iter__(self)
|
| Iterate over the strings in the store, in order.
|
| YIELDS (str): A string in the store.
|
| __len__(...)
| StringStore.__len__(self)
|
| The number of strings in the store.
| if string in SYMBOLS_BY_STR:
| return SYMBOLS_BY_STR[string]
| else:
| return self._intern_str(string, allow_transient)
|
| RETURNS (int): The number of strings in the store.
|
| __reduce__(self)
| StringStore.__reduce__(self)
|
| add(self, string: 'str', allow_transient: 'Optional[bool]' = None) -> 'int'
| StringStore.add(self, string: str, allow_transient: Optional[bool] = None) -> int
|
| Add a string to the StringStore.
|
| string (str): The string to add.
| allow_transient (bool): Allow the string to be stored in the 'transient'
| map, which will be flushed at the end of the memory zone. Strings
| encountered during arbitrary text processing should be added
| with allow_transient=True, while labels and other strings used
| internally should not.
| RETURNS (uint64): The string's hash value.
|
| as_int(self, key)
| StringStore.as_int(self, key)
|
| If key is an int, return it; otherwise, get the int value.
|
| as_string(self, key)
| StringStore.as_string(self, key)
|
| If key is a string, return it; otherwise, get the string value.
|
| from_bytes(self, bytes_data, **kwargs)
| StringStore.from_bytes(self, bytes_data, **kwargs)
|
| Load state from a binary string.
|
| bytes_data (bytes): The data to load from.
| RETURNS (StringStore): The `StringStore` object.
|
| from_disk(self, path)
| StringStore.from_disk(self, path)
|
| Loads state from a directory. Modifies the object in place and
| returns it.
|
| path (str / Path): A path to a directory. Paths may be either
| strings or `Path`-like objects.
| RETURNS (StringStore): The modified `StringStore` object.
|
| memory_zone(self, mem: 'Optional[Pool]' = None) -> 'Pool'
| StringStore.memory_zone(self, mem: Optional[Pool] = None) -> Pool
|
| Begin a block where all resources allocated during the block will
| be freed at the end of it. If a resources was created within the
| memory zone block, accessing it outside the block is invalid.
| Behaviour of this invalid access is undefined. Memory zones should
| not be nested.
|
| The memory zone is helpful for services that need to process large
| volumes of text with a defined memory budget.
|
| to_bytes(self, **kwargs)
| StringStore.to_bytes(self, **kwargs)
|
| Serialize the current state to a binary string.
|
| RETURNS (bytes): The serialized form of the `StringStore` object.
|
| to_disk(self, path)
| StringStore.to_disk(self, path)
|
| Save the current state to a directory.
|
| path (str / Path): A path to a directory, which will be created if
| it doesn't exist. Paths may be either strings or Path-like objects.
|
| values(self) -> 'List[int]'
| StringStore.values(self) -> List[int]
|
| Iterate over the stored strings hashes in insertion order.
|
| RETURNS: A list of string hashs.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __pyx_vtable__ = <capsule object NULL>
FUNCTIONS
get_string_id(key)
get_string_id(key)
Get a string ID, handling the reserved symbols correctly. If the key is
already an ID, return it.
This function optimises for convenience over performance, so shouldn't be
used in tight loops.
hash_string(string)
hash_string(str string) -> hash_t
DATA
List = typing.List
A generic version of list.
Optional = typing.Optional
Optional[X] is equivalent to Union[X, None].
SYMBOLS_BY_INT = ['', 'IS_ALPHA', 'IS_ASCII', 'IS_DIGIT', 'IS_LOWER', ...
SYMBOLS_BY_STR = {'': 0, 'ADJ': 84, 'ADP': 85, 'ADV': 86, 'AUX': 87, '...
__pyx_capi__ = {'decode_Utf8Str': <capsule object "PyObject *(__pyx_t_...
__test__ = {}
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\strings.cp312-win_amd64.pyd
spacy.symbols
Python Library Documentation: module spacy.symbols in spacy
NAME
spacy.symbols
FUNCTIONS
sort_nums(x)
sort_nums(x)
DATA
0
ADJ = 84
ADP = 85
ADV = 86
AUX = 87
CARDINAL = 397
CCONJ = 89
CLUSTER = 72
CONJ = 88
DATE = 391
DEP = 76
DEPRECATED001 = 104
DEPRECATED002 = 105
DEPRECATED003 = 106
DEPRECATED004 = 107
DEPRECATED005 = 108
DEPRECATED006 = 109
DEPRECATED007 = 110
DEPRECATED008 = 111
DEPRECATED009 = 112
DEPRECATED010 = 113
DEPRECATED011 = 114
DEPRECATED012 = 115
DEPRECATED013 = 116
DEPRECATED014 = 117
DEPRECATED015 = 118
DEPRECATED016 = 119
DEPRECATED017 = 120
DEPRECATED018 = 121
DEPRECATED019 = 122
DEPRECATED020 = 123
DEPRECATED021 = 124
DEPRECATED022 = 125
DEPRECATED023 = 126
DEPRECATED024 = 127
DEPRECATED025 = 128
DEPRECATED026 = 129
DEPRECATED027 = 130
DEPRECATED028 = 131
DEPRECATED029 = 132
DEPRECATED030 = 133
DEPRECATED031 = 134
DEPRECATED032 = 135
DEPRECATED033 = 136
DEPRECATED034 = 137
DEPRECATED035 = 138
DEPRECATED036 = 139
DEPRECATED037 = 140
DEPRECATED038 = 141
DEPRECATED039 = 142
DEPRECATED040 = 143
DEPRECATED041 = 144
DEPRECATED042 = 145
DEPRECATED043 = 146
DEPRECATED044 = 147
DEPRECATED045 = 148
DEPRECATED046 = 149
DEPRECATED047 = 150
DEPRECATED048 = 151
DEPRECATED049 = 152
DEPRECATED050 = 153
DEPRECATED051 = 154
DEPRECATED052 = 155
DEPRECATED053 = 156
DEPRECATED054 = 157
DEPRECATED055 = 158
DEPRECATED056 = 159
DEPRECATED057 = 160
DEPRECATED058 = 161
DEPRECATED059 = 162
DEPRECATED060 = 163
DEPRECATED061 = 164
DEPRECATED062 = 165
DEPRECATED063 = 166
DEPRECATED064 = 167
DEPRECATED065 = 168
DEPRECATED066 = 169
DEPRECATED067 = 170
DEPRECATED068 = 171
DEPRECATED069 = 172
DEPRECATED070 = 173
DEPRECATED071 = 174
DEPRECATED072 = 175
DEPRECATED073 = 176
DEPRECATED074 = 177
DEPRECATED075 = 178
DEPRECATED076 = 179
DEPRECATED077 = 180
DEPRECATED078 = 181
DEPRECATED079 = 182
DEPRECATED080 = 183
DEPRECATED081 = 184
DEPRECATED082 = 185
DEPRECATED083 = 186
DEPRECATED084 = 187
DEPRECATED085 = 188
DEPRECATED086 = 189
DEPRECATED087 = 190
DEPRECATED088 = 191
DEPRECATED089 = 192
DEPRECATED090 = 193
DEPRECATED091 = 194
DEPRECATED092 = 195
DEPRECATED093 = 196
DEPRECATED094 = 197
DEPRECATED095 = 198
DEPRECATED096 = 199
DEPRECATED097 = 200
DEPRECATED098 = 201
DEPRECATED099 = 202
DEPRECATED100 = 203
DEPRECATED101 = 204
DEPRECATED102 = 205
DEPRECATED103 = 206
DEPRECATED104 = 207
DEPRECATED105 = 208
DEPRECATED106 = 209
DEPRECATED107 = 210
DEPRECATED108 = 211
DEPRECATED109 = 212
DEPRECATED110 = 213
DEPRECATED111 = 214
DEPRECATED112 = 215
DEPRECATED113 = 216
DEPRECATED114 = 217
DEPRECATED115 = 218
DEPRECATED116 = 219
DEPRECATED117 = 220
DEPRECATED118 = 221
DEPRECATED119 = 222
DEPRECATED120 = 223
DEPRECATED121 = 224
DEPRECATED122 = 225
DEPRECATED123 = 226
DEPRECATED124 = 227
DEPRECATED125 = 228
DEPRECATED126 = 229
DEPRECATED127 = 230
DEPRECATED128 = 231
DEPRECATED129 = 232
DEPRECATED130 = 233
DEPRECATED131 = 234
DEPRECATED132 = 235
DEPRECATED133 = 236
DEPRECATED134 = 237
DEPRECATED135 = 238
DEPRECATED136 = 239
DEPRECATED137 = 240
DEPRECATED138 = 241
DEPRECATED139 = 242
DEPRECATED140 = 243
DEPRECATED141 = 244
DEPRECATED142 = 245
DEPRECATED143 = 246
DEPRECATED144 = 247
DEPRECATED145 = 248
DEPRECATED146 = 249
DEPRECATED147 = 250
DEPRECATED148 = 251
DEPRECATED149 = 252
DEPRECATED150 = 253
DEPRECATED151 = 254
DEPRECATED152 = 255
DEPRECATED153 = 256
DEPRECATED154 = 257
DEPRECATED155 = 258
DEPRECATED156 = 259
DEPRECATED157 = 260
DEPRECATED158 = 261
DEPRECATED159 = 262
DEPRECATED160 = 263
DEPRECATED161 = 264
DEPRECATED162 = 265
DEPRECATED163 = 266
DEPRECATED164 = 267
DEPRECATED165 = 268
DEPRECATED166 = 269
DEPRECATED167 = 270
DEPRECATED168 = 271
DEPRECATED169 = 272
DEPRECATED170 = 273
DEPRECATED171 = 274
DEPRECATED172 = 275
DEPRECATED173 = 276
DEPRECATED174 = 277
DEPRECATED175 = 278
DEPRECATED176 = 279
DEPRECATED177 = 280
DEPRECATED178 = 281
DEPRECATED179 = 282
DEPRECATED180 = 283
DEPRECATED181 = 284
DEPRECATED182 = 285
DEPRECATED183 = 286
DEPRECATED184 = 287
DEPRECATED185 = 288
DEPRECATED186 = 289
DEPRECATED187 = 290
DEPRECATED188 = 291
DEPRECATED189 = 292
DEPRECATED190 = 293
DEPRECATED191 = 294
DEPRECATED192 = 295
DEPRECATED193 = 296
DEPRECATED194 = 297
DEPRECATED195 = 298
DEPRECATED196 = 299
DEPRECATED197 = 300
DEPRECATED198 = 301
DEPRECATED199 = 302
DEPRECATED200 = 303
DEPRECATED201 = 304
DEPRECATED202 = 305
DEPRECATED203 = 306
DEPRECATED204 = 307
DEPRECATED205 = 308
DEPRECATED206 = 309
DEPRECATED207 = 310
DEPRECATED208 = 311
DEPRECATED209 = 312
DEPRECATED210 = 313
DEPRECATED211 = 314
DEPRECATED212 = 315
DEPRECATED213 = 316
DEPRECATED214 = 317
DEPRECATED215 = 318
DEPRECATED216 = 319
DEPRECATED217 = 320
DEPRECATED218 = 321
DEPRECATED219 = 322
DEPRECATED220 = 323
DEPRECATED221 = 324
DEPRECATED222 = 325
DEPRECATED223 = 326
DEPRECATED224 = 327
DEPRECATED225 = 328
DEPRECATED226 = 329
DEPRECATED227 = 330
DEPRECATED228 = 331
DEPRECATED229 = 332
DEPRECATED230 = 333
DEPRECATED231 = 334
DEPRECATED232 = 335
DEPRECATED233 = 336
DEPRECATED234 = 337
DEPRECATED235 = 338
DEPRECATED236 = 339
DEPRECATED237 = 340
DEPRECATED238 = 341
DEPRECATED239 = 342
DEPRECATED240 = 343
DEPRECATED241 = 344
DEPRECATED242 = 345
DEPRECATED243 = 346
DEPRECATED244 = 347
DEPRECATED245 = 348
DEPRECATED246 = 349
DEPRECATED247 = 350
DEPRECATED248 = 351
DEPRECATED249 = 352
DEPRECATED250 = 353
DEPRECATED251 = 354
DEPRECATED252 = 355
DEPRECATED253 = 356
DEPRECATED254 = 357
DEPRECATED255 = 358
DEPRECATED256 = 359
DEPRECATED257 = 360
DEPRECATED258 = 361
DEPRECATED259 = 362
DEPRECATED260 = 363
DEPRECATED261 = 364
DEPRECATED262 = 365
DEPRECATED263 = 366
DEPRECATED264 = 367
DEPRECATED265 = 368
DEPRECATED266 = 369
DEPRECATED267 = 370
DEPRECATED268 = 371
DEPRECATED269 = 372
DEPRECATED270 = 373
DEPRECATED271 = 374
DEPRECATED272 = 375
DEPRECATED273 = 376
DEPRECATED274 = 377
DEPRECATED275 = 378
DEPRECATED276 = 379
DET = 90
ENT_ID = 454
ENT_IOB = 77
ENT_KB_ID = 452
ENT_TYPE = 78
EOL = 102
EVENT = 387
FACILITY = 382
FLAG19 = 19
FLAG20 = 20
FLAG21 = 21
FLAG22 = 22
FLAG23 = 23
FLAG24 = 24
FLAG25 = 25
FLAG26 = 26
FLAG27 = 27
FLAG28 = 28
FLAG29 = 29
FLAG30 = 30
FLAG31 = 31
FLAG32 = 32
FLAG33 = 33
FLAG34 = 34
FLAG35 = 35
FLAG36 = 36
FLAG37 = 37
FLAG38 = 38
FLAG39 = 39
FLAG40 = 40
FLAG41 = 41
FLAG42 = 42
FLAG43 = 43
FLAG44 = 44
FLAG45 = 45
FLAG46 = 46
FLAG47 = 47
FLAG48 = 48
FLAG49 = 49
FLAG50 = 50
FLAG51 = 51
FLAG52 = 52
FLAG53 = 53
FLAG54 = 54
FLAG55 = 55
FLAG56 = 56
FLAG57 = 57
FLAG58 = 58
FLAG59 = 59
FLAG60 = 60
FLAG61 = 61
FLAG62 = 62
FLAG63 = 63
GPE = 384
HEAD = 79
ID = 64
IDS = {'': 0, 'ADJ': 84, 'ADP': 85, 'ADV': 86, 'AUX': 87, 'CARDINAL': ...
IDX = 455
INTJ = 91
IS_ALPHA = 1
IS_ASCII = 2
IS_BRACKET = 14
IS_CURRENCY = 18
IS_DIGIT = 3
IS_LEFT_PUNCT = 16
IS_LOWER = 4
IS_OOV_DEPRECATED = 13
IS_PUNCT = 5
IS_QUOTE = 15
IS_RIGHT_PUNCT = 17
IS_SPACE = 6
IS_STOP = 12
IS_TITLE = 7
IS_UPPER = 8
LANG = 83
LANGUAGE = 389
LAW = 390
LEMMA = 73
LENGTH = 71
LIKE_EMAIL = 11
LIKE_NUM = 10
LIKE_URL = 9
LOC = 385
LOWER = 66
MONEY = 394
MORPH = 453
NAMES = ['', 'IS_ALPHA', 'IS_ASCII', 'IS_DIGIT', 'IS_LOWER', 'IS_PUNCT...
NORM = 67
NORP = 381
NOUN = 92
NUM = 93
ORDINAL = 396
ORG = 383
ORTH = 65
PART = 94
PERCENT = 393
PERSON = 380
POS = 74
PREFIX = 69
PROB = 82
PRODUCT = 386
PRON = 95
PROPN = 96
PUNCT = 97
QUANTITY = 395
SCONJ = 98
SENT_START = 80
SHAPE = 68
SPACE = 103
SPACY = 81
SUFFIX = 70
SYM = 99
TAG = 75
TIME = 392
VERB = 100
WORK_OF_ART = 388
X = 101
__test__ = {}
acl = 451
acomp = 398
advcl = 399
advmod = 400
agent = 401
amod = 402
appos = 403
attr = 404
aux = 405
auxpass = 406
cc = 407
ccomp = 408
complm = 409
conj = 410
cop = 411
csubj = 412
csubjpass = 413
dep = 414
det = 415
dobj = 416
expl = 417
hmod = 418
hyph = 419
infmod = 420
intj = 421
iobj = 422
it = ('_', 456)
mark = 423
meta = 424
neg = 425
nmod = 426
nn = 427
npadvmod = 428
nsubj = 429
nsubjpass = 430
num = 431
number = 432
obj = 434
obl = 435
oprd = 433
parataxis = 436
partmod = 437
pcomp = 438
pobj = 439
poss = 440
possessive = 441
preconj = 442
prep = 443
prt = 444
punct = 445
quantmod = 446
rcmod = 448
relcl = 447
root = 449
xcomp = 450
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\symbols.cp312-win_amd64.pyd
spacy.sys
Python Library Documentation: built-in module sys
NAME
sys
MODULE REFERENCE
https://docs.python.org/3.12/library/sys.html
The following documentation is automatically generated from the Python
source files. It may be incomplete, incorrect or include features that
are considered implementation detail and may vary between Python
implementations. When in doubt, consult the module reference at the
location listed above.
DESCRIPTION
This module provides access to some objects used or maintained by the
interpreter and to functions that interact strongly with the interpreter.
Dynamic objects:
argv -- command line arguments; argv[0] is the script pathname if known
path -- module search path; path[0] is the script directory, else ''
modules -- dictionary of loaded modules
displayhook -- called to show results in an interactive session
excepthook -- called to handle any uncaught exception other than SystemExit
To customize printing in an interactive session or to install a custom
top-level exception handler, assign other functions to replace these.
stdin -- standard input file object; used by input()
stdout -- standard output file object; used by print()
stderr -- standard error object; used for error messages
By assigning other file objects (or objects that behave like files)
to these, it is possible to redirect all of the interpreter's I/O.
last_exc - the last uncaught exception
Only available in an interactive session after a
traceback has been printed.
last_type -- type of last uncaught exception
last_value -- value of last uncaught exception
last_traceback -- traceback of last uncaught exception
These three are the (deprecated) legacy representation of last_exc.
Static objects:
builtin_module_names -- tuple of module names built into this interpreter
copyright -- copyright notice pertaining to this interpreter
exec_prefix -- prefix used to find the machine-specific Python library
executable -- absolute path of the executable binary of the Python interpreter
float_info -- a named tuple with information about the float implementation.
float_repr_style -- string indicating the style of repr() output for floats
hash_info -- a named tuple with information about the hash algorithm.
hexversion -- version information encoded as a single integer
implementation -- Python implementation information.
int_info -- a named tuple with information about the int implementation.
maxsize -- the largest supported length of containers.
maxunicode -- the value of the largest Unicode code point
platform -- platform identifier
prefix -- prefix used to find the Python library
thread_info -- a named tuple with information about the thread implementation.
version -- the version of this interpreter as a string
version_info -- version information as a named tuple
dllhandle -- [Windows only] integer handle of the Python DLL
winver -- [Windows only] version number of the Python DLL
_enablelegacywindowsfsencoding -- [Windows only]
__stdin__ -- the original stdin; don't touch!
__stdout__ -- the original stdout; don't touch!
__stderr__ -- the original stderr; don't touch!
__displayhook__ -- the original displayhook; don't touch!
__excepthook__ -- the original excepthook; don't touch!
Functions:
displayhook() -- print an object to the screen, and save it in builtins._
excepthook() -- print an exception and its traceback to sys.stderr
exception() -- return the current thread's active exception
exc_info() -- return information about the current thread's active exception
exit() -- exit the interpreter by raising SystemExit
getdlopenflags() -- returns flags to be used for dlopen() calls
getprofile() -- get the global profiling function
getrefcount() -- return the reference count for an object (plus one :-)
getrecursionlimit() -- return the max recursion depth for the interpreter
getsizeof() -- return the size of an object in bytes
gettrace() -- get the global debug tracing function
setdlopenflags() -- set the flags to be used for dlopen() calls
setprofile() -- set the global profiling function
setrecursionlimit() -- set the max recursion depth for the interpreter
settrace() -- set the global debug tracing function
SUBMODULES
monitoring
FUNCTIONS
__breakpointhook__ = breakpointhook(...)
breakpointhook(*args, **kws)
This hook function is called by built-in breakpoint().
__displayhook__ = displayhook(object, /)
Print an object to sys.stdout and also save it in builtins._
__excepthook__ = excepthook(exctype, value, traceback, /)
Handle an exception by displaying it with a traceback on sys.stderr.
__unraisablehook__ = unraisablehook(unraisable, /)
Handle an unraisable exception.
The unraisable argument has the following attributes:
* exc_type: Exception type.
* exc_value: Exception value, can be None.
* exc_traceback: Exception traceback, can be None.
* err_msg: Error message, can be None.
* object: Object causing the exception, can be None.
activate_stack_trampoline(backend, /)
Activate stack profiler trampoline *backend*.
addaudithook(hook)
Adds a new audit hook callback.
audit(...)
audit(event, *args)
Passes the event to any audit hooks that are attached.
breakpointhook(...)
breakpointhook(*args, **kws)
This hook function is called by built-in breakpoint().
call_tracing(func, args, /)
Call func(*args), while tracing is enabled.
The tracing state is saved, and restored afterwards. This is intended
to be called from a debugger from a checkpoint, to recursively debug
some other code.
deactivate_stack_trampoline()
Deactivate the current stack profiler trampoline backend.
If no stack profiler is activated, this function has no effect.
displayhook(object, /)
Print an object to sys.stdout and also save it in builtins._
exc_info()
Return current exception information: (type, value, traceback).
Return information about the most recent exception caught by an except
clause in the current stack frame or in an older stack frame.
excepthook(exctype, value, traceback, /)
Handle an exception by displaying it with a traceback on sys.stderr.
exception()
Return the current exception.
Return the most recent exception caught by an except clause
in the current stack frame or in an older stack frame, or None
if no such exception exists.
exit(status=None, /)
Exit the interpreter by raising SystemExit(status).
If the status is omitted or None, it defaults to zero (i.e., success).
If the status is an integer, it will be used as the system exit status.
If it is another kind of object, it will be printed and the system
exit status will be one (i.e., failure).
get_asyncgen_hooks()
Return the installed asynchronous generators hooks.
This returns a namedtuple of the form (firstiter, finalizer).
get_coroutine_origin_tracking_depth()
Check status of origin tracking for coroutine objects in this thread.
get_int_max_str_digits()
Return the maximum string digits limit for non-binary int<->str conversions.
getallocatedblocks()
Return the number of memory blocks currently allocated.
getdefaultencoding()
Return the current default encoding used by the Unicode implementation.
getfilesystemencodeerrors()
Return the error mode used Unicode to OS filename conversion.
getfilesystemencoding()
Return the encoding used to convert Unicode filenames to OS filenames.
getprofile()
Return the profiling function set with sys.setprofile.
See the profiler chapter in the library manual.
getrecursionlimit()
Return the current value of the recursion limit.
The recursion limit is the maximum depth of the Python interpreter
stack. This limit prevents infinite recursion from causing an overflow
of the C stack and crashing Python.
getrefcount(object, /)
Return the reference count of object.
The count returned is generally one higher than you might expect,
because it includes the (temporary) reference as an argument to
getrefcount().
getsizeof(...)
getsizeof(object [, default]) -> int
Return the size of object in bytes.
getswitchinterval()
Return the current thread switch interval; see sys.setswitchinterval().
gettrace()
Return the global debug tracing function set with sys.settrace.
See the debugger chapter in the library manual.
getunicodeinternedsize()
Return the number of elements of the unicode interned dictionary
getwindowsversion()
Return info about the running version of Windows as a named tuple.
The members are named: major, minor, build, platform, service_pack,
service_pack_major, service_pack_minor, suite_mask, product_type and
platform_version. For backward compatibility, only the first 5 items
are available by indexing. All elements are numbers, except
service_pack and platform_type which are strings, and platform_version
which is a 3-tuple. Platform is always 2. Product_type may be 1 for a
workstation, 2 for a domain controller, 3 for a server.
Platform_version is a 3-tuple containing a version number that is
intended for identifying the OS rather than feature detection.
intern(string, /)
``Intern'' the given string.
This enters the string in the (global) table of interned strings whose
purpose is to speed up dictionary lookups. Return the string itself or
the previously interned string object with the same value.
is_finalizing()
Return True if Python is exiting.
is_stack_trampoline_active()
Return *True* if a stack profiler trampoline is active.
set_asyncgen_hooks(...)
set_asyncgen_hooks([firstiter] [, finalizer])
Set a finalizer for async generators objects.
set_coroutine_origin_tracking_depth(depth)
Enable or disable origin tracking for coroutine objects in this thread.
Coroutine objects will track 'depth' frames of traceback information
about where they came from, available in their cr_origin attribute.
Set a depth of 0 to disable.
set_int_max_str_digits(maxdigits)
Set the maximum string digits limit for non-binary int<->str conversions.
setprofile(...)
setprofile(function)
Set the profiling function. It will be called on each function call
and return. See the profiler chapter in the library manual.
setrecursionlimit(limit, /)
Set the maximum depth of the Python interpreter stack to n.
This limit prevents infinite recursion from causing an overflow of the C
stack and crashing Python. The highest possible limit is platform-
dependent.
setswitchinterval(interval, /)
Set the ideal thread switching delay inside the Python interpreter.
The actual frequency of switching threads can be lower if the
interpreter executes long sequences of uninterruptible code
(this is implementation-specific and workload-dependent).
The parameter must represent the desired switching delay in seconds
A typical value is 0.005 (5 milliseconds).
settrace(...)
settrace(function)
Set the global debug tracing function. It will be called on each
function call. See the debugger chapter in the library manual.
unraisablehook(unraisable, /)
Handle an unraisable exception.
The unraisable argument has the following attributes:
* exc_type: Exception type.
* exc_value: Exception value, can be None.
* exc_traceback: Exception traceback, can be None.
* err_msg: Error message, can be None.
* object: Object causing the exception, can be None.
DATA
__stderr__ = <_io.TextIOWrapper name='<stderr>' mode='w' encoding='cp1...
__stdin__ = <_io.TextIOWrapper name='<stdin>' mode='r' encoding='utf-8...
__stdout__ = <_io.TextIOWrapper name='<stdout>' mode='w' encoding='cp1...
api_version = 1013
argv = [r'f:\JoeyCodes\PyDocs\py_docs.py', '--worker', 'spacy', r'F:\J...
base_exec_prefix = r'C:\Users\Youse\AppData\Local\Programs\Python\Pyth...
base_prefix = r'C:\Users\Youse\AppData\Local\Programs\Python\Python312...
builtin_module_names = ('_abc', '_ast', '_bisect', '_blake2', '_codecs...
byteorder = 'little'
copyright = 'Copyright (c) 2001-2023 Python Software Foundati...ematis...
dllhandle = 140727031824384
dont_write_bytecode = False
exec_prefix = r'C:\Users\Youse\AppData\Local\Programs\Python\Python312...
executable = r'C:\Users\Youse\AppData\Local\Programs\Python\Python312\...
flags = sys.flags(debug=0, inspect=0, interactive=0, opt...ding=0, saf...
float_info = sys.float_info(max=1.7976931348623157e+308, max_...epsilo...
float_repr_style = 'short'
hash_info = sys.hash_info(width=64, modulus=2305843009213693...iphash1...
hexversion = 51119856
implementation = namespace(name='cpython', cache_tag='cpython-312...as...
int_info = sys.int_info(bits_per_digit=30, sizeof_digit=4, ..._str_dig...
maxsize = 9223372036854775807
maxunicode = 1114111
meta_path = [<_distutils_hack.DistutilsMetaFinder object>, <class '_fr...
modules = {'Cython': <module 'Cython' from 'C:\\Users\\Youse\\AppData....
orig_argv = [r'C:\Users\Youse\AppData\Local\Programs\Python\Python312\...
path = [r'f:\JoeyCodes\PyDocs', r'C:\Users\Youse\AppData\Local\Program...
path_hooks = [<class 'zipimport.zipimporter'>, <function FileFinder.pa...
path_importer_cache = {r'C:\Users\Youse\AppData\Local\Programs\Python\...
platform = 'win32'
platlibdir = 'DLLs'
prefix = r'C:\Users\Youse\AppData\Local\Programs\Python\Python312'
pycache_prefix = None
stderr = <_io.TextIOWrapper name='<stderr>' mode='w' encoding='cp1252'...
stdin = <_io.TextIOWrapper name='<stdin>' mode='r' encoding='utf-8'>
stdlib_module_names = frozenset({'__future__', '_abc', '_aix_support',...
stdout = <_io.TextIOWrapper name='<stdout>' mode='w' encoding='cp1252'...
thread_info = sys.thread_info(name='nt', lock=None, version=None)
version = '3.12.6 (tags/v3.12.6:a4a2d2b, Sep 6 2024, 20:11:23) [MSC v...
version_info = sys.version_info(major=3, minor=12, micro=6, releaselev...
warnoptions = []
winver = '3.12'
FILE
(built-in)
spacy.tokenizer
Python Library Documentation: module spacy.tokenizer in spacy
NAME
spacy.tokenizer
CLASSES
builtins.object
Tokenizer
class Tokenizer(builtins.object)
| Tokenizer(Vocab vocab, rules=None, prefix_search=None, suffix_search=None, infix_finditer=None, token_match=None, url_match=None, faster_heuristics=True, max_cache_size=10000)
|
| Segment text, and create Doc objects with the discovered segment
| boundaries.
|
| DOCS: https://spacy.io/api/tokenizer
|
| Methods defined here:
|
| __call__(...)
| Tokenizer.__call__(self, str string)
|
| Tokenize a string.
|
| string (str): The string to tokenize.
| RETURNS (Doc): A container for linguistic annotations.
|
| DOCS: https://spacy.io/api/tokenizer#call
|
| __init__(...)
| Create a `Tokenizer`, to create `Doc` objects given unicode text.
|
| vocab (Vocab): A storage container for lexical types.
| rules (dict): Exceptions and special-cases for the tokenizer.
| prefix_search (callable): A function matching the signature of
| `re.compile(string).search` to match prefixes.
| suffix_search (callable): A function matching the signature of
| `re.compile(string).search` to match suffixes.
| infix_finditer (callable): A function matching the signature of
| `re.compile(string).finditer` to find infixes.
| token_match (callable): A function matching the signature of
| `re.compile(string).match`, for matching strings to be
| recognized as tokens.
| url_match (callable): A function matching the signature of
| `re.compile(string).match`, for matching strings to be
| recognized as urls.
| faster_heuristics (bool): Whether to restrict the final
| Matcher-based pass for rules to those containing affixes or space.
| Defaults to True.
| max_cache_size (int): Maximum number of tokenization chunks to cache.
|
| EXAMPLE:
| >>> tokenizer = Tokenizer(nlp.vocab)
|
| DOCS: https://spacy.io/api/tokenizer#init
|
| __reduce__(self)
| Tokenizer.__reduce__(self)
|
| add_special_case(self, string, substrings)
| Tokenizer.add_special_case(self, str string, substrings)
|
| Add a special-case tokenization rule.
|
| string (str): The string to specially tokenize.
| substrings (iterable): A sequence of dicts, where each dict describes
| a token and its attributes. The `ORTH` fields of the attributes
| must exactly match the string when they are concatenated.
|
| DOCS: https://spacy.io/api/tokenizer#add_special_case
|
| explain(self, text)
| Tokenizer.explain(self, text)
|
| A debugging tokenizer that provides information about which
| tokenizer rule or pattern was matched for each token. The tokens
| produced are identical to `nlp.tokenizer()` except for whitespace
| tokens.
|
| string (str): The string to tokenize.
| RETURNS (list): A list of (pattern_string, token_string) tuples
|
| DOCS: https://spacy.io/api/tokenizer#explain
|
| find_infix(self, string)
| Tokenizer.find_infix(self, str string)
|
| Find internal split points of the string, such as hyphens.
|
| string (str): The string to segment.
| RETURNS (list): A list of `re.MatchObject` objects that have `.start()`
| and `.end()` methods, denoting the placement of internal segment
| separators, e.g. hyphens.
|
| DOCS: https://spacy.io/api/tokenizer#find_infix
|
| find_prefix(self, string)
| Tokenizer.find_prefix(self, str string)
|
| Find the length of a prefix that should be segmented from the
| string, or None if no prefix rules match.
|
| string (str): The string to segment.
| RETURNS (int): The length of the prefix if present, otherwise `None`.
|
| DOCS: https://spacy.io/api/tokenizer#find_prefix
|
| find_suffix(self, string)
| Tokenizer.find_suffix(self, str string)
|
| Find the length of a suffix that should be segmented from the
| string, or None if no suffix rules match.
|
| string (str): The string to segment.
| Returns (int): The length of the suffix if present, otherwise `None`.
|
| DOCS: https://spacy.io/api/tokenizer#find_suffix
|
| from_bytes(self, bytes_data, *, exclude=())
| Tokenizer.from_bytes(self, bytes_data, *, exclude=tuple())
|
| Load state from a binary string.
|
| bytes_data (bytes): The data to load from.
| exclude (list): String names of serialization fields to exclude.
| RETURNS (Tokenizer): The `Tokenizer` object.
|
| DOCS: https://spacy.io/api/tokenizer#from_bytes
|
| from_disk(self, path, *, exclude=())
| Tokenizer.from_disk(self, path, *, exclude=tuple())
|
| Loads state from a directory. Modifies the object in place and
| returns it.
|
| path (str / Path): A path to a directory.
| exclude (list): String names of serialization fields to exclude.
| RETURNS (Tokenizer): The modified `Tokenizer` object.
|
| DOCS: https://spacy.io/api/tokenizer#from_disk
|
| pipe(self, texts, batch_size=1000)
| Tokenizer.pipe(self, texts, batch_size=1000)
|
| Tokenize a stream of texts.
|
| texts: A sequence of unicode texts.
| batch_size (int): Number of texts to accumulate in an internal buffer.
| Defaults to 1000.
| YIELDS (Doc): A sequence of Doc objects, in order.
|
| DOCS: https://spacy.io/api/tokenizer#pipe
|
| score(self, examples, **kwargs)
| Tokenizer.score(self, examples, **kwargs)
|
| to_bytes(self, *, exclude=())
| Tokenizer.to_bytes(self, *, exclude=tuple())
|
| Serialize the current state to a binary string.
|
| exclude (list): String names of serialization fields to exclude.
| RETURNS (bytes): The serialized form of the `Tokenizer` object.
|
| DOCS: https://spacy.io/api/tokenizer#to_bytes
|
| to_disk(self, path, **kwargs)
| Tokenizer.to_disk(self, path, **kwargs)
|
| Save the current state to a directory.
|
| path (str / Path): A path to a directory, which will be created if
| it doesn't exist.
| exclude (list): String names of serialization fields to exclude.
|
| DOCS: https://spacy.io/api/tokenizer#to_disk
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| faster_heuristics
|
| infix_finditer
|
| max_cache_size
| max_cache_size: 'int'
|
| prefix_search
|
| rules
|
| suffix_search
|
| token_match
|
| url_match
|
| vocab
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __pyx_vtable__ = <capsule object NULL>
DATA
NORM = 67
ORTH = 65
__test__ = {'Tokenizer.__init__ (line 31)': 'Create a `Tokenizer`, to ...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\tokenizer.cp312-win_amd64.pyd
spacy.tokens
Python Library Documentation: package spacy.tokens in spacy
NAME
spacy.tokens
PACKAGE CONTENTS
_dict_proxies
_retokenize
_serialize
doc
graph
morphanalysis
span
span_group
token
underscore
CLASSES
builtins.object
spacy.tokens._serialize.DocBin
spacy.tokens.doc.Doc
spacy.tokens.morphanalysis.MorphAnalysis
spacy.tokens.span.Span
spacy.tokens.span_group.SpanGroup
spacy.tokens.token.Token
class Doc(builtins.object)
| Doc(Vocab vocab, words=None, spaces=None, user_data=None, *, tags=None, pos=None, morphs=None, lemmas=None, heads=None, deps=None, sent_starts=None, ents=None)
|
| A sequence of Token objects. Access sentences and named entities, export
| annotations to numpy arrays, losslessly serialize to compressed binary
| strings. The `Doc` object holds an array of `TokenC` structs. The
| Python-level `Token` and `Span` objects are views of this array, i.e.
| they don't own the data themselves.
|
| EXAMPLE:
| Construction 1
| >>> doc = nlp(u'Some text')
|
| Construction 2
| >>> from spacy.tokens import Doc
| >>> doc = Doc(nlp.vocab, words=["hello", "world", "!"], spaces=[True, False, False])
|
| DOCS: https://spacy.io/api/doc
|
| Methods defined here:
|
| __bytes__(self)
| Doc.__bytes__(self)
|
| __getitem__(...)
| Doc.__getitem__(self, i)
|
| Get a `Token` or `Span` object.
|
| i (int or tuple) The index of the token, or the slice of the document
| to get.
| RETURNS (Token or Span): The token at `doc[i]]`, or the span at
| `doc[start : end]`.
|
| EXAMPLE:
| >>> doc[i]
| Get the `Token` object at position `i`, where `i` is an integer.
| Negative indexing is supported, and follows the usual Python
| semantics, i.e. `doc[-2]` is `doc[len(doc) - 2]`.
|
| >>> doc[start : end]]
| Get a `Span` object, starting at position `start` and ending at
| position `end`, where `start` and `end` are token indices. For
| instance, `doc[2:5]` produces a span consisting of tokens 2, 3 and
| 4. Stepped slices (e.g. `doc[start : end : step]`) are not
| supported, as `Span` objects must be contiguous (cannot have gaps).
| You can use negative indices and open-ended ranges, which have
| their normal Python semantics.
|
| DOCS: https://spacy.io/api/doc#getitem
|
| __init__(...)
| Create a Doc object.
|
| vocab (Vocab): A vocabulary object, which must match any models you
| want to use (e.g. tokenizer, parser, entity recognizer).
| words (Optional[List[Union[str, int]]]): A list of unicode strings or
| hash values to add to the document as words. If `None`, defaults to
| empty list.
| spaces (Optional[List[bool]]): A list of boolean values, of the same
| length as `words`. `True` means that the word is followed by a space,
| `False` means it is not. If `None`, defaults to `[True]*len(words)`
| user_data (dict or None): Optional extra data to attach to the Doc.
| tags (Optional[List[str]]): A list of unicode strings, of the same
| length as words, to assign as token.tag. Defaults to None.
| pos (Optional[List[str]]): A list of unicode strings, of the same
| length as words, to assign as token.pos. Defaults to None.
| morphs (Optional[List[str]]): A list of unicode strings, of the same
| length as words, to assign as token.morph. Defaults to None.
| lemmas (Optional[List[str]]): A list of unicode strings, of the same
| length as words, to assign as token.lemma. Defaults to None.
| heads (Optional[List[int]]): A list of values, of the same length as
| words, to assign as heads. Head indices are the position of the
| head in the doc. Defaults to None.
| deps (Optional[List[str]]): A list of unicode strings, of the same
| length as words, to assign as token.dep. Defaults to None.
| sent_starts (Optional[List[Union[bool, int, None]]]): A list of values,
| of the same length as words, to assign as token.is_sent_start. Will
| be overridden by heads if heads is provided. Defaults to None.
| ents (Optional[List[str]]): A list of unicode strings, of the same
| length as words, as IOB tags to assign as token.ent_iob and
| token.ent_type. Defaults to None.
|
| DOCS: https://spacy.io/api/doc#init
|
| __iter__(...)
| Doc.__iter__(self)
|
| Iterate over `Token` objects, from which the annotations can be
| easily accessed. This is the main way of accessing `Token` objects,
| which are the main way annotations are accessed from Python. If faster-
| than-Python speeds are required, you can instead access the annotations
| as a numpy array, or access the underlying C data directly from Cython.
|
| DOCS: https://spacy.io/api/doc#iter
|
| __len__(...)
| Doc.__len__(self)
|
| The number of tokens in the document.
|
| RETURNS (int): The number of tokens in the document.
|
| DOCS: https://spacy.io/api/doc#len
|
| __reduce__ = __reduce_cython__(...)
| Doc.__reduce_cython__(self)
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__ = __setstate_cython__(...)
| Doc.__setstate_cython__(self, __pyx_state)
|
| __str__(self, /)
| Return str(self).
|
| __unicode__(self)
| Doc.__unicode__(self)
|
| char_span(self, start_idx, end_idx, label=0, kb_id=0, vector=None, alignment_mode='strict', span_id=0)
| Doc.char_span(self, int start_idx, int end_idx, label=0, kb_id=0, vector=None, alignment_mode='strict', span_id=0)
|
| Create a `Span` object from the slice
| `doc.text[start_idx : end_idx]`. Returns None if no valid `Span` can be
| created.
|
| doc (Doc): The parent document.
| start_idx (int): The index of the first character of the span.
| end_idx (int): The index of the first character after the span.
| label (Union[int, str]): A label to attach to the Span, e.g. for
| named entities.
| kb_id (Union[int, str]): An ID from a KB to capture the meaning of a
| named entity.
| vector (ndarray[ndim=1, dtype='float32']): A meaning representation of
| the span.
| alignment_mode (str): How character indices are aligned to token
| boundaries. Options: "strict" (character indices must be aligned
| with token boundaries), "contract" (span of all tokens completely
| within the character span), "expand" (span of all tokens at least
| partially covered by the character span). Defaults to "strict".
| span_id (Union[int, str]): An identifier to associate with the span.
| RETURNS (Span): The newly constructed object.
|
| DOCS: https://spacy.io/api/doc#char_span
|
| copy(self)
| Doc.copy(self)
|
| count_by(self, attr_id, exclude=None, counts=None)
| Doc.count_by(self, attr_id_t attr_id, exclude=None, counts=None)
|
| Count the frequencies of a given attribute. Produces a dict of
| `{attribute (int): count (ints)}` frequencies, keyed by the values of
| the given attribute ID.
|
| attr_id (int): The attribute ID to key the counts.
| RETURNS (dict): A dictionary mapping attributes to integer counts.
|
| DOCS: https://spacy.io/api/doc#count_by
|
| extend_tensor(self, tensor)
| Doc.extend_tensor(self, tensor)
|
| Concatenate a new tensor onto the doc.tensor object.
|
| The doc.tensor attribute holds dense feature vectors
| computed by the models in the pipeline. Let's say a
| document with 30 words has a tensor with 128 dimensions
| per word. doc.tensor.shape will be (30, 128). After
| calling doc.extend_tensor with an array of shape (30, 64),
| doc.tensor == (30, 192).
|
| from_array(self, attrs, array)
| Doc.from_array(self, attrs, array)
|
| Load attributes from a numpy array. Write to a `Doc` object, from an
| `(M, N)` array of attributes.
|
| attrs (list) A list of attribute ID ints.
| array (numpy.ndarray[ndim=2, dtype='int32']): The attribute values.
| RETURNS (Doc): Itself.
|
| DOCS: https://spacy.io/api/doc#from_array
|
| from_bytes(self, bytes_data, *, exclude=())
| Doc.from_bytes(self, bytes_data, *, exclude=tuple())
|
| Deserialize, i.e. import the document contents from a binary string.
|
| data (bytes): The string to load from.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (Doc): Itself.
|
| DOCS: https://spacy.io/api/doc#from_bytes
|
| from_dict(self, msg, *, exclude=())
| Doc.from_dict(self, msg, *, exclude=tuple())
|
| Deserialize the document contents from a dictionary representation.
|
| msg (Dict[str, Any]): The dictionary to load from.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (Doc): Itself.
|
| from_disk(self, path, *, exclude=())
| Doc.from_disk(self, path, *, exclude=tuple())
|
| Loads state from a directory. Modifies the object in place and
| returns it.
|
| path (str / Path): A path to a directory. Paths may be either
| strings or `Path`-like objects.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (Doc): The modified `Doc` object.
|
| DOCS: https://spacy.io/api/doc#from_disk
|
| from_json(self, doc_json, *, validate=False)
| Doc.from_json(self, doc_json, *, validate=False)
|
| Convert a JSON document generated by Doc.to_json() to a Doc.
|
| doc_json (Dict): JSON representation of doc object to load.
| validate (bool): Whether to validate `doc_json` against the expected schema.
| Defaults to False.
| RETURNS (Doc): A doc instance corresponding to the specified JSON representation.
|
| get_lca_matrix(self)
| Doc.get_lca_matrix(self)
|
| Calculates a matrix of Lowest Common Ancestors (LCA) for a given
| `Doc`, where LCA[i, j] is the index of the lowest common ancestor among
| token i and j.
|
| RETURNS (np.array[ndim=2, dtype=numpy.int32]): LCA matrix with shape
| (n, n), where n = len(self).
|
| DOCS: https://spacy.io/api/doc#get_lca_matrix
|
| has_annotation(self, attr, *, require_complete=False)
| Doc.has_annotation(self, attr, *, require_complete=False)
|
| Check whether the doc contains annotation on a token attribute.
|
| attr (Union[int, str]): The attribute string name or int ID.
| require_complete (bool): Whether to check that the attribute is set on
| every token in the doc.
| RETURNS (bool): Whether annotation is present.
|
| DOCS: https://spacy.io/api/doc#has_annotation
|
| retokenize(self)
| Doc.retokenize(self)
|
| Context manager to handle retokenization of the Doc.
| Modifications to the Doc's tokenization are stored, and then
| made all at once when the context manager exits. This is
| much more efficient, and less error-prone.
|
| All views of the Doc (Span and Token) created before the
| retokenization are invalidated, although they may accidentally
| continue to work.
|
| DOCS: https://spacy.io/api/doc#retokenize
| USAGE: https://spacy.io/usage/linguistic-features#retokenization
|
| set_ents(self, entities, *, blocked=None, missing=None, outside=None, default=<SetEntsDefault.outside: 'outside'>)
| Doc.set_ents(self, entities, *, blocked=None, missing=None, outside=None, default=SetEntsDefault.outside)
|
| Set entity annotation.
|
| entities (List[Span]): Spans with labels to set as entities.
| blocked (Optional[List[Span]]): Spans to set as 'blocked' (never an
| entity) for spacy's built-in NER component. Other components may
| ignore this setting.
| missing (Optional[List[Span]]): Spans with missing/unknown entity
| information.
| outside (Optional[List[Span]]): Spans outside of entities (O in IOB).
| default (str): How to set entity annotation for tokens outside of any
| provided spans. Options: "blocked", "missing", "outside" and
| "unmodified" (preserve current state). Defaults to "outside".
|
| similarity(self, other)
| Doc.similarity(self, other)
|
| Make a semantic similarity estimate. The default estimate is cosine
| similarity using an average of word vectors.
|
| other (object): The object to compare with. By default, accepts `Doc`,
| `Span`, `Token` and `Lexeme` objects.
| RETURNS (float): A scalar similarity score. Higher is more similar.
|
| DOCS: https://spacy.io/api/doc#similarity
|
| to_array(self, py_attr_ids)
| Doc.to_array(self, py_attr_ids) -> ndarray
|
| Export given token attributes to a numpy `ndarray`.
| If `attr_ids` is a sequence of M attributes, the output array will be
| of shape `(N, M)`, where N is the length of the `Doc` (in tokens). If
| `attr_ids` is a single attribute, the output shape will be (N,). You
| can specify attributes by integer ID (e.g. spacy.attrs.LEMMA) or
| string name (e.g. 'LEMMA' or 'lemma').
|
| py_attr_ids (list[]): A list of attributes (int IDs or string names).
| RETURNS (numpy.ndarray[long, ndim=2]): A feature matrix, with one row
| per word, and one column per attribute indicated in the input
| `attr_ids`.
|
| EXAMPLE:
| >>> from spacy.attrs import LOWER, POS, ENT_TYPE, IS_ALPHA
| >>> doc = nlp(text)
| >>> # All strings mapped to integers, for easy export to numpy
| >>> np_array = doc.to_array([LOWER, POS, ENT_TYPE, IS_ALPHA])
|
| to_bytes(self, *, exclude=())
| Doc.to_bytes(self, *, exclude=tuple())
|
| Serialize, i.e. export the document contents to a binary string.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (bytes): A losslessly serialized copy of the `Doc`, including
| all annotations.
|
| DOCS: https://spacy.io/api/doc#to_bytes
|
| to_dict(self, *, exclude=())
| Doc.to_dict(self, *, exclude=tuple())
|
| Export the document contents to a dictionary for serialization.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (Dict[str, Any]): A dictionary representation of the `Doc`
|
| to_disk(self, path, *, exclude=())
| Doc.to_disk(self, path, *, exclude=tuple())
|
| Save the current state to a directory.
|
| path (str / Path): A path to a directory, which will be created if
| it doesn't exist. Paths may be either strings or Path-like objects.
| exclude (Iterable[str]): String names of serialization fields to exclude.
|
| DOCS: https://spacy.io/api/doc#to_disk
|
| to_json(self, underscore=None)
| Doc.to_json(self, underscore=None)
|
| Convert a Doc to JSON.
|
| underscore (list): Optional list of string names of custom doc._.
| attributes. Attribute values need to be JSON-serializable. Values will
| be added to an "_" key in the data, e.g. "_": {"foo": "bar"}.
| RETURNS (dict): The data in JSON format.
|
| to_utf8_array(self, nr_char=-1)
| Doc.to_utf8_array(self, int nr_char=-1)
|
| Encode word strings to utf8, and export to a fixed-width array
| of characters. Characters are placed into the array in the order:
| 0, -1, 1, -2, etc
| For example, if the array is sliced array[:, :8], the array will
| contain the first 4 characters and last 4 characters of each word ---
| with the middle characters clipped out. The value 255 is used as a pad
| value.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| get_extension(name)
| Doc.get_extension(cls, name)
|
| Look up a previously registered extension by name.
|
| name (str): Name of the extension.
| RETURNS (tuple): A `(default, method, getter, setter)` tuple.
|
| DOCS: https://spacy.io/api/doc#get_extension
|
| has_extension(name)
| Doc.has_extension(cls, name)
|
| Check whether an extension has been registered.
|
| name (str): Name of the extension.
| RETURNS (bool): Whether the extension has been registered.
|
| DOCS: https://spacy.io/api/doc#has_extension
|
| remove_extension(name)
| Doc.remove_extension(cls, name)
|
| Remove a previously registered extension.
|
| name (str): Name of the extension.
| RETURNS (tuple): A `(default, method, getter, setter)` tuple of the
| removed extension.
|
| DOCS: https://spacy.io/api/doc#remove_extension
|
| set_extension(name, **kwargs)
| Doc.set_extension(cls, name, **kwargs)
|
| Define a custom attribute which becomes available as `Doc._`.
|
| name (str): Name of the attribute to set.
| default: Optional default value of the attribute.
| getter (callable): Optional getter function.
| setter (callable): Optional setter function.
| method (callable): Optional method for method extension.
| force (bool): Force overwriting existing attribute.
|
| DOCS: https://spacy.io/api/doc#set_extension
| USAGE: https://spacy.io/usage/processing-pipelines#custom-components-attributes
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| from_docs(docs, ensure_whitespace=True, attrs=None, *, exclude=())
| Doc.from_docs(docs, ensure_whitespace=True, attrs=None, *, exclude=tuple())
|
| Concatenate multiple Doc objects to form a new one. Raises an error
| if the `Doc` objects do not all share the same `Vocab`.
|
| docs (list): A list of Doc objects.
| ensure_whitespace (bool): Insert a space between two adjacent docs
| whenever the first doc does not end in whitespace.
| attrs (list): Optional list of attribute ID ints or attribute name
| strings.
| exclude (Iterable[str]): Doc attributes to exclude. Supported
| attributes: `spans`, `tensor`, `user_data`.
| RETURNS (Doc): A doc that contains the concatenated docs, or None if no
| docs were given.
|
| DOCS: https://spacy.io/api/doc#from_docs
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| cats
| cats: object
|
| doc
|
| ents
| The named entities in the document. Returns a tuple of named entity
| `Span` objects, if the entity recognizer has been applied.
|
| RETURNS (tuple): Entities in the document, one `Span` per entity.
|
| DOCS: https://spacy.io/api/doc#ents
|
| has_unknown_spaces
| has_unknown_spaces: 'bool'
|
| has_vector
| A boolean value indicating whether a word vector is associated with
| the object.
|
| RETURNS (bool): Whether a word vector is associated with the object.
|
| DOCS: https://spacy.io/api/doc#has_vector
|
| is_nered
|
| is_parsed
|
| is_sentenced
|
| is_tagged
|
| lang
| RETURNS (uint64): ID of the language of the doc's vocabulary.
|
| lang_
| RETURNS (str): Language of the doc's vocabulary, e.g. 'en'.
|
| mem
|
| noun_chunks
| Iterate over the base noun phrases in the document. Yields base
| noun-phrase #[code Span] objects, if the language has a noun chunk iterator.
| Raises a NotImplementedError otherwise.
|
| A base noun phrase, or "NP chunk", is a noun
| phrase that does not permit other NPs to be nested within it – so no
| NP-level coordination, no prepositional phrases, and no relative
| clauses.
|
| YIELDS (Span): Noun chunks in the document.
|
| DOCS: https://spacy.io/api/doc#noun_chunks
|
| noun_chunks_iterator
| noun_chunks_iterator: object
|
| sentiment
| sentiment: 'float'
|
| sents
| Iterate over the sentences in the document. Yields sentence `Span`
| objects. Sentence spans have no label.
|
| YIELDS (Span): Sentences in the document.
|
| DOCS: https://spacy.io/api/doc#sents
|
| spans
|
| tensor
| tensor: object
|
| text
| A unicode representation of the document text.
|
| RETURNS (str): The original verbatim text of the document.
|
| text_with_ws
| An alias of `Doc.text`, provided for duck-type compatibility with
| `Span` and `Token`.
|
| RETURNS (str): The original verbatim text of the document.
|
| user_data
| user_data: object
|
| user_hooks
| user_hooks: dict
|
| user_span_hooks
| user_span_hooks: dict
|
| user_token_hooks
| user_token_hooks: dict
|
| vector
| A real-valued meaning representation. Defaults to an average of the
| token vectors.
|
| RETURNS (numpy.ndarray[ndim=1, dtype='float32']): A 1D numpy array
| representing the document's semantics.
|
| DOCS: https://spacy.io/api/doc#vector
|
| vector_norm
| The L2 norm of the document's vector representation.
|
| RETURNS (float): The L2 norm of the vector representation.
|
| DOCS: https://spacy.io/api/doc#vector_norm
|
| vocab
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __pyx_vtable__ = <capsule object NULL>
class DocBin(builtins.object)
| DocBin(attrs: Iterable[str] = ('ORTH', 'NORM', 'TAG', 'HEAD', 'DEP', 'ENT_IOB', 'ENT_TYPE', 'ENT_KB_ID', 'ENT_ID', 'LEMMA', 'MORPH', 'POS', 'SENT_START'), store_user_data: bool = False, docs: Iterable[spacy.tokens.doc.Doc] = []) -> None
|
| Pack Doc objects for binary serialization.
|
| The DocBin class lets you efficiently serialize the information from a
| collection of Doc objects. You can control which information is serialized
| by passing a list of attribute IDs, and optionally also specify whether the
| user data is serialized. The DocBin is faster and produces smaller data
| sizes than pickle, and allows you to deserialize without executing arbitrary
| Python code.
|
| The serialization format is gzipped msgpack, where the msgpack object has
| the following structure:
|
| {
| "attrs": List[uint64], # e.g. [TAG, HEAD, ENT_IOB, ENT_TYPE]
| "tokens": bytes, # Serialized numpy uint64 array with the token data
| "spans": List[Dict[str, bytes]], # SpanGroups data for each doc
| "spaces": bytes, # Serialized numpy boolean array with spaces data
| "lengths": bytes, # Serialized numpy int32 array with the doc lengths
| "strings": List[str] # List of unique strings in the token data
| "version": str, # DocBin version number
| }
|
| Strings for the words, tags, labels etc are represented by 64-bit hashes in
| the token data, and every string that occurs at least once is passed via the
| strings object. This means the storage is more efficient if you pack more
| documents together, because you have less duplication in the strings.
|
| A notable downside to this format is that you can't easily extract just one
| document from the DocBin.
|
| Methods defined here:
|
| __init__(self, attrs: Iterable[str] = ('ORTH', 'NORM', 'TAG', 'HEAD', 'DEP', 'ENT_IOB', 'ENT_TYPE', 'ENT_KB_ID', 'ENT_ID', 'LEMMA', 'MORPH', 'POS', 'SENT_START'), store_user_data: bool = False, docs: Iterable[spacy.tokens.doc.Doc] = []) -> None
| Create a DocBin object to hold serialized annotations.
|
| attrs (Iterable[str]): List of attributes to serialize. 'orth' and
| 'spacy' are always serialized, so they're not required.
| store_user_data (bool): Whether to write the `Doc.user_data` to bytes/file.
| docs (Iterable[Doc]): Docs to add.
|
| DOCS: https://spacy.io/api/docbin#init
|
| __len__(self) -> int
| RETURNS: The number of Doc objects added to the DocBin.
|
| add(self, doc: spacy.tokens.doc.Doc) -> None
| Add a Doc's annotations to the DocBin for serialization.
|
| doc (Doc): The Doc object to add.
|
| DOCS: https://spacy.io/api/docbin#add
|
| from_bytes(self, bytes_data: bytes) -> 'DocBin'
| Deserialize the DocBin's annotations from a bytestring.
|
| bytes_data (bytes): The data to load from.
| RETURNS (DocBin): The loaded DocBin.
|
| DOCS: https://spacy.io/api/docbin#from_bytes
|
| from_disk(self, path: Union[str, pathlib.Path]) -> 'DocBin'
| Load the DocBin from a file (typically called .spacy).
|
| path (str / Path): The file path.
| RETURNS (DocBin): The loaded DocBin.
|
| DOCS: https://spacy.io/api/docbin#to_disk
|
| get_docs(self, vocab: spacy.vocab.Vocab) -> Iterator[spacy.tokens.doc.Doc]
| Recover Doc objects from the annotations, using the given vocab.
| Note that the user data of each doc will be read (if available) and returned,
| regardless of the setting of 'self.store_user_data'.
|
| vocab (Vocab): The shared vocab.
| YIELDS (Doc): The Doc objects.
|
| DOCS: https://spacy.io/api/docbin#get_docs
|
| merge(self, other: 'DocBin') -> None
| Extend the annotations of this DocBin with the annotations from
| another. Will raise an error if the pre-defined attrs of the two
| DocBins don't match, or if they differ in whether or not to store
| user data.
|
| other (DocBin): The DocBin to merge into the current bin.
|
| DOCS: https://spacy.io/api/docbin#merge
|
| to_bytes(self) -> bytes
| Serialize the DocBin's annotations to a bytestring.
|
| RETURNS (bytes): The serialized DocBin.
|
| DOCS: https://spacy.io/api/docbin#to_bytes
|
| to_disk(self, path: Union[str, pathlib.Path]) -> None
| Save the DocBin to a file (typically called .spacy).
|
| path (str / Path): The file path.
|
| DOCS: https://spacy.io/api/docbin#to_disk
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class MorphAnalysis(builtins.object)
| MorphAnalysis(Vocab vocab, features=dict())
|
| Control access to morphological features for a token.
|
| Methods defined here:
|
| __contains__(...)
| MorphAnalysis.__contains__(self, feature)
|
| Test whether the morphological analysis contains some feature.
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __iter__(...)
| MorphAnalysis.__iter__(self)
|
| Iterate over the features in the analysis.
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(...)
| MorphAnalysis.__len__(self)
|
| The number of features in the analysis.
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __reduce__ = __reduce_cython__(...)
| MorphAnalysis.__reduce_cython__(self)
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__ = __setstate_cython__(...)
| MorphAnalysis.__setstate_cython__(self, __pyx_state)
|
| __str__(self, /)
| Return str(self).
|
| get(self, field, default=None)
| MorphAnalysis.get(self, field, default=None)
|
| Retrieve feature values by field.
|
| to_dict(self)
| MorphAnalysis.to_dict(self)
|
| Produce a dict representation.
|
| to_json(self)
| MorphAnalysis.to_json(self)
|
| Produce a json serializable representation as a UD FEATS-style
| string.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| from_id(vocab, key)
| MorphAnalysis.from_id(cls, Vocab vocab, hash_t key)
|
| Create a morphological analysis from a given ID.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| key
|
| vocab
class Span(builtins.object)
| A slice from a Doc object.
|
| DOCS: https://spacy.io/api/span
|
| Methods defined here:
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getitem__(...)
| Span.__getitem__(self, i)
|
| Get a `Token` or a `Span` object
|
| i (int or tuple): The index of the token within the span, or slice of
| the span to get.
| RETURNS (Token or Span): The token at `span[i]`.
|
| DOCS: https://spacy.io/api/span#getitem
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(...)
| Span.__iter__(self)
|
| Iterate over `Token` objects.
|
| YIELDS (Token): A `Token` object.
|
| DOCS: https://spacy.io/api/span#iter
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(...)
| Span.__len__(self)
|
| Get the number of tokens in the span.
|
| RETURNS (int): The number of tokens in the span.
|
| DOCS: https://spacy.io/api/span#len
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __reduce__(self)
| Span.__reduce__(self)
|
| __repr__(self, /)
| Return repr(self).
|
| as_doc(self, *, copy_user_data=False, array_head=None, array=None)
| Span.as_doc(self, *, bool copy_user_data=False, array_head=None, array=None)
|
| Create a `Doc` object with a copy of the `Span`'s data.
|
| copy_user_data (bool): Whether or not to copy the original doc's user data.
| array_head (tuple): `Doc` array attrs, can be passed in to speed up computation.
| array (ndarray): `Doc` as array, can be passed in to speed up computation.
| RETURNS (Doc): The `Doc` copy of the span.
|
| DOCS: https://spacy.io/api/span#as_doc
|
| char_span(self, start_idx, end_idx, label=0, kb_id=0, vector=None, id=0, alignment_mode='strict', span_id=0)
| Span.char_span(self, int start_idx, int end_idx, label=0, kb_id=0, vector=None, id=0, alignment_mode='strict', span_id=0)
|
| Create a `Span` object from the slice `span.text[start : end]`.
|
| start (int): The index of the first character of the span.
| end (int): The index of the first character after the span.
| label (Union[int, str]): A label to attach to the Span, e.g. for
| named entities.
| kb_id (Union[int, str]): An ID from a KB to capture the meaning of a named entity.
| vector (ndarray[ndim=1, dtype='float32']): A meaning representation of
| the span.
| id (Union[int, str]): Unused.
| alignment_mode (str): How character indices are aligned to token
| boundaries. Options: "strict" (character indices must be aligned
| with token boundaries), "contract" (span of all tokens completely
| within the character span), "expand" (span of all tokens at least
| partially covered by the character span). Defaults to "strict".
| span_id (Union[int, str]): An identifier to associate with the span.
| RETURNS (Span): The newly constructed object.
|
| get_lca_matrix(self)
| Span.get_lca_matrix(self)
|
| Calculates a matrix of Lowest Common Ancestors (LCA) for a given
| `Span`, where LCA[i, j] is the index of the lowest common ancestor among
| the tokens span[i] and span[j]. If they have no common ancestor within
| the span, LCA[i, j] will be -1.
|
| RETURNS (np.array[ndim=2, dtype=numpy.int32]): LCA matrix with shape
| (n, n), where n = len(self).
|
| DOCS: https://spacy.io/api/span#get_lca_matrix
|
| similarity(self, other)
| Span.similarity(self, other)
|
| Make a semantic similarity estimate. The default estimate is cosine
| similarity using an average of word vectors.
|
| other (object): The object to compare with. By default, accepts `Doc`,
| `Span`, `Token` and `Lexeme` objects.
| RETURNS (float): A scalar similarity score. Higher is more similar.
|
| DOCS: https://spacy.io/api/span#similarity
|
| to_array(self, py_attr_ids)
| Span.to_array(self, py_attr_ids) -> ndarray
|
| Given a list of M attribute IDs, export the tokens to a numpy
| `ndarray` of shape `(N, M)`, where `N` is the length of the document.
| The values will be 32-bit integers.
|
| attr_ids (list[int]): A list of attribute ID ints.
| RETURNS (numpy.ndarray[long, ndim=2]): A feature matrix, with one row
| per word, and one column per attribute indicated in the input
| `attr_ids`.
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| get_extension(name)
| Span.get_extension(cls, name)
|
| Look up a previously registered extension by name.
|
| name (str): Name of the extension.
| RETURNS (tuple): A `(default, method, getter, setter)` tuple.
|
| DOCS: https://spacy.io/api/span#get_extension
|
| has_extension(name)
| Span.has_extension(cls, name)
|
| Check whether an extension has been registered.
|
| name (str): Name of the extension.
| RETURNS (bool): Whether the extension has been registered.
|
| DOCS: https://spacy.io/api/span#has_extension
|
| remove_extension(name)
| Span.remove_extension(cls, name)
|
| Remove a previously registered extension.
|
| name (str): Name of the extension.
| RETURNS (tuple): A `(default, method, getter, setter)` tuple of the
| removed extension.
|
| DOCS: https://spacy.io/api/span#remove_extension
|
| set_extension(name, **kwargs)
| Span.set_extension(cls, name, **kwargs)
|
| Define a custom attribute which becomes available as `Span._`.
|
| name (str): Name of the attribute to set.
| default: Optional default value of the attribute.
| getter (callable): Optional getter function.
| setter (callable): Optional setter function.
| method (callable): Optional method for method extension.
| force (bool): Force overwriting existing attribute.
|
| DOCS: https://spacy.io/api/span#set_extension
| USAGE: https://spacy.io/usage/processing-pipelines#custom-components-attributes
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| conjuncts
| Tokens that are conjoined to the span's root.
|
| RETURNS (tuple): A tuple of Token objects.
|
| DOCS: https://spacy.io/api/span#lefts
|
| doc
|
| end
|
| end_char
|
| ent_id
| RETURNS (uint64): The entity ID.
|
| ent_id_
| RETURNS (str): The (string) entity ID.
|
| ents
| The named entities that fall completely within the span. Returns
| a tuple of `Span` objects.
|
| RETURNS (tuple): Entities in the span, one `Span` per entity.
|
| DOCS: https://spacy.io/api/span#ents
|
| has_vector
| A boolean value indicating whether a word vector is associated with
| the object.
|
| RETURNS (bool): Whether a word vector is associated with the object.
|
| DOCS: https://spacy.io/api/span#has_vector
|
| id
|
| id_
| RETURNS (str): The span's ID.
|
| kb_id
|
| kb_id_
| RETURNS (str): The span's KB ID.
|
| label
|
| label_
| RETURNS (str): The span's label.
|
| lefts
| Tokens that are to the left of the span, whose head is within the
| `Span`.
|
| YIELDS (Token):A left-child of a token of the span.
|
| DOCS: https://spacy.io/api/span#lefts
|
| lemma_
| RETURNS (str): The span's lemma.
|
| n_lefts
| The number of tokens that are to the left of the span, whose
| heads are within the span.
|
| RETURNS (int): The number of leftward immediate children of the
| span, in the syntactic dependency parse.
|
| DOCS: https://spacy.io/api/span#n_lefts
|
| n_rights
| The number of tokens that are to the right of the span, whose
| heads are within the span.
|
| RETURNS (int): The number of rightward immediate children of the
| span, in the syntactic dependency parse.
|
| DOCS: https://spacy.io/api/span#n_rights
|
| noun_chunks
| Iterate over the base noun phrases in the span. Yields base
| noun-phrase #[code Span] objects, if the language has a noun chunk iterator.
| Raises a NotImplementedError otherwise.
|
| A base noun phrase, or "NP chunk", is a noun
| phrase that does not permit other NPs to be nested within it – so no
| NP-level coordination, no prepositional phrases, and no relative
| clauses.
|
| YIELDS (Span): Noun chunks in the span.
|
| DOCS: https://spacy.io/api/span#noun_chunks
|
| orth_
| Verbatim text content (identical to `Span.text`). Exists mostly for
| consistency with other attributes.
|
| RETURNS (str): The span's text.
|
| rights
| Tokens that are to the right of the Span, whose head is within the
| `Span`.
|
| YIELDS (Token): A right-child of a token of the span.
|
| DOCS: https://spacy.io/api/span#rights
|
| root
| The token with the shortest path to the root of the
| sentence (or the root itself). If multiple tokens are equally
| high in the tree, the first token is taken.
|
| RETURNS (Token): The root token.
|
| DOCS: https://spacy.io/api/span#root
|
| sent
| Obtain the sentence that contains this span. If the given span
| crosses sentence boundaries, return only the first sentence
| to which it belongs.
|
| RETURNS (Span): The sentence span that the span is a part of.
|
| sentiment
| RETURNS (float): A scalar value indicating the positivity or
| negativity of the span.
|
| sents
| Obtain the sentences that contain this span. If the given span
| crosses sentence boundaries, return all sentences it is a part of.
|
| RETURNS (Iterable[Span]): All sentences that the span is a part of.
|
| DOCS: https://spacy.io/api/span#sents
|
| start
|
| start_char
|
| subtree
| Tokens within the span and tokens which descend from them.
|
| YIELDS (Token): A token within the span, or a descendant from it.
|
| DOCS: https://spacy.io/api/span#subtree
|
| tensor
| The span's slice of the doc's tensor.
|
| RETURNS (ndarray[ndim=2, dtype='float32']): A 2D numpy or cupy array
| representing the span's semantics.
|
| text
| RETURNS (str): The original verbatim text of the span.
|
| text_with_ws
| The text content of the span with a trailing whitespace character if
| the last token has one.
|
| RETURNS (str): The text content of the span (with trailing
| whitespace).
|
| vector
| A real-valued meaning representation. Defaults to an average of the
| token vectors.
|
| RETURNS (numpy.ndarray[ndim=1, dtype='float32']): A 1D numpy array
| representing the span's semantics.
|
| DOCS: https://spacy.io/api/span#vector
|
| vector_norm
| The L2 norm of the span's vector representation.
|
| RETURNS (float): The L2 norm of the vector representation.
|
| DOCS: https://spacy.io/api/span#vector_norm
|
| vocab
| RETURNS (Vocab): The Span's Doc's vocab.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __pyx_vtable__ = <capsule object NULL>
class SpanGroup(builtins.object)
| SpanGroup(doc, name='', *, attrs={}, spans=[])
|
| A group of spans that all belong to the same Doc object. The group
| can be named, and you can attach additional attributes to it. Span groups
| are generally accessed via the `doc.spans` attribute. The `doc.spans`
| attribute will convert lists of spans into a `SpanGroup` object for you
| automatically on assignment.
|
| Example:
| Construction 1
| >>> doc = nlp("Their goi ng home")
| >>> doc.spans["errors"] = SpanGroup(
| doc,
| name="errors",
| spans=[doc[0:1], doc[1:3]],
| attrs={"annotator": "matt"}
| )
|
| Construction 2
| >>> doc = nlp("Their goi ng home")
| >>> doc.spans["errors"] = [doc[0:1], doc[1:3]]
| >>> assert isinstance(doc.spans["errors"], SpanGroup)
|
| DOCS: https://spacy.io/api/spangroup
|
| Methods defined here:
|
| __add__(...)
| SpanGroup.__add__(self, other: SpanGroup) -> SpanGroup
|
| Operator +. Concatenate a span group with this group and return a
| new span group.
|
| other (SpanGroup): The SpanGroup to add.
|
| RETURNS (SpanGroup): The concatenated SpanGroup.
|
| DOCS: https://spacy.io/api/spangroup#add
|
| __delitem__(...)
| SpanGroup.__delitem__(self, int i)
|
| Delete a span from the span group at index i.
|
| i (int): The item index.
|
| DOCS: https://spacy.io/api/spangroup#delitem
|
| __getitem__(...)
| SpanGroup.__getitem__(self, int i) -> Span
|
| Get a span from the group. Note that a copy of the span is returned,
| so if any changes are made to this span, they are not reflected in the
| corresponding member of the span group.
|
| i (int): The item index.
| RETURNS (Span): The span at the given index.
|
| DOCS: https://spacy.io/api/spangroup#getitem
|
| __iadd__(...)
| SpanGroup.__iadd__(self, other: Union[SpanGroup, Iterable['Span']]) -> SpanGroup
|
| Operator +=. Append a span group or spans to this group and return
| the current span group.
|
| other (Union[SpanGroup, Iterable["Span"]]): The SpanGroup or spans to
| add.
|
| RETURNS (SpanGroup): The current span group.
|
| DOCS: https://spacy.io/api/spangroup#iadd
|
| __init__(...)
| Create a SpanGroup.
|
| doc (Doc): The reference Doc object.
| name (str): The group name.
| attrs (Dict[str, Any]): Optional JSON-serializable attributes to attach.
| spans (Iterable[Span]): The spans to add to the group.
|
| DOCS: https://spacy.io/api/spangroup#init
|
| __iter__(...)
| SpanGroup.__iter__(self)
|
| Iterate over the spans in this SpanGroup.
| YIELDS (Span): A span in this SpanGroup.
|
| DOCS: https://spacy.io/api/spangroup#iter
|
| __len__(...)
| SpanGroup.__len__(self)
|
| RETURNS (int): The number of spans in the group.
|
| DOCS: https://spacy.io/api/spangroup#len
|
| __radd__(self, value, /)
| Return value+self.
|
| __reduce__ = __reduce_cython__(...)
| SpanGroup.__reduce_cython__(self)
|
| __reduce_cython__(self)
| SpanGroup.__reduce_cython__(self)
|
| __repr__(self, /)
| Return repr(self).
|
| __setitem__(...)
| SpanGroup.__setitem__(self, int i, Span span)
|
| Set a span in the span group.
|
| i (int): The item index.
| span (Span): The span.
|
| DOCS: https://spacy.io/api/spangroup#setitem
|
| __setstate__ = __setstate_cython__(...)
| SpanGroup.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| SpanGroup.__setstate_cython__(self, __pyx_state)
|
| append(self, span)
| SpanGroup.append(self, Span span)
|
| Add a span to the group. The span must refer to the same Doc
| object as the span group.
|
| span (Span): The span to append.
|
| DOCS: https://spacy.io/api/spangroup#append
|
| copy(self, doc: "Optional['Doc']" = None) -> 'SpanGroup'
| SpanGroup.copy(self, doc: Optional['Doc'] = None) -> SpanGroup
|
| Clones the span group.
|
| doc (Doc): New reference document to which the copy is bound.
| RETURNS (SpanGroup): A copy of the span group.
|
| DOCS: https://spacy.io/api/spangroup#copy
|
| extend(self, spans_or_span_group: "Union[SpanGroup, Iterable['Span']]")
| SpanGroup.extend(self, spans_or_span_group: Union[SpanGroup, Iterable['Span']])
|
| Add multiple spans or contents of another SpanGroup to the group.
| All spans must refer to the same Doc object as the span group.
|
| spans (Union[SpanGroup, Iterable["Span"]]): The spans to add.
|
| DOCS: https://spacy.io/api/spangroup#extend
|
| from_bytes(self, bytes_data)
| SpanGroup.from_bytes(self, bytes_data)
|
| Deserialize the SpanGroup's contents from a byte string.
|
| bytes_data (bytes): The span group to load.
| RETURNS (SpanGroup): The deserialized span group.
|
| DOCS: https://spacy.io/api/spangroup#from_bytes
|
| to_bytes(self)
| SpanGroup.to_bytes(self)
|
| Serialize the SpanGroup's contents to a byte string.
|
| RETURNS (bytes): The serialized span group.
|
| DOCS: https://spacy.io/api/spangroup#to_bytes
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| attrs
| attrs: dict
|
| doc
| RETURNS (Doc): The reference document.
|
| DOCS: https://spacy.io/api/spangroup#doc
|
| has_overlap
| RETURNS (bool): Whether the group contains overlapping spans.
|
| DOCS: https://spacy.io/api/spangroup#has_overlap
|
| name
| name: str
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __pyx_vtable__ = <capsule object NULL>
class Token(builtins.object)
| An individual token – i.e. a word, punctuation symbol, whitespace,
| etc.
|
| DOCS: https://spacy.io/api/token
|
| Methods defined here:
|
| __bytes__(self)
| Token.__bytes__(self)
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(...)
| Token.__len__(self)
|
| The number of unicode characters in the token, i.e. `token.text`.
|
| RETURNS (int): The number of unicode characters in the token.
|
| DOCS: https://spacy.io/api/token#len
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __reduce__(self)
| Token.__reduce__(self)
|
| __repr__(self, /)
| Return repr(self).
|
| __str__(self, /)
| Return str(self).
|
| __unicode__(self)
| Token.__unicode__(self)
|
| check_flag(self, flag_id)
| Token.check_flag(self, attr_id_t flag_id) -> bool
|
| Check the value of a boolean flag.
|
| flag_id (int): The ID of the flag attribute.
| RETURNS (bool): Whether the flag is set.
|
| DOCS: https://spacy.io/api/token#check_flag
|
| has_dep(self)
| Token.has_dep(self)
|
| Check whether the token has annotated dep information.
| Returns False when the dep label is unset/missing.
|
| RETURNS (bool): Whether the dep label is valid or not.
|
| has_head(self)
| Token.has_head(self)
|
| Check whether the token has annotated head information.
| Return False when the head annotation is unset/missing.
|
| RETURNS (bool): Whether the head annotation is valid or not.
|
| has_morph(self)
| Token.has_morph(self)
|
| Check whether the token has annotated morph information.
| Return False when the morph annotation is unset/missing.
|
| RETURNS (bool): Whether the morph annotation is set.
|
| is_ancestor(self, descendant)
| Token.is_ancestor(self, descendant)
|
| Check whether this token is a parent, grandparent, etc. of another
| in the dependency tree.
|
| descendant (Token): Another token.
| RETURNS (bool): Whether this token is the ancestor of the descendant.
|
| DOCS: https://spacy.io/api/token#is_ancestor
|
| nbor(self, i=1)
| Token.nbor(self, int i=1)
|
| Get a neighboring token.
|
| i (int): The relative position of the token to get. Defaults to 1.
| RETURNS (Token): The token at position `self.doc[self.i+i]`.
|
| DOCS: https://spacy.io/api/token#nbor
|
| set_morph(self, features)
| Token.set_morph(self, features)
|
| similarity(self, other)
| Token.similarity(self, other)
|
| Make a semantic similarity estimate. The default estimate is cosine
| similarity using an average of word vectors.
|
| other (object): The object to compare with. By default, accepts `Doc`,
| `Span`, `Token` and `Lexeme` objects.
| RETURNS (float): A scalar similarity score. Higher is more similar.
|
| DOCS: https://spacy.io/api/token#similarity
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| get_extension(name)
| Token.get_extension(cls, name)
|
| Look up a previously registered extension by name.
|
| name (str): Name of the extension.
| RETURNS (tuple): A `(default, method, getter, setter)` tuple.
|
| DOCS: https://spacy.io/api/token#get_extension
|
| has_extension(name)
| Token.has_extension(cls, name)
|
| Check whether an extension has been registered.
|
| name (str): Name of the extension.
| RETURNS (bool): Whether the extension has been registered.
|
| DOCS: https://spacy.io/api/token#has_extension
|
| iob_strings()
| Token.iob_strings(cls)
|
| remove_extension(name)
| Token.remove_extension(cls, name)
|
| Remove a previously registered extension.
|
| name (str): Name of the extension.
| RETURNS (tuple): A `(default, method, getter, setter)` tuple of the
| removed extension.
|
| DOCS: https://spacy.io/api/token#remove_extension
|
| set_extension(name, **kwargs)
| Token.set_extension(cls, name, **kwargs)
|
| Define a custom attribute which becomes available as `Token._`.
|
| name (str): Name of the attribute to set.
| default: Optional default value of the attribute.
| getter (callable): Optional getter function.
| setter (callable): Optional setter function.
| method (callable): Optional method for method extension.
| force (bool): Force overwriting existing attribute.
|
| DOCS: https://spacy.io/api/token#set_extension
| USAGE: https://spacy.io/usage/processing-pipelines#custom-components-attributes
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| ancestors
| A sequence of this token's syntactic ancestors.
|
| YIELDS (Token): A sequence of ancestor tokens such that
| `ancestor.is_ancestor(self)`.
|
| DOCS: https://spacy.io/api/token#ancestors
|
| children
| A sequence of the token's immediate syntactic children.
|
| YIELDS (Token): A child token such that `child.head==self`.
|
| DOCS: https://spacy.io/api/token#children
|
| cluster
| RETURNS (int): Brown cluster ID.
|
| conjuncts
| A sequence of coordinated tokens, including the token itself.
|
| RETURNS (tuple): The coordinated tokens.
|
| DOCS: https://spacy.io/api/token#conjuncts
|
| dep
| RETURNS (uint64): ID of syntactic dependency label.
|
| dep_
| RETURNS (str): The syntactic dependency label.
|
| doc
|
| ent_id
| RETURNS (uint64): ID of the entity the token is an instance of,
| if any.
|
| ent_id_
| RETURNS (str): ID of the entity the token is an instance of,
| if any.
|
| ent_iob
| IOB code of named entity tag. `1="I", 2="O", 3="B"`. 0 means no tag
| is assigned.
|
| RETURNS (uint64): IOB code of named entity tag.
|
| ent_iob_
| IOB code of named entity tag. "B" means the token begins an entity,
| "I" means it is inside an entity, "O" means it is outside an entity,
| and "" means no entity tag is set. "B" with an empty ent_type
| means that the token is blocked from further processing by NER.
|
| RETURNS (str): IOB code of named entity tag.
|
| ent_kb_id
| RETURNS (uint64): Named entity KB ID.
|
| ent_kb_id_
| RETURNS (str): Named entity KB ID.
|
| ent_type
| RETURNS (uint64): Named entity type.
|
| ent_type_
| RETURNS (str): Named entity type.
|
| has_vector
| A boolean value indicating whether a word vector is associated with
| the object.
|
| RETURNS (bool): Whether a word vector is associated with the object.
|
| DOCS: https://spacy.io/api/token#has_vector
|
| head
| The syntactic parent, or "governor", of this token.
| If token.has_head() is `False`, this method will return itself.
|
| RETURNS (Token): The token predicted by the parser to be the head of
| the current token.
|
| i
|
| idx
| RETURNS (int): The character offset of the token within the parent
| document.
|
| is_alpha
| RETURNS (bool): Whether the token consists of alpha characters.
| Equivalent to `token.text.isalpha()`.
|
| is_ascii
| RETURNS (bool): Whether the token consists of ASCII characters.
| Equivalent to `[any(ord(c) >= 128 for c in token.text)]`.
|
| is_bracket
| RETURNS (bool): Whether the token is a bracket.
|
| is_currency
| RETURNS (bool): Whether the token is a currency symbol.
|
| is_digit
| RETURNS (bool): Whether the token consists of digits. Equivalent to
| `token.text.isdigit()`.
|
| is_left_punct
| RETURNS (bool): Whether the token is a left punctuation mark.
|
| is_lower
| RETURNS (bool): Whether the token is in lowercase. Equivalent to
| `token.text.islower()`.
|
| is_oov
| RETURNS (bool): Whether the token is out-of-vocabulary.
|
| is_punct
| RETURNS (bool): Whether the token is punctuation.
|
| is_quote
| RETURNS (bool): Whether the token is a quotation mark.
|
| is_right_punct
| RETURNS (bool): Whether the token is a right punctuation mark.
|
| is_sent_end
| A boolean value indicating whether the token ends a sentence.
| `None` if unknown. Defaults to `True` for the last token in the `Doc`.
|
| RETURNS (bool / None): Whether the token ends a sentence.
| None if unknown.
|
| DOCS: https://spacy.io/api/token#is_sent_end
|
| is_sent_start
| A boolean value indicating whether the token starts a sentence.
| `None` if unknown. Defaults to `True` for the first token in the `Doc`.
|
| RETURNS (bool / None): Whether the token starts a sentence.
| None if unknown.
|
| is_space
| RETURNS (bool): Whether the token consists of whitespace characters.
| Equivalent to `token.text.isspace()`.
|
| is_stop
| RETURNS (bool): Whether the token is a stop word, i.e. part of a
| "stop list" defined by the language data.
|
| is_title
| RETURNS (bool): Whether the token is in titlecase. Equivalent to
| `token.text.istitle()`.
|
| is_upper
| RETURNS (bool): Whether the token is in uppercase. Equivalent to
| `token.text.isupper()`
|
| lang
| RETURNS (uint64): ID of the language of the parent document's
| vocabulary.
|
| lang_
| RETURNS (str): Language of the parent document's vocabulary,
| e.g. 'en'.
|
| left_edge
| Token.left_edge: int
|
| The leftmost token of this token's syntactic descendents.
|
| RETURNS (Token): The first token such that `self.is_ancestor(token)`.
|
| lefts
| The leftward immediate children of the word, in the syntactic
| dependency parse.
|
| YIELDS (Token): A left-child of the token.
|
| DOCS: https://spacy.io/api/token#lefts
|
| lemma
| RETURNS (uint64): ID of the base form of the word, with no
| inflectional suffixes.
|
| lemma_
| RETURNS (str): The token lemma, i.e. the base form of the word,
| with no inflectional suffixes.
|
| lex
| RETURNS (Lexeme): The underlying lexeme.
|
| lex_id
| RETURNS (int): Sequential ID of the token's lexical type.
|
| like_email
| RETURNS (bool): Whether the token resembles an email address.
|
| like_num
| RETURNS (bool): Whether the token resembles a number, e.g. "10.9",
| "10", "ten", etc.
|
| like_url
| RETURNS (bool): Whether the token resembles a URL.
|
| lower
| RETURNS (uint64): ID of the lowercase token text.
|
| lower_
| RETURNS (str): The lowercase token text. Equivalent to
| `Token.text.lower()`.
|
| morph
|
| n_lefts
| The number of leftward immediate children of the word, in the
| syntactic dependency parse.
|
| RETURNS (int): The number of leftward immediate children of the
| word, in the syntactic dependency parse.
|
| DOCS: https://spacy.io/api/token#n_lefts
|
| n_rights
| The number of rightward immediate children of the word, in the
| syntactic dependency parse.
|
| RETURNS (int): The number of rightward immediate children of the
| word, in the syntactic dependency parse.
|
| DOCS: https://spacy.io/api/token#n_rights
|
| norm
| RETURNS (uint64): ID of the token's norm, i.e. a normalised form of
| the token text. Usually set in the language's tokenizer exceptions
| or norm exceptions.
|
| norm_
| RETURNS (str): The token's norm, i.e. a normalised form of the
| token text. Usually set in the language's tokenizer exceptions or
| norm exceptions.
|
| orth
| RETURNS (uint64): ID of the verbatim text content.
|
| orth_
| RETURNS (str): Verbatim text content (identical to
| `Token.text`). Exists mostly for consistency with the other
| attributes.
|
| pos
| RETURNS (uint64): ID of coarse-grained part-of-speech tag.
|
| pos_
| RETURNS (str): Coarse-grained part-of-speech tag.
|
| prefix
| RETURNS (uint64): ID of a length-N substring from the start of the
| token. Defaults to `N=1`.
|
| prefix_
| RETURNS (str): A length-N substring from the start of the token.
| Defaults to `N=1`.
|
| prob
| RETURNS (float): Smoothed log probability estimate of token type.
|
| rank
| RETURNS (int): Sequential ID of the token's lexical type, used to
| index into tables, e.g. for word vectors.
|
| right_edge
| Token.right_edge: int
|
| The rightmost token of this token's syntactic descendents.
|
| RETURNS (Token): The last token such that `self.is_ancestor(token)`.
|
| rights
| The rightward immediate children of the word, in the syntactic
| dependency parse.
|
| YIELDS (Token): A right-child of the token.
|
| DOCS: https://spacy.io/api/token#rights
|
| sent
| RETURNS (Span): The sentence span that the token is a part of.
|
| sent_start
| Deprecated: use Token.is_sent_start instead.
|
| sentiment
| RETURNS (float): A scalar value indicating the positivity or
| negativity of the token.
|
| shape
| RETURNS (uint64): ID of the token's shape, a transform of the
| token's string, to show orthographic features (e.g. "Xxxx", "dd").
|
| shape_
| RETURNS (str): Transform of the token's string, to show
| orthographic features. For example, "Xxxx" or "dd".
|
| subtree
| A sequence containing the token and all the token's syntactic
| descendants.
|
| YIELDS (Token): A descendent token such that
| `self.is_ancestor(descendent) or token == self`.
|
| DOCS: https://spacy.io/api/token#subtree
|
| suffix
| RETURNS (uint64): ID of a length-N substring from the end of the
| token. Defaults to `N=3`.
|
| suffix_
| RETURNS (str): A length-N substring from the end of the token.
| Defaults to `N=3`.
|
| tag
| RETURNS (uint64): ID of fine-grained part-of-speech tag.
|
| tag_
| RETURNS (str): Fine-grained part-of-speech tag.
|
| tensor
|
| text
| RETURNS (str): The original verbatim text of the token.
|
| text_with_ws
| RETURNS (str): The text content of the span (with trailing
| whitespace).
|
| vector
| A real-valued meaning representation.
|
| RETURNS (numpy.ndarray[ndim=1, dtype='float32']): A 1D numpy array
| representing the token's semantics.
|
| DOCS: https://spacy.io/api/token#vector
|
| vector_norm
| The L2 norm of the token's vector representation.
|
| RETURNS (float): The L2 norm of the vector representation.
|
| DOCS: https://spacy.io/api/token#vector_norm
|
| vocab
|
| whitespace_
| RETURNS (str): The trailing whitespace character, if present.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __pyx_vtable__ = <capsule object NULL>
DATA
__all__ = ['Doc', 'DocBin', 'MorphAnalysis', 'Span', 'SpanGroup', 'Tok...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\tokens\__init__.py
spacy.training
Python Library Documentation: package spacy.training in spacy
NAME
spacy.training
PACKAGE CONTENTS
align
alignment
alignment_array
augment
batchers
callbacks
converters (package)
corpus
example
gold_io
initialize
iob_utils
loggers
loop
pretrain
CLASSES
builtins.object
spacy.training.alignment.Alignment
spacy.training.corpus.Corpus
spacy.training.corpus.JsonlCorpus
spacy.training.corpus.PlainTextCorpus
spacy.training.example.Example
class Alignment(builtins.object)
| Alignment(x2y: spacy.training.alignment_array.AlignmentArray, y2x: spacy.training.alignment_array.AlignmentArray) -> None
|
| Alignment(x2y: spacy.training.alignment_array.AlignmentArray, y2x: spacy.training.alignment_array.AlignmentArray)
|
| Methods defined here:
|
| __eq__(self, other)
| Return self==value.
|
| __init__(self, x2y: spacy.training.alignment_array.AlignmentArray, y2x: spacy.training.alignment_array.AlignmentArray) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| __repr__(self)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| from_indices(x2y: List[List[int]], y2x: List[List[int]]) -> 'Alignment'
|
| from_strings(A: List[str], B: List[str]) -> 'Alignment'
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {'x2y': <class 'spacy.training.alignment_array.Align...
|
| __dataclass_fields__ = {'x2y': Field(name='x2y',type=<class 'spacy.tra...
|
| __dataclass_params__ = _DataclassParams(init=True,repr=True,eq=True,or...
|
| __hash__ = None
|
| __match_args__ = ('x2y', 'y2x')
class Corpus(builtins.object)
| Corpus(path: Union[str, pathlib.Path], *, limit: int = 0, gold_preproc: bool = False, max_length: int = 0, augmenter: Optional[Callable] = None, shuffle: bool = False) -> None
|
| Iterate Example objects from a file or directory of DocBin (.spacy)
| formatted data files.
|
| path (Path): The directory or filename to read from.
| gold_preproc (bool): Whether to set up the Example object with gold-standard
| sentences and tokens for the predictions. Gold preprocessing helps
| the annotations align to the tokenization, and may result in sequences
| of more consistent length. However, it may reduce run-time accuracy due
| to train/test skew. Defaults to False.
| max_length (int): Maximum document length. Longer documents will be
| split into sentences, if sentence boundaries are available. Defaults to
| 0, which indicates no limit.
| limit (int): Limit corpus to a subset of examples, e.g. for debugging.
| Defaults to 0, which indicates no limit.
| augment (Callable[Example, Iterable[Example]]): Optional data augmentation
| function, to extrapolate additional examples from your annotations.
| shuffle (bool): Whether to shuffle the examples.
|
| DOCS: https://spacy.io/api/corpus
|
| Methods defined here:
|
| __call__(self, nlp: 'Language') -> Iterator[spacy.training.example.Example]
| Yield examples from the data.
|
| nlp (Language): The current nlp object.
| YIELDS (Example): The examples.
|
| DOCS: https://spacy.io/api/corpus#call
|
| __init__(self, path: Union[str, pathlib.Path], *, limit: int = 0, gold_preproc: bool = False, max_length: int = 0, augmenter: Optional[Callable] = None, shuffle: bool = False) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| make_examples(self, nlp: 'Language', reference_docs: Iterable[spacy.tokens.doc.Doc]) -> Iterator[spacy.training.example.Example]
|
| make_examples_gold_preproc(self, nlp: 'Language', reference_docs: Iterable[spacy.tokens.doc.Doc]) -> Iterator[spacy.training.example.Example]
|
| read_docbin(self, vocab: spacy.vocab.Vocab, locs: Iterable[Union[str, pathlib.Path]]) -> Iterator[spacy.tokens.doc.Doc]
| Yield training examples as example dicts
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class Example(builtins.object)
| Example(Doc predicted, Doc reference, alignment=None, *)
|
| Methods defined here:
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __len__(self, /)
| Return len(self).
|
| __reduce__ = __reduce_cython__(...)
| Example.__reduce_cython__(self)
|
| __reduce_cython__(self)
| Example.__reduce_cython__(self)
|
| __repr__(self, /)
| Return repr(self).
|
| __setstate__ = __setstate_cython__(...)
| Example.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| Example.__setstate_cython__(self, __pyx_state)
|
| __str__(self, /)
| Return str(self).
|
| copy(self)
| Example.copy(self)
|
| get_aligned(self, field, as_string=False)
| Example.get_aligned(self, field, as_string=False)
|
| Return an aligned array for a token attribute.
|
| get_aligned_ents_and_ner(self)
| Example.get_aligned_ents_and_ner(self)
|
| get_aligned_ner(self)
| Example.get_aligned_ner(self)
|
| get_aligned_parse(self, projectivize=True)
| Example.get_aligned_parse(self, projectivize=True)
|
| get_aligned_sent_starts(self)
| Example.get_aligned_sent_starts(self)
|
| Get list of SENT_START attributes aligned to the predicted tokenization.
| If the reference does not have sentence starts, return a list of None values.
|
| get_aligned_spans_x2y(self, x_spans, allow_overlap=False)
| Example.get_aligned_spans_x2y(self, x_spans, allow_overlap=False)
|
| get_aligned_spans_y2x(self, y_spans, allow_overlap=False)
| Example.get_aligned_spans_y2x(self, y_spans, allow_overlap=False)
|
| get_matching_ents(self, check_label=True)
| Example.get_matching_ents(self, check_label=True)
|
| Return entities that are shared between predicted and reference docs.
|
| If `check_label` is True, entities must have matching labels to be
| kept. Otherwise only the character indices need to match.
|
| split_sents(self)
| Example.split_sents(self)
|
| Split the token annotations into multiple Examples based on
| sent_starts and return a list of the new Examples
|
| to_dict(self)
| Example.to_dict(self)
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| from_dict(predicted, example_dict)
| Example.from_dict(cls, Doc predicted, dict example_dict)
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| alignment
|
| predicted
|
| reference
|
| text
|
| x
|
| y
class JsonlCorpus(builtins.object)
| JsonlCorpus(path: Union[str, pathlib.Path, NoneType], *, limit: int = 0, min_length: int = 0, max_length: int = 0) -> None
|
| Iterate Example objects from a file or directory of jsonl
| formatted raw text files.
|
| path (Path): The directory or filename to read from.
| min_length (int): Minimum document length (in tokens). Shorter documents
| will be skipped. Defaults to 0, which indicates no limit.
|
| max_length (int): Maximum document length (in tokens). Longer documents will
| be skipped. Defaults to 0, which indicates no limit.
| limit (int): Limit corpus to a subset of examples, e.g. for debugging.
| Defaults to 0, which indicates no limit.
|
| DOCS: https://spacy.io/api/corpus#jsonlcorpus
|
| Methods defined here:
|
| __call__(self, nlp: 'Language') -> Iterator[spacy.training.example.Example]
| Yield examples from the data.
|
| nlp (Language): The current nlp object.
| YIELDS (Example): The example objects.
|
| DOCS: https://spacy.io/api/corpus#jsonlcorpus-call
|
| __init__(self, path: Union[str, pathlib.Path, NoneType], *, limit: int = 0, min_length: int = 0, max_length: int = 0) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| file_type = 'jsonl'
class PlainTextCorpus(builtins.object)
| PlainTextCorpus(path: Union[str, pathlib.Path, NoneType], *, min_length: int = 0, max_length: int = 0) -> None
|
| Iterate Example objects from a file or directory of plain text
| UTF-8 files with one line per doc.
|
| path (Path): The directory or filename to read from.
| min_length (int): Minimum document length (in tokens). Shorter documents
| will be skipped. Defaults to 0, which indicates no limit.
| max_length (int): Maximum document length (in tokens). Longer documents will
| be skipped. Defaults to 0, which indicates no limit.
|
| DOCS: https://spacy.io/api/corpus#plaintextcorpus
|
| Methods defined here:
|
| __call__(self, nlp: 'Language') -> Iterator[spacy.training.example.Example]
| Yield examples from the data.
|
| nlp (Language): The current nlp object.
| YIELDS (Example): The example objects.
|
| DOCS: https://spacy.io/api/corpus#plaintextcorpus-call
|
| __init__(self, path: Union[str, pathlib.Path, NoneType], *, min_length: int = 0, max_length: int = 0) -> None
| Initialize self. See help(type(self)) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| file_type = 'txt'
FUNCTIONS
biluo_tags_to_offsets(doc: spacy.tokens.doc.Doc, tags: Iterable[str]) -> List[Tuple[int, int, Union[str, int]]]
Encode per-token tags following the BILUO scheme into entity offsets.
doc (Doc): The document that the BILUO tags refer to.
tags (iterable): A sequence of BILUO tags with each tag describing one
token. Each tags string will be of the form of either "", "O" or
"{action}-{label}", where action is one of "B", "I", "L", "U".
RETURNS (list): A sequence of `(start, end, label)` triples. `start` and
`end` will be character-offset integers denoting the slice into the
original string.
biluo_tags_to_spans(doc: spacy.tokens.doc.Doc, tags: Iterable[str]) -> List[spacy.tokens.span.Span]
Encode per-token tags following the BILUO scheme into Span object, e.g.
to overwrite the doc.ents.
doc (Doc): The document that the BILUO tags refer to.
tags (iterable): A sequence of BILUO tags with each tag describing one
token. Each tag string will be of the form of either "", "O" or
"{action}-{label}", where action is one of "B", "I", "L", "U".
RETURNS (list): A sequence of Span objects. Each token with a missing IOB
tag is returned as a Span with an empty label.
biluo_to_iob(tags: Iterable[str]) -> List[str]
create_copy_from_base_model(tokenizer: Optional[str] = None, vocab: Optional[str] = None) -> Callable[[ForwardRef('Language')], ForwardRef('Language')]
docs_to_json(docs, doc_id=0, ner_missing_tag='O')
docs_to_json(docs, doc_id=0, ner_missing_tag='O')
Convert a list of Doc objects into the JSON-serializable format used by
the spacy train command.
docs (iterable / Doc): The Doc object(s) to convert.
doc_id (int): Id for the JSON.
RETURNS (dict): The data in spaCy's JSON format
- each input doc will be treated as a paragraph in the output doc
dont_augment(nlp: 'Language', example: spacy.training.example.Example) -> Iterator[spacy.training.example.Example]
iob_to_biluo(tags: Iterable[str]) -> List[str]
minibatch_by_padded_size(seqs: Iterable[~ItemT], size: Union[Sequence[int], int], buffer: int = 256, discard_oversize: bool = False, get_length: Callable = <built-in function len>) -> Iterable[List[~ItemT]]
Minibatch a sequence by the size of padded batches that would result,
with sequences binned by length within a window.
The padded size is defined as the maximum length of sequences within the
batch multiplied by the number of sequences in the batch.
size (int or Sequence[int]): The largest padded size to batch sequences into.
buffer (int): The number of sequences to accumulate before sorting by length.
A larger buffer will result in more even sizing, but if the buffer is
very large, the iteration order will be less random, which can result
in suboptimal training.
discard_oversize (bool): Whether to discard sequences that are by themselves
longer than the largest padded batch size.
get_length (Callable or None): Function to get the length of a sequence item.
The `len` function is used by default.
minibatch_by_words(seqs: Iterable[~ItemT], size: Union[Sequence[int], int], tolerance=0.2, discard_oversize=False, get_length=<built-in function len>) -> Iterable[List[~ItemT]]
Create minibatches of roughly a given number of words. If any examples
are longer than the specified batch length, they will appear in a batch by
themselves, or be discarded if discard_oversize=True.
seqs (Iterable[Sequence]): The sequences to minibatch.
size (int or Sequence[int]): The target number of words per batch.
Can be a single integer, or a sequence, allowing for variable batch sizes.
tolerance (float): What percentage of the size to allow batches to exceed.
discard_oversize (bool): Whether to discard sequences that by themselves
exceed the tolerated size.
get_length (Callable or None): Function to get the length of a sequence
item. The `len` function is used by default.
offsets_to_biluo_tags(doc: spacy.tokens.doc.Doc, entities: Iterable[Tuple[int, int, Union[str, int]]], missing: str = 'O') -> List[str]
Encode labelled spans into per-token tags, using the
Begin/In/Last/Unit/Out scheme (BILUO).
doc (Doc): The document that the entity offsets refer to. The output tags
will refer to the token boundaries within the document.
entities (iterable): A sequence of `(start, end, label)` triples. `start`
and `end` should be character-offset integers denoting the slice into
the original string.
missing (str): The label used for missing values, e.g. if tokenization
doesn’t align with the entity offsets. Defaults to "O".
RETURNS (list): A list of unicode strings, describing the tags. Each tag
string will be of the form either "", "O" or "{action}-{label}", where
action is one of "B", "I", "L", "U". The missing label is used where the
entity offsets don't align with the tokenization in the `Doc` object.
The training algorithm will view these as missing values. "O" denotes a
non-entity token. "B" denotes the beginning of a multi-token entity,
"I" the inside of an entity of three or more tokens, and "L" the end
of an entity of two or more tokens. "U" denotes a single-token entity.
EXAMPLE:
>>> text = 'I like London.'
>>> entities = [(len('I like '), len('I like London'), 'LOC')]
>>> doc = nlp.tokenizer(text)
>>> tags = offsets_to_biluo_tags(doc, entities)
>>> assert tags == ["O", "O", 'U-LOC', "O"]
orth_variants_augmenter(nlp: 'Language', example: spacy.training.example.Example, orth_variants: Dict[str, List[Dict]], *, level: float = 0.0, lower: float = 0.0) -> Iterator[spacy.training.example.Example]
read_json_file(loc, docs_filter=None, limit=None)
read_json_file(loc, docs_filter=None, limit=None)
Read Example dictionaries from a json file or directory.
remove_bilu_prefix(label: str) -> str
split_bilu_label(label: str) -> Tuple[str, str]
tags_to_entities(tags: Iterable[str]) -> List[Tuple[str, int, int]]
Note that the end index returned by this function is inclusive.
To use it for Span creation, increment the end by 1.
validate_examples(examples, method)
validate_examples(examples, method)
Check that a batch of examples received during processing is valid.
This function lives here to prevent circular imports.
examples (Iterable[Examples]): A batch of examples.
method (str): The method name to show in error messages.
validate_get_examples(get_examples, method)
validate_get_examples(get_examples, method)
Check that a generator of a batch of examples received during processing is valid:
the callable produces a non-empty list of Example objects.
This function lives here to prevent circular imports.
get_examples (Callable[[], Iterable[Example]]): A function that produces a batch of examples.
method (str): The method name to show in error messages.
DATA
__all__ = ['Alignment', 'Corpus', 'Example', 'JsonlCorpus', 'PlainText...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\training\__init__.py
spacy.ty
Python Library Documentation: module spacy.ty in spacy
NAME
spacy.ty
CLASSES
typing.Protocol(typing.Generic)
InitializableComponent
ListenedToComponent
TrainableComponent
class InitializableComponent(typing.Protocol)
| InitializableComponent(*args, **kwargs)
|
| Method resolution order:
| InitializableComponent
| typing.Protocol
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__ = _no_init_or_replace_init(self, *args, **kwargs) from typing
|
| initialize(self, get_examples: Callable[[], Iterable[ForwardRef('Example')]], nlp: 'Language', **kwargs: Any)
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __subclasshook__ = _proto_hook(other) from typing
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {}
|
| __non_callable_proto_members__ = set()
|
| __parameters__ = ()
|
| __protocol_attrs__ = {'initialize'}
|
| ----------------------------------------------------------------------
| Class methods inherited from typing.Protocol:
|
| __init_subclass__(*args, **kwargs)
| Function to initialize subclasses.
|
| ----------------------------------------------------------------------
| Class methods inherited from typing.Generic:
|
| __class_getitem__(...)
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
class ListenedToComponent(typing.Protocol)
| ListenedToComponent(*args, **kwargs)
|
| Method resolution order:
| ListenedToComponent
| typing.Protocol
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__ = _no_init_or_replace_init(self, *args, **kwargs) from typing
|
| add_listener(self, listener: thinc.model.Model, component_name: str) -> None
|
| find_listeners(self, component) -> None
|
| remove_listener(self, listener: thinc.model.Model, component_name: str) -> bool
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __subclasshook__ = _proto_hook(other) from typing
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'listener_map': typing.Dict[str, typing.Sequence[th...
|
| __non_callable_proto_members__ = {'listener_map', 'listeners', 'listen...
|
| __parameters__ = ()
|
| __protocol_attrs__ = {'add_listener', 'find_listeners', 'listener_map'...
|
| ----------------------------------------------------------------------
| Class methods inherited from typing.Protocol:
|
| __init_subclass__(*args, **kwargs)
| Function to initialize subclasses.
|
| ----------------------------------------------------------------------
| Class methods inherited from typing.Generic:
|
| __class_getitem__(...)
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
class TrainableComponent(typing.Protocol)
| TrainableComponent(*args, **kwargs)
|
| Method resolution order:
| TrainableComponent
| typing.Protocol
| typing.Generic
| builtins.object
|
| Methods defined here:
|
| __init__ = _no_init_or_replace_init(self, *args, **kwargs) from typing
|
| finish_update(self, sgd: thinc.optimizers.Optimizer) -> None
|
| update(self, examples: Iterable[ForwardRef('Example')], *, drop: float = 0.0, sgd: Optional[thinc.optimizers.Optimizer] = None, losses: Optional[Dict[str, float]] = None) -> Dict[str, float]
|
| ----------------------------------------------------------------------
| Class methods defined here:
|
| __subclasshook__ = _proto_hook(other) from typing
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __abstractmethods__ = frozenset()
|
| __annotations__ = {'is_trainable': <class 'bool'>, 'model': typing.Any...
|
| __non_callable_proto_members__ = {'is_trainable', 'model'}
|
| __parameters__ = ()
|
| __protocol_attrs__ = {'finish_update', 'is_trainable', 'model', 'updat...
|
| ----------------------------------------------------------------------
| Class methods inherited from typing.Protocol:
|
| __init_subclass__(*args, **kwargs)
| Function to initialize subclasses.
|
| ----------------------------------------------------------------------
| Class methods inherited from typing.Generic:
|
| __class_getitem__(...)
| Parameterizes a generic class.
|
| At least, parameterizing a generic class is the *main* thing this
| method does. For example, for some generic class `Foo`, this is called
| when we do `Foo[int]` - there, with `cls=Foo` and `params=int`.
|
| However, note that this method is also called when defining generic
| classes in the first place with `class Foo[T]: ...`.
DATA
Callable = typing.Callable
Deprecated alias to collections.abc.Callable.
Callable[[int], str] signifies a function that takes a single
parameter of type int and returns a str.
The subscription syntax must always be used with exactly two
values: the argument list and the return type.
The argument list must be a list of types, a ParamSpec,
Concatenate or ellipsis. The return type must be a single type.
There is no syntax to indicate optional or keyword arguments;
such function types are rarely used as callback types.
Dict = typing.Dict
A generic version of dict.
Iterable = typing.Iterable
A generic version of collections.abc.Iterable.
List = typing.List
A generic version of list.
Optional = typing.Optional
Optional[X] is equivalent to Union[X, None].
Sequence = typing.Sequence
A generic version of collections.abc.Sequence.
TYPE_CHECKING = False
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\ty.py
spacy.util
Python Library Documentation: module spacy.util in spacy
NAME
spacy.util
CLASSES
builtins.dict(builtins.object)
SimpleFrozenDict
builtins.list(builtins.object)
SimpleFrozenList
builtins.object
DummyTokenizer
ENV_VARS
thinc.config.registry(confection._registry.registry)
registry
class DummyTokenizer(builtins.object)
| Methods defined here:
|
| __call__(self, text)
| Call self as a function.
|
| from_bytes(self, data: bytes, **kwargs) -> 'DummyTokenizer'
|
| from_disk(self, path: Union[str, pathlib.Path], **kwargs) -> 'DummyTokenizer'
|
| pipe(self, texts, **kwargs)
|
| to_bytes(self, **kwargs)
| # add dummy methods for to_bytes, from_bytes, to_disk and from_disk to
| # allow serialization (see #1557)
|
| to_disk(self, path: Union[str, pathlib.Path], **kwargs) -> None
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
class ENV_VARS(builtins.object)
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| CONFIG_OVERRIDES = 'SPACY_CONFIG_OVERRIDES'
class SimpleFrozenDict(builtins.dict)
| SimpleFrozenDict(*args, error: str = "[E095] Can't write to frozen dictionary. This is likely an internal error. Are you writing to a default function argument?", **kwargs) -> None
|
| Simplified implementation of a frozen dict, mainly used as default
| function or method argument (for arguments that should default to empty
| dictionary). Will raise an error if user or spaCy attempts to add to dict.
|
| Method resolution order:
| SimpleFrozenDict
| builtins.dict
| builtins.object
|
| Methods defined here:
|
| __init__(self, *args, error: str = "[E095] Can't write to frozen dictionary. This is likely an internal error. Are you writing to a default function argument?", **kwargs) -> None
| Initialize the frozen dict. Can be initialized with pre-defined
| values.
|
| error (str): The error message when user tries to assign to dict.
|
| __setitem__(self, key, value)
| Set self[key] to value.
|
| pop(self, key, default=None)
| D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
|
| If the key is not found, return the default if given; otherwise,
| raise a KeyError.
|
| update(self, other)
| D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
| If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
| If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
| In either case, this is followed by: for k in F: D[k] = F[k]
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.dict:
|
| __contains__(self, key, /)
| True if the dictionary has the specified key, else False.
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __ior__(self, value, /)
| Return self|=value.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __or__(self, value, /)
| Return self|value.
|
| __repr__(self, /)
| Return repr(self).
|
| __reversed__(self, /)
| Return a reverse iterator over the dict keys.
|
| __ror__(self, value, /)
| Return value|self.
|
| __sizeof__(...)
| D.__sizeof__() -> size of D in memory, in bytes
|
| clear(...)
| D.clear() -> None. Remove all items from D.
|
| copy(...)
| D.copy() -> a shallow copy of D
|
| get(self, key, default=None, /)
| Return the value for key if key is in the dictionary, else default.
|
| items(...)
| D.items() -> a set-like object providing a view on D's items
|
| keys(...)
| D.keys() -> a set-like object providing a view on D's keys
|
| popitem(self, /)
| Remove and return a (key, value) pair as a 2-tuple.
|
| Pairs are returned in LIFO (last-in, first-out) order.
| Raises KeyError if the dict is empty.
|
| setdefault(self, key, default=None, /)
| Insert key with a value of default if key is not in the dictionary.
|
| Return the value for key if key is in the dictionary, else default.
|
| values(...)
| D.values() -> an object providing a view on D's values
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.dict:
|
| __class_getitem__(...)
| See PEP 585
|
| fromkeys(iterable, value=None, /)
| Create a new dictionary with keys from iterable and values set to value.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.dict:
|
| __new__(*args, **kwargs) class method of builtins.dict
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from builtins.dict:
|
| __hash__ = None
class SimpleFrozenList(builtins.list)
| SimpleFrozenList(*args, error: str = "[E927] Can't write to frozen list. Maybe you're trying to modify a computed property or default function argument?") -> None
|
| Wrapper class around a list that lets us raise custom errors if certain
| attributes/methods are accessed. Mostly used for properties like
| Language.pipeline that return an immutable list (and that we don't want to
| convert to a tuple to not break too much backwards compatibility). If a user
| accidentally calls nlp.pipeline.append(), we can raise a more helpful error.
|
| Method resolution order:
| SimpleFrozenList
| builtins.list
| builtins.object
|
| Methods defined here:
|
| __init__(self, *args, error: str = "[E927] Can't write to frozen list. Maybe you're trying to modify a computed property or default function argument?") -> None
| Initialize the frozen list.
|
| error (str): The error message when user tries to mutate the list.
|
| append(self, *args, **kwargs)
| Append object to the end of the list.
|
| clear(self, *args, **kwargs)
| Remove all items from list.
|
| extend(self, *args, **kwargs)
| Extend list by appending elements from the iterable.
|
| insert(self, *args, **kwargs)
| Insert object before index.
|
| pop(self, *args, **kwargs)
| Remove and return item at index (default last).
|
| Raises IndexError if list is empty or index is out of range.
|
| remove(self, *args, **kwargs)
| Remove first occurrence of value.
|
| Raises ValueError if the value is not present.
|
| reverse(self, *args, **kwargs)
| Reverse *IN PLACE*.
|
| sort(self, *args, **kwargs)
| Sort the list in ascending order and return None.
|
| The sort is in-place (i.e. the list itself is modified) and stable (i.e. the
| order of two equal elements is maintained).
|
| If a key function is given, apply it once to each list item and sort them,
| ascending or descending, according to their function values.
|
| The reverse flag can be set to sort in descending order.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.list:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, index, /)
| Return self[index].
|
| __gt__(self, value, /)
| Return self>value.
|
| __iadd__(self, value, /)
| Implement self+=value.
|
| __imul__(self, value, /)
| Implement self*=value.
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __repr__(self, /)
| Return repr(self).
|
| __reversed__(self, /)
| Return a reverse iterator over the list.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __setitem__(self, key, value, /)
| Set self[key] to value.
|
| __sizeof__(self, /)
| Return the size of the list in memory, in bytes.
|
| copy(self, /)
| Return a shallow copy of the list.
|
| count(self, value, /)
| Return number of occurrences of value.
|
| index(self, value, start=0, stop=9223372036854775807, /)
| Return first index of value.
|
| Raises ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Class methods inherited from builtins.list:
|
| __class_getitem__(...)
| See PEP 585
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.list:
|
| __new__(*args, **kwargs) class method of builtins.list
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from builtins.list:
|
| __hash__ = None
class registry(thinc.config.registry)
| Method resolution order:
| registry
| thinc.config.registry
| confection._registry.registry
| builtins.object
|
| Class methods defined here:
|
| ensure_populated() -> None
| Ensure the registry is populated with all necessary components.
|
| find(registry_name: str, func_name: str) -> Dict[str, Union[str, int, NoneType]]
| Find information about a registered function, including the
| module and path to the file it's defined in, the line number and the
| docstring, if available.
|
| registry_name (str): Name of the catalogue registry.
| func_name (str): Name of the registered function.
| RETURNS (Dict[str, Optional[Union[str, int]]]): The function info.
|
| get(registry_name: str, func_name: str) -> Callable
| Get a registered function from the registry.
|
| get_registry_names() -> List[str]
| List all available registries.
|
| has(registry_name: str, func_name: str) -> bool
| Check whether a function is available in a registry.
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __annotations__ = {}
|
| architectures = <catalogue.Registry object>
|
| augmenters = <catalogue.Registry object>
|
| batchers = <catalogue.Registry object>
|
| callbacks = <catalogue.Registry object>
|
| cli = <catalogue.Registry object>
|
| displacy_colors = <catalogue.Registry object>
|
| factories = <catalogue.Registry object>
|
| languages = <catalogue.Registry object>
|
| lemmatizers = <catalogue.Registry object>
|
| loggers = <catalogue.Registry object>
|
| lookups = <catalogue.Registry object>
|
| misc = <catalogue.Registry object>
|
| models = <catalogue.Registry object>
|
| readers = <catalogue.Registry object>
|
| scorers = <catalogue.Registry object>
|
| tokenizers = <catalogue.Registry object>
|
| vectors = <catalogue.Registry object>
|
| ----------------------------------------------------------------------
| Class methods inherited from thinc.config.registry:
|
| create(registry_name: str, entry_points: bool = False) -> None
| Create a new custom registry.
|
| ----------------------------------------------------------------------
| Data and other attributes inherited from thinc.config.registry:
|
| datasets = <catalogue.Registry object>
|
| initializers = <catalogue.Registry object>
|
| layers = <catalogue.Registry object>
|
| losses = <catalogue.Registry object>
|
| ops = <catalogue.Registry object>
|
| optimizers = <catalogue.Registry object>
|
| schedules = <catalogue.Registry object>
|
| ----------------------------------------------------------------------
| Class methods inherited from confection._registry.registry:
|
| fill(config: Union[confection._config.Config, Dict[str, Dict[str, Any]]], *, schema=None, overrides: Dict[str, Any] = {}, interpolate: bool = False, validate: bool = True) -> confection._config.Config
|
| get_constructor(obj: Dict[str, Any]) -> Tuple[str, str]
|
| is_promise(obj: Any) -> bool
| Check whether an object is a "promise", i.e. contains a reference
| to a registered function (via a key starting with `"@"`.
|
| parse_args(obj: Dict[str, Any]) -> Tuple[List[Any], Dict[str, Any]]
|
| resolve(config: Union[confection._config.Config, Dict[str, Dict[str, Any]]], *, schema=None, overrides: Dict[str, Any] = {}, validate: bool = True) -> Dict[str, Any]
|
| ----------------------------------------------------------------------
| Data descriptors inherited from confection._registry.registry:
|
| __dict__
| dictionary for instance variables
|
| __weakref__
| list of weak references to the object
FUNCTIONS
add_lookups(default_func: Callable[[str], Any], *lookups) -> Callable[[str], Any]
Extend an attribute function with special cases. If a word is in the
lookups, the value is returned. Otherwise the previous function is used.
default_func (callable): The default function to execute.
*lookups (dict): Lookup dictionary mapping string to attribute value.
RETURNS (callable): Lexical attribute getter.
all_equal(iterable)
Return True if all the elements are equal to each other
(or if the input is an empty sequence), False otherwise.
check_bool_env_var(env_var: str) -> bool
Convert the value of an environment variable to a boolean. Add special
check for "0" (falsy) and consider everything else truthy, except unset.
env_var (str): The name of the environment variable to check.
RETURNS (bool): Its boolean value.
check_lexeme_norms(vocab, component_name)
combine_score_weights(weights: List[Dict[str, Optional[float]]], overrides: Dict[str, Optional[float]] = {}) -> Dict[str, Optional[float]]
Combine and normalize score weights defined by components, e.g.
{"ents_r": 0.2, "ents_p": 0.3, "ents_f": 0.5} and {"some_other_score": 1.0}.
weights (List[dict]): The weights defined by the components.
overrides (Dict[str, Optional[Union[float, int]]]): Existing scores that
should be preserved.
RETURNS (Dict[str, float]): The combined and normalized weights.
compile_infix_regex(entries: Iterable[Union[str, Pattern]]) -> Pattern
Compile a sequence of infix rules into a regex object.
entries (Iterable[Union[str, Pattern]]): The infix rules, e.g.
spacy.lang.punctuation.TOKENIZER_INFIXES.
RETURNS (regex object): The regex object. to be used for Tokenizer.infix_finditer.
compile_prefix_regex(entries: Iterable[Union[str, Pattern]]) -> Pattern
Compile a sequence of prefix rules into a regex object.
entries (Iterable[Union[str, Pattern]]): The prefix rules, e.g.
spacy.lang.punctuation.TOKENIZER_PREFIXES.
RETURNS (Pattern): The regex object. to be used for Tokenizer.prefix_search.
compile_suffix_regex(entries: Iterable[Union[str, Pattern]]) -> Pattern
Compile a sequence of suffix rules into a regex object.
entries (Iterable[Union[str, Pattern]]): The suffix rules, e.g.
spacy.lang.punctuation.TOKENIZER_SUFFIXES.
RETURNS (Pattern): The regex object. to be used for Tokenizer.suffix_search.
copy_config(config: Union[Dict[str, Any], confection._config.Config]) -> confection._config.Config
Deep copy a Config. Will raise an error if the config contents are not
JSON-serializable.
config (Config): The config to copy.
RETURNS (Config): The copied config.
create_default_optimizer() -> thinc.optimizers.Optimizer
dict_to_dot(obj: Dict[str, dict], *, for_overrides: bool = False) -> Dict[str, Any]
Convert dot notation to a dict. For example: {"token": {"pos": True,
"_": {"xyz": True }}} becomes {"token.pos": True, "token._.xyz": True}.
obj (Dict[str, dict]): The dict to convert.
for_overrides (bool): Whether to enable special handling for registered
functions in overrides.
RETURNS (Dict[str, Any]): The key/value pairs.
dot_to_dict(values: Dict[str, Any]) -> Dict[str, dict]
Convert dot notation to a dict. For example: {"token.pos": True,
"token._.xyz": True} becomes {"token": {"pos": True, "_": {"xyz": True }}}.
values (Dict[str, Any]): The key/value pairs to convert.
RETURNS (Dict[str, dict]): The converted values.
dot_to_object(config: confection._config.Config, section: str)
Convert dot notation of a "section" to a specific part of the Config.
e.g. "training.optimizer" would return the Optimizer object.
Throws an error if the section is not defined in this config.
config (Config): The config.
section (str): The dot notation of the section in the config.
RETURNS: The object denoted by the section
ensure_path(path: Any) -> Any
Ensure string is converted to a Path.
path (Any): Anything. If string, it's converted to Path.
RETURNS: Path or original argument.
escape_html(text: str) -> str
Replace <, >, &, " with their HTML encoded representation. Intended to
prevent HTML errors in rendered displaCy markup.
text (str): The original text.
RETURNS (str): Equivalent text to be safely used within HTML.
expand_exc(excs: Dict[str, List[dict]], search: str, replace: str) -> Dict[str, List[dict]]
Find string in tokenizer exceptions, duplicate entry and replace string.
For example, to add additional versions with typographic apostrophes.
excs (Dict[str, List[dict]]): Tokenizer exceptions.
search (str): String to find and replace.
replace (str): Replacement.
RETURNS (Dict[str, List[dict]]): Combined tokenizer exceptions.
filter_chain_spans(*spans: Iterable[ForwardRef('Span')]) -> List[ForwardRef('Span')]
filter_spans(spans: Iterable[ForwardRef('Span')]) -> List[ForwardRef('Span')]
Filter a sequence of spans and remove duplicates or overlaps. Useful for
creating named entities (where one token can only be part of one entity) or
when merging spans with `Retokenizer.merge`. When spans overlap, the (first)
longest span is preferred over shorter spans.
spans (Iterable[Span]): The spans to filter.
RETURNS (List[Span]): The filtered spans.
find_available_port(start: int, host: str, auto_select: bool = False) -> int
Given a starting port and a host, handle finding a port.
If `auto_select` is False, a busy port will raise an error.
If `auto_select` is True, the next free higher port will be used.
start (int): the port to start looking from
host (str): the host to find a port on
auto_select (bool): whether to automatically select a new port if the given port is busy (default False)
RETURNS (int): The port to use.
find_matching_language(lang: str) -> Optional[str]
Given a two-letter ISO 639-1 or three-letter ISO 639-3 language code,
find a supported spaCy language.
Returns the language code if a matching language is available, or None
if there is no matching language.
>>> find_matching_language('fra') # ISO 639-3 code for French
'fr'
>>> find_matching_language('fre') # ISO 639-2/B code for French
'fr'
>>> find_matching_language('iw') # Obsolete ISO 639-1 code for Hebrew
'he'
>>> find_matching_language('mo') # Deprecated code for Moldavian
'ro'
>>> find_matching_language('scc') # Deprecated ISO 639-2/B code for Serbian
'sr'
>>> find_matching_language('zxx')
None
from_bytes(bytes_data: bytes, setters: Dict[str, Callable[[bytes], Any]], exclude: Iterable[str]) -> None
from_dict(msg: Dict[str, Any], setters: Dict[str, Callable[[Any], Any]], exclude: Iterable[str]) -> Dict[str, Any]
from_disk(path: Union[str, pathlib.Path], readers: Dict[str, Callable[[pathlib.Path], NoneType]], exclude: Iterable[str]) -> pathlib.Path
get_arg_names(func: Callable) -> List[str]
Get a list of all named arguments of a function (regular,
keyword-only).
func (Callable): The function
RETURNS (List[str]): The argument names.
get_async(stream, numpy_array)
get_base_version(version: str) -> str
Generate the base version without any prerelease identifiers.
version (str): The version, e.g. "3.0.0.dev1".
RETURNS (str): The base version, e.g. "3.0.0".
get_cuda_stream(require: bool = False, non_blocking: bool = True) -> NoneType
get_installed_models() -> List[str]
List all model packages currently installed in the environment.
RETURNS (List[str]): The string names of the models.
get_lang_class(lang: str) -> Type[ForwardRef('Language')]
Import and load a Language class.
lang (str): Two-letter ISO 639-1 or three-letter ISO 639-3 language code, such as 'en' and 'eng'.
RETURNS (Language): Language class.
get_minor_version(version: str) -> Optional[str]
Get the major + minor version (without patch or prerelease identifiers).
version (str): The version.
RETURNS (str): The major + minor version or None if version is invalid.
get_minor_version_range(version: str) -> str
Generate a version range like >=1.2.3,<1.3.0 based on a given version
(e.g. of spaCy).
get_model_lower_version(constraint: str) -> Optional[str]
From a version range like >=1.2.3,<1.3.0 return the lower pin.
get_model_meta(path: Union[str, pathlib.Path]) -> Dict[str, Any]
Get model meta.json from a directory path and validate its contents.
path (str / Path): Path to model directory.
RETURNS (Dict[str, Any]): The model's meta data.
get_module_path(module: module) -> pathlib.Path
Get the path of a Python module.
module (ModuleType): The Python module.
RETURNS (Path): The path.
get_object_name(obj: Any) -> str
Get a human-readable name of a Python object, e.g. a pipeline component.
obj (Any): The Python object, typically a function or class.
RETURNS (str): A human-readable name.
get_package_path(name: str) -> pathlib.Path
Get the path to an installed package.
name (str): Package name.
RETURNS (Path): Path to installed package.
get_package_version(name: str) -> Optional[str]
Get the version of an installed package. Typically used to get model
package versions.
name (str): The name of the installed Python package.
RETURNS (str / None): The version or None if package not installed.
get_sourced_components(config: Union[Dict[str, Any], confection._config.Config]) -> Dict[str, Dict[str, Any]]
RETURNS (List[str]): All sourced components in the original config,
e.g. {"source": "en_core_web_sm"}. If the config contains a key
"factory", we assume it refers to a component factory.
get_words_and_spaces(words: Iterable[str], text: str) -> Tuple[List[str], List[bool]]
Given a list of words and a text, reconstruct the original tokens and
return a list of words and spaces that can be used to create a Doc. This
can help recover destructive tokenization that didn't preserve any
whitespace information.
words (Iterable[str]): The words.
text (str): The original text.
RETURNS (Tuple[List[str], List[bool]]): The words and spaces.
ignore_error(proc_name, proc, docs, e)
import_file(name: str, loc: Union[str, pathlib.Path]) -> module
Import module from a file. Used to load models from a directory.
name (str): Name of module to load.
loc (str / Path): Path to the file.
RETURNS: The loaded module.
is_compatible_version(version: str, constraint: str, prereleases: bool = True) -> Optional[bool]
Check if a version (e.g. "2.0.0") is compatible given a version
constraint (e.g. ">=1.9.0,<2.2.1"). If the constraint is a specific version,
it's interpreted as =={version}.
version (str): The version to check.
constraint (str): The constraint string.
prereleases (bool): Whether to allow prereleases. If set to False,
prerelease versions will be considered incompatible.
RETURNS (bool / None): Whether the version is compatible, or None if the
version or constraint are invalid.
is_cython_func(func: Callable) -> bool
Slightly hacky check for whether a callable is implemented in Cython.
Can be used to implement slightly different behaviors, especially around
inspecting and parameter annotations. Note that this will only return True
for actual cdef functions and methods, not regular Python functions defined
in Python modules.
func (Callable): The callable to check.
RETURNS (bool): Whether the callable is Cython (probably).
is_in_interactive() -> bool
Check if user is running spaCy from an interactive Python
shell. Will return True in Jupyter notebooks too.
RETURNS (bool): True if in interactive mode, False if not.
is_in_jupyter() -> bool
Check if user is running spaCy from a Jupyter or Colab notebook by
detecting the IPython kernel. Mainly used for the displaCy visualizer.
RETURNS (bool): True if in Jupyter/Colab, False if not.
is_minor_version_match(version_a: str, version_b: str) -> bool
Compare two versions and check if they match in major and minor, without
patch or prerelease identifiers. Used internally for compatibility checks
that should be insensitive to patch releases.
version_a (str): The first version
version_b (str): The second version.
RETURNS (bool): Whether the versions match.
is_package(name: str) -> bool
Check if string maps to a package installed via pip.
name (str): Name of package.
RETURNS (bool): True if installed package, False if not.
is_prerelease_version(version: str) -> bool
Check whether a version is a prerelease version.
version (str): The version, e.g. "3.0.0.dev1".
RETURNS (bool): Whether the version is a prerelease version.
is_same_func(func1: Callable, func2: Callable) -> bool
Approximately decide whether two functions are the same, even if their
identity is different (e.g. after they have been live reloaded). Mostly
used in the @Language.component and @Language.factory decorators to decide
whether to raise if a factory already exists. Allows decorator to run
multiple times with the same function.
func1 (Callable): The first function.
func2 (Callable): The second function.
RETURNS (bool): Whether it's the same function (most likely).
is_unconstrained_version(constraint: str, prereleases: bool = True) -> Optional[bool]
lang_class_is_loaded(lang: str) -> bool
Check whether a Language class is already loaded. Language classes are
loaded lazily, to avoid expensive setup code associated with the language
data.
lang (str): Two-letter language code, e.g. 'en'.
RETURNS (bool): Whether a Language class has been loaded.
load_config(path: Union[str, pathlib.Path], overrides: Dict[str, Any] = {}, interpolate: bool = False) -> confection._config.Config
Load a config file. Takes care of path validation and section order.
path (Union[str, Path]): Path to the config file or "-" to read from stdin.
overrides: (Dict[str, Any]): Config overrides as nested dict or
dict keyed by section values in dot notation.
interpolate (bool): Whether to interpolate and resolve variables.
RETURNS (Config): The loaded config.
load_config_from_str(text: str, overrides: Dict[str, Any] = {}, interpolate: bool = False)
Load a full config from a string. Wrapper around Thinc's Config.from_str.
text (str): The string config to load.
interpolate (bool): Whether to interpolate and resolve variables.
RETURNS (Config): The loaded config.
load_language_data(path: Union[str, pathlib.Path]) -> Union[dict, list]
Load JSON language data using the given path as a base. If the provided
path isn't present, will attempt to load a gzipped version before giving up.
path (str / Path): The data to load.
RETURNS: The loaded data.
load_meta(path: Union[str, pathlib.Path]) -> Dict[str, Any]
Load a model meta.json from a path and validate its contents.
path (Union[str, Path]): Path to meta.json.
RETURNS (Dict[str, Any]): The loaded meta.
load_model(name: Union[str, pathlib.Path], *, vocab: Union[ForwardRef('Vocab'), bool] = True, disable: Union[str, Iterable[str]] = [], enable: Union[str, Iterable[str]] = [], exclude: Union[str, Iterable[str]] = [], config: Union[Dict[str, Any], confection._config.Config] = {}) -> 'Language'
Load a model from a package or data path.
name (str): Package name or model path.
vocab (Vocab / True): Optional vocab to pass in on initialization. If True,
a new Vocab object will be created.
disable (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to disable.
enable (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to enable. All others will be disabled.
exclude (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to exclude.
config (Dict[str, Any] / Config): Config overrides as nested dict or dict
keyed by section values in dot notation.
RETURNS (Language): The loaded nlp object.
load_model_from_config(config: Union[Dict[str, Any], confection._config.Config], *, meta: Dict[str, Any] = {}, vocab: Union[ForwardRef('Vocab'), bool] = True, disable: Union[str, Iterable[str]] = [], enable: Union[str, Iterable[str]] = [], exclude: Union[str, Iterable[str]] = [], auto_fill: bool = False, validate: bool = True) -> 'Language'
Create an nlp object from a config. Expects the full config file including
a section "nlp" containing the settings for the nlp object.
name (str): Package name or model path.
meta (Dict[str, Any]): Optional model meta.
vocab (Vocab / True): Optional vocab to pass in on initialization. If True,
a new Vocab object will be created.
disable (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to disable. Disabled
pipes will be loaded but they won't be run unless you explicitly
enable them by calling nlp.enable_pipe.
enable (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to enable. All other
pipes will be disabled (and can be enabled using `nlp.enable_pipe`).
exclude (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to exclude. Excluded
components won't be loaded.
auto_fill (bool): Whether to auto-fill config with missing defaults.
validate (bool): Whether to show config validation errors.
RETURNS (Language): The loaded nlp object.
load_model_from_init_py(init_file: Union[pathlib.Path, str], *, vocab: Union[ForwardRef('Vocab'), bool] = True, disable: Union[str, Iterable[str]] = [], enable: Union[str, Iterable[str]] = [], exclude: Union[str, Iterable[str]] = [], config: Union[Dict[str, Any], confection._config.Config] = {}) -> 'Language'
Helper function to use in the `load()` method of a model package's
__init__.py.
vocab (Vocab / True): Optional vocab to pass in on initialization. If True,
a new Vocab object will be created.
disable (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to disable. Disabled
pipes will be loaded but they won't be run unless you explicitly
enable them by calling nlp.enable_pipe.
enable (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to enable. All other
pipes will be disabled (and can be enabled using `nlp.enable_pipe`).
exclude (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to exclude. Excluded
components won't be loaded.
config (Dict[str, Any] / Config): Config overrides as nested dict or dict
keyed by section values in dot notation.
RETURNS (Language): The loaded nlp object.
load_model_from_package(name: str, *, vocab: Union[ForwardRef('Vocab'), bool] = True, disable: Union[str, Iterable[str]] = [], enable: Union[str, Iterable[str]] = [], exclude: Union[str, Iterable[str]] = [], config: Union[Dict[str, Any], confection._config.Config] = {}) -> 'Language'
Load a model from an installed package.
name (str): The package name.
vocab (Vocab / True): Optional vocab to pass in on initialization. If True,
a new Vocab object will be created.
disable (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to disable. Disabled
pipes will be loaded but they won't be run unless you explicitly
enable them by calling nlp.enable_pipe.
enable (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to enable. All other
pipes will be disabled (and can be enabled using `nlp.enable_pipe`).
exclude (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to exclude. Excluded
components won't be loaded.
config (Dict[str, Any] / Config): Config overrides as nested dict or dict
keyed by section values in dot notation.
RETURNS (Language): The loaded nlp object.
load_model_from_path(model_path: pathlib.Path, *, meta: Optional[Dict[str, Any]] = None, vocab: Union[ForwardRef('Vocab'), bool] = True, disable: Union[str, Iterable[str]] = [], enable: Union[str, Iterable[str]] = [], exclude: Union[str, Iterable[str]] = [], config: Union[Dict[str, Any], confection._config.Config] = {}) -> 'Language'
Load a model from a data directory path. Creates Language class with
pipeline from config.cfg and then calls from_disk() with path.
model_path (Path): Model path.
meta (Dict[str, Any]): Optional model meta.
vocab (Vocab / True): Optional vocab to pass in on initialization. If True,
a new Vocab object will be created.
disable (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to disable. Disabled
pipes will be loaded but they won't be run unless you explicitly
enable them by calling nlp.enable_pipe.
enable (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to enable. All other
pipes will be disabled (and can be enabled using `nlp.enable_pipe`).
exclude (Union[str, Iterable[str]]): Name(s) of pipeline component(s) to exclude. Excluded
components won't be loaded.
config (Dict[str, Any] / Config): Config overrides as nested dict or dict
keyed by section values in dot notation.
RETURNS (Language): The loaded nlp object.
make_first_longest_spans_filter()
make_tempdir() -> Generator[pathlib.Path, NoneType, NoneType]
Execute a block in a temporary directory and remove the directory and
its contents at the end of the with block.
YIELDS (Path): The path of the temp directory.
minibatch(items, size)
Iterate over batches of items. `size` may be an iterator,
so that batch-size can vary on each step.
minify_html(html: str) -> str
Perform a template-specific, rudimentary HTML minification for displaCy.
Disclaimer: NOT a general-purpose solution, only removes indentation and
newlines.
html (str): Markup to minify.
RETURNS (str): "Minified" HTML.
normalize_slice(length: int, start: int, stop: int, step: Optional[int] = None) -> Tuple[int, int]
packages_distributions() -> Dict[str, List[str]]
Return a mapping of top-level packages to their distributions. We're
inlining this helper from the importlib_metadata "backport" here, since
it's not available in the builtin importlib.metadata.
raise_error(proc_name, proc, docs, e)
read_regex(path: Union[str, pathlib.Path]) -> Pattern
replace_model_node(model: thinc.model.Model, target: thinc.model.Model, replacement: thinc.model.Model) -> None
Replace a node within a model with a new one, updating refs.
model (Model): The parent model.
target (Model): The target node.
replacement (Model): The node to replace the target with.
resolve_dot_names(config: confection._config.Config, dot_names: List[Optional[str]]) -> Tuple[Any, ...]
Resolve one or more "dot notation" names, e.g. corpora.train.
The paths could point anywhere into the config, so we don't know which
top-level section we'll be looking within.
We resolve the whole top-level section, although we could resolve less --
we could find the lowest part of the tree.
run_command(command: Union[str, List[str]], *, stdin: Optional[Any] = None, capture: bool = False) -> subprocess.CompletedProcess
Run a command on the command line as a subprocess. If the subprocess
returns a non-zero exit code, a system exit is performed.
command (str / List[str]): The command. If provided as a string, the
string will be split using shlex.split.
stdin (Optional[Any]): stdin to read from or None.
capture (bool): Whether to capture the output and errors. If False,
the stdout and stderr will not be redirected, and if there's an error,
sys.exit will be called with the return code. You should use capture=False
when you want to turn over execution to the command, and capture=True
when you want to run the command more like a function.
RETURNS (Optional[CompletedProcess]): The process object.
set_dot_to_object(config: confection._config.Config, section: str, value: Any) -> None
Update a config at a given position from a dot notation.
config (Config): The config.
section (str): The dot notation of the section in the config.
value (Any): The value to set in the config.
set_lang_class(name: str, cls: Type[ForwardRef('Language')]) -> None
Set a custom Language class name that can be loaded via get_lang_class.
name (str): Name of Language class.
cls (Language): Language class.
split_command(command: str) -> List[str]
Split a string command using shlex. Handles platform compatibility.
command (str) : The command to split
RETURNS (List[str]): The split command.
split_requirement(requirement: str) -> Tuple[str, str]
Split a requirement like spacy>=1.2.3 into ("spacy", ">=1.2.3").
to_bytes(getters: Dict[str, Callable[[], bytes]], exclude: Iterable[str]) -> bytes
to_dict(getters: Dict[str, Callable[[], Any]], exclude: Iterable[str]) -> Dict[str, Any]
to_disk(path: Union[str, pathlib.Path], writers: Dict[str, Callable[[pathlib.Path], NoneType]], exclude: Iterable[str]) -> pathlib.Path
to_ternary_int(val) -> int
Convert a value to the ternary 1/0/-1 int used for True/None/False in
attributes such as SENT_START: True/1/1.0 is 1 (True), None/0/0.0 is 0
(None), any other values are -1 (False).
update_exc(base_exceptions: Dict[str, List[dict]], *addition_dicts) -> Dict[str, List[dict]]
Update and validate tokenizer exceptions. Will overwrite exceptions.
base_exceptions (Dict[str, List[dict]]): Base exceptions.
*addition_dicts (Dict[str, List[dict]]): Exceptions to add to the base dict, in order.
RETURNS (Dict[str, List[dict]]): Combined tokenizer exceptions.
walk_dict(node: Dict[str, Any], parent: List[str] = [], *, for_overrides: bool = False) -> Iterator[Tuple[List[str], Any]]
Walk a dict and yield the path and values of the leaves.
for_overrides (bool): Whether to treat registered functions that start with
@ as final values rather than dicts to traverse.
warn_if_jupyter_cupy()
Warn about require_gpu if a jupyter notebook + cupy + mismatched
contextvars vs. thread ops are detected
working_dir(path: Union[str, pathlib.Path]) -> Iterator[pathlib.Path]
Change current working directory and returns to previous on exit.
path (str / Path): The directory to navigate to.
YIELDS (Path): The absolute path to the current working directory. This
should be used if the block needs to perform actions within the working
directory, to prevent mismatches with relative paths.
DATA
CONFIG_SECTION_ORDER = ['paths', 'variables', 'system', 'nlp', 'compon...
Callable = typing.Callable
Deprecated alias to collections.abc.Callable.
Callable[[int], str] signifies a function that takes a single
parameter of type int and returns a str.
The subscription syntax must always be used with exactly two
values: the argument list and the return type.
The argument list must be a list of types, a ParamSpec,
Concatenate or ellipsis. The return type must be a single type.
There is no syntax to indicate optional or keyword arguments;
such function types are rarely used as callback types.
CudaStream = None
DEFAULT_OOV_PROB = -20
Dict = typing.Dict
A generic version of dict.
Generator = typing.Generator
A generic version of collections.abc.Generator.
Iterable = typing.Iterable
A generic version of collections.abc.Iterable.
Iterator = typing.Iterator
A generic version of collections.abc.Iterator.
LANG_ALIASES = {'af': ['afr'], 'am': ['amh'], 'ar': ['ara'], 'az': ['a...
LEXEME_NORM_LANGS = ['cs', 'da', 'de', 'el', 'en', 'grc', 'id', 'lb', ...
List = typing.List
A generic version of list.
Mapping = typing.Mapping
A generic version of collections.abc.Mapping.
NoReturn = typing.NoReturn
Special type indicating functions that never return.
Example::
from typing import NoReturn
def stop() -> NoReturn:
raise Exception('no way')
NoReturn can also be used as a bottom type, a type that
has no values. Starting in Python 3.11, the Never type should
be used for this concept instead. Type checkers should treat the two
equivalently.
OLD_MODEL_SHORTCUTS = {'de': 'de_core_news_sm', 'el': 'el_core_news_sm...
OOV_RANK = 18446744073709551615
ORTH = 65
Optional = typing.Optional
Optional[X] is equivalent to Union[X, None].
Pattern = typing.Pattern
A generic version of re.Pattern.
Set = typing.Set
A generic version of set.
TYPE_CHECKING = False
Tuple = typing.Tuple
Deprecated alias to builtins.tuple.
Tuple[X, Y] is the cross-product type of X and Y.
Example: Tuple[T1, T2] is a tuple of two elements corresponding
to type variables T1 and T2. Tuple[int, float, str] is a tuple
of an int, a float and a string.
To specify a variable-length tuple of homogeneous type, use Tuple[T, ...].
Type = typing.Type
Deprecated alias to builtins.type.
builtins.type or typing.Type can be used to annotate class objects.
For example, suppose we have the following classes::
class User: ... # Abstract base for User classes
class BasicUser(User): ...
class ProUser(User): ...
class TeamUser(User): ...
And a function that takes a class argument that's a subclass of
User and returns an instance of the corresponding class::
def new_user[U](user_class: Type[U]) -> U:
user = user_class()
# (Here we could write the user object to a database)
return user
joe = new_user(BasicUser)
At this point the type checker knows that joe has type BasicUser.
Union = typing.Union
Union type; Union[X, Y] means either X or Y.
On Python 3.10 and higher, the | operator
can also be used to denote unions;
X | Y means the same thing to the type checker as Union[X, Y].
To define a union, use e.g. Union[int, str]. Details:
- The arguments must be types and there must be at least one.
- None as an argument is a special case and is replaced by
type(None).
- Unions of unions are flattened, e.g.::
assert Union[Union[int, str], float] == Union[int, str, float]
- Unions of a single argument vanish, e.g.::
assert Union[int] == int # The constructor actually returns int
- Redundant arguments are skipped, e.g.::
assert Union[int, str, int] == Union[int, str]
- When comparing unions, the argument order is ignored, e.g.::
assert Union[int, str] == Union[str, int]
- You cannot subclass or instantiate a union.
- You can use Optional[X] as a shorthand for Union[X, None].
cupy = None
is_windows = True
logger = <Logger spacy (WARNING)>
logger_stream_handler = <StreamHandler <stderr> (NOTSET)>
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\util.py
spacy.vectors
Python Library Documentation: module spacy.vectors in spacy
NAME
spacy.vectors
CLASSES
builtins.object
BaseVectors
Vectors
builtins.str(builtins.object)
Mode(builtins.str, enum.Enum)
enum.Enum(builtins.object)
Mode(builtins.str, enum.Enum)
class BaseVectors(builtins.object)
| BaseVectors(strings=None, *)
|
| Methods defined here:
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __init__(self, /, *args, **kwargs)
| Initialize self. See help(type(self)) for accurate signature.
|
| __len__(self, /)
| Return len(self).
|
| __reduce__ = __reduce_cython__(...)
| BaseVectors.__reduce_cython__(self)
|
| __reduce_cython__(self)
| BaseVectors.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| BaseVectors.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| BaseVectors.__setstate_cython__(self, __pyx_state)
|
| add(self, key, *, vector=None)
| BaseVectors.add(self, key, *, vector=None)
|
| from_bytes(self, data: 'bytes', **kwargs)
| BaseVectors.from_bytes(self, data: bytes, **kwargs)
|
| from_disk(self, path: 'Union[str, Path]', **kwargs)
| BaseVectors.from_disk(self, path: Union[str, Path], **kwargs)
|
| get_batch(self, keys)
| BaseVectors.get_batch(self, keys)
|
| is_full(self)
| BaseVectors.is_full(self)
|
| to_bytes(self, **kwargs)
| BaseVectors.to_bytes(self, **kwargs)
|
| to_disk(self, path: 'Union[str, Path]', **kwargs)
| BaseVectors.to_disk(self, path: Union[str, Path], **kwargs)
|
| to_ops(self, ops: 'Ops')
| BaseVectors.to_ops(self, ops: Ops)
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| shape
|
| size
|
| vectors_length
class Mode(builtins.str, enum.Enum)
| Mode(*values)
|
| Method resolution order:
| Mode
| builtins.str
| enum.Enum
| builtins.object
|
| Methods defined here:
|
| __format__(self, format_spec) from enum.Enum
| Default object formatter.
|
| Return str(self) if format_spec is empty. Raise TypeError otherwise.
|
| __new__(cls, value) from enum.Enum
| Create and return a new object. See help(type) for accurate signature.
|
| __repr__(self) from enum.Enum
| Return repr(self).
|
| __str__(self) from enum.Enum
| Return str(self).
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| default = <Mode.default: 'default'>
|
| floret = <Mode.floret: 'floret'>
|
| ----------------------------------------------------------------------
| Methods inherited from builtins.str:
|
| __add__(self, value, /)
| Return self+value.
|
| __contains__(self, key, /)
| Return bool(key in self).
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getitem__(self, key, /)
| Return self[key].
|
| __getnewargs__(...)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __mod__(self, value, /)
| Return self%value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __rmod__(self, value, /)
| Return value%self.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __sizeof__(self, /)
| Return the size of the string in memory, in bytes.
|
| capitalize(self, /)
| Return a capitalized version of the string.
|
| More specifically, make the first character have upper case and the rest lower
| case.
|
| casefold(self, /)
| Return a version of the string suitable for caseless comparisons.
|
| center(self, width, fillchar=' ', /)
| Return a centered string of length width.
|
| Padding is done using the specified fill character (default is a space).
|
| count(...)
| S.count(sub[, start[, end]]) -> int
|
| Return the number of non-overlapping occurrences of substring sub in
| string S[start:end]. Optional arguments start and end are
| interpreted as in slice notation.
|
| encode(self, /, encoding='utf-8', errors='strict')
| Encode the string using the codec registered for encoding.
|
| encoding
| The encoding in which to encode the string.
| errors
| The error handling scheme to use for encoding errors.
| The default is 'strict' meaning that encoding errors raise a
| UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
| 'xmlcharrefreplace' as well as any other name registered with
| codecs.register_error that can handle UnicodeEncodeErrors.
|
| endswith(...)
| S.endswith(suffix[, start[, end]]) -> bool
|
| Return True if S ends with the specified suffix, False otherwise.
| With optional start, test S beginning at that position.
| With optional end, stop comparing S at that position.
| suffix can also be a tuple of strings to try.
|
| expandtabs(self, /, tabsize=8)
| Return a copy where all tab characters are expanded using spaces.
|
| If tabsize is not given, a tab size of 8 characters is assumed.
|
| find(...)
| S.find(sub[, start[, end]]) -> int
|
| Return the lowest index in S where substring sub is found,
| such that sub is contained within S[start:end]. Optional
| arguments start and end are interpreted as in slice notation.
|
| Return -1 on failure.
|
| format(...)
| S.format(*args, **kwargs) -> str
|
| Return a formatted version of S, using substitutions from args and kwargs.
| The substitutions are identified by braces ('{' and '}').
|
| format_map(...)
| S.format_map(mapping) -> str
|
| Return a formatted version of S, using substitutions from mapping.
| The substitutions are identified by braces ('{' and '}').
|
| index(...)
| S.index(sub[, start[, end]]) -> int
|
| Return the lowest index in S where substring sub is found,
| such that sub is contained within S[start:end]. Optional
| arguments start and end are interpreted as in slice notation.
|
| Raises ValueError when the substring is not found.
|
| isalnum(self, /)
| Return True if the string is an alpha-numeric string, False otherwise.
|
| A string is alpha-numeric if all characters in the string are alpha-numeric and
| there is at least one character in the string.
|
| isalpha(self, /)
| Return True if the string is an alphabetic string, False otherwise.
|
| A string is alphabetic if all characters in the string are alphabetic and there
| is at least one character in the string.
|
| isascii(self, /)
| Return True if all characters in the string are ASCII, False otherwise.
|
| ASCII characters have code points in the range U+0000-U+007F.
| Empty string is ASCII too.
|
| isdecimal(self, /)
| Return True if the string is a decimal string, False otherwise.
|
| A string is a decimal string if all characters in the string are decimal and
| there is at least one character in the string.
|
| isdigit(self, /)
| Return True if the string is a digit string, False otherwise.
|
| A string is a digit string if all characters in the string are digits and there
| is at least one character in the string.
|
| isidentifier(self, /)
| Return True if the string is a valid Python identifier, False otherwise.
|
| Call keyword.iskeyword(s) to test whether string s is a reserved identifier,
| such as "def" or "class".
|
| islower(self, /)
| Return True if the string is a lowercase string, False otherwise.
|
| A string is lowercase if all cased characters in the string are lowercase and
| there is at least one cased character in the string.
|
| isnumeric(self, /)
| Return True if the string is a numeric string, False otherwise.
|
| A string is numeric if all characters in the string are numeric and there is at
| least one character in the string.
|
| isprintable(self, /)
| Return True if the string is printable, False otherwise.
|
| A string is printable if all of its characters are considered printable in
| repr() or if it is empty.
|
| isspace(self, /)
| Return True if the string is a whitespace string, False otherwise.
|
| A string is whitespace if all characters in the string are whitespace and there
| is at least one character in the string.
|
| istitle(self, /)
| Return True if the string is a title-cased string, False otherwise.
|
| In a title-cased string, upper- and title-case characters may only
| follow uncased characters and lowercase characters only cased ones.
|
| isupper(self, /)
| Return True if the string is an uppercase string, False otherwise.
|
| A string is uppercase if all cased characters in the string are uppercase and
| there is at least one cased character in the string.
|
| join(self, iterable, /)
| Concatenate any number of strings.
|
| The string whose method is called is inserted in between each given string.
| The result is returned as a new string.
|
| Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'
|
| ljust(self, width, fillchar=' ', /)
| Return a left-justified string of length width.
|
| Padding is done using the specified fill character (default is a space).
|
| lower(self, /)
| Return a copy of the string converted to lowercase.
|
| lstrip(self, chars=None, /)
| Return a copy of the string with leading whitespace removed.
|
| If chars is given and not None, remove characters in chars instead.
|
| partition(self, sep, /)
| Partition the string into three parts using the given separator.
|
| This will search for the separator in the string. If the separator is found,
| returns a 3-tuple containing the part before the separator, the separator
| itself, and the part after it.
|
| If the separator is not found, returns a 3-tuple containing the original string
| and two empty strings.
|
| removeprefix(self, prefix, /)
| Return a str with the given prefix string removed if present.
|
| If the string starts with the prefix string, return string[len(prefix):].
| Otherwise, return a copy of the original string.
|
| removesuffix(self, suffix, /)
| Return a str with the given suffix string removed if present.
|
| If the string ends with the suffix string and that suffix is not empty,
| return string[:-len(suffix)]. Otherwise, return a copy of the original
| string.
|
| replace(self, old, new, count=-1, /)
| Return a copy with all occurrences of substring old replaced by new.
|
| count
| Maximum number of occurrences to replace.
| -1 (the default value) means replace all occurrences.
|
| If the optional argument count is given, only the first count occurrences are
| replaced.
|
| rfind(...)
| S.rfind(sub[, start[, end]]) -> int
|
| Return the highest index in S where substring sub is found,
| such that sub is contained within S[start:end]. Optional
| arguments start and end are interpreted as in slice notation.
|
| Return -1 on failure.
|
| rindex(...)
| S.rindex(sub[, start[, end]]) -> int
|
| Return the highest index in S where substring sub is found,
| such that sub is contained within S[start:end]. Optional
| arguments start and end are interpreted as in slice notation.
|
| Raises ValueError when the substring is not found.
|
| rjust(self, width, fillchar=' ', /)
| Return a right-justified string of length width.
|
| Padding is done using the specified fill character (default is a space).
|
| rpartition(self, sep, /)
| Partition the string into three parts using the given separator.
|
| This will search for the separator in the string, starting at the end. If
| the separator is found, returns a 3-tuple containing the part before the
| separator, the separator itself, and the part after it.
|
| If the separator is not found, returns a 3-tuple containing two empty strings
| and the original string.
|
| rsplit(self, /, sep=None, maxsplit=-1)
| Return a list of the substrings in the string, using sep as the separator string.
|
| sep
| The separator used to split the string.
|
| When set to None (the default value), will split on any whitespace
| character (including \n \r \t \f and spaces) and will discard
| empty strings from the result.
| maxsplit
| Maximum number of splits.
| -1 (the default value) means no limit.
|
| Splitting starts at the end of the string and works to the front.
|
| rstrip(self, chars=None, /)
| Return a copy of the string with trailing whitespace removed.
|
| If chars is given and not None, remove characters in chars instead.
|
| split(self, /, sep=None, maxsplit=-1)
| Return a list of the substrings in the string, using sep as the separator string.
|
| sep
| The separator used to split the string.
|
| When set to None (the default value), will split on any whitespace
| character (including \n \r \t \f and spaces) and will discard
| empty strings from the result.
| maxsplit
| Maximum number of splits.
| -1 (the default value) means no limit.
|
| Splitting starts at the front of the string and works to the end.
|
| Note, str.split() is mainly useful for data that has been intentionally
| delimited. With natural text that includes punctuation, consider using
| the regular expression module.
|
| splitlines(self, /, keepends=False)
| Return a list of the lines in the string, breaking at line boundaries.
|
| Line breaks are not included in the resulting list unless keepends is given and
| true.
|
| startswith(...)
| S.startswith(prefix[, start[, end]]) -> bool
|
| Return True if S starts with the specified prefix, False otherwise.
| With optional start, test S beginning at that position.
| With optional end, stop comparing S at that position.
| prefix can also be a tuple of strings to try.
|
| strip(self, chars=None, /)
| Return a copy of the string with leading and trailing whitespace removed.
|
| If chars is given and not None, remove characters in chars instead.
|
| swapcase(self, /)
| Convert uppercase characters to lowercase and lowercase characters to uppercase.
|
| title(self, /)
| Return a version of the string where each word is titlecased.
|
| More specifically, words start with uppercased characters and all remaining
| cased characters have lower case.
|
| translate(self, table, /)
| Replace each character in the string using the given translation table.
|
| table
| Translation table, which must be a mapping of Unicode ordinals to
| Unicode ordinals, strings, or None.
|
| The table must implement lookup/indexing via __getitem__, for instance a
| dictionary or list. If this operation raises LookupError, the character is
| left untouched. Characters mapped to None are deleted.
|
| upper(self, /)
| Return a copy of the string converted to uppercase.
|
| zfill(self, width, /)
| Pad a numeric string with zeros on the left, to fill a field of the given width.
|
| The string is never truncated.
|
| ----------------------------------------------------------------------
| Static methods inherited from builtins.str:
|
| maketrans(...)
| Return a translation table usable for str.translate().
|
| If there is only one argument, it must be a dictionary mapping Unicode
| ordinals (integers) or characters to Unicode ordinals, strings or None.
| Character keys will be then converted to ordinals.
| If there are two arguments, they must be strings of equal length, and
| in the resulting dictionary, each character in x will be mapped to the
| character at the same position in y. If there is a third argument, it
| must be a string, whose characters will be mapped to None in the result.
|
| ----------------------------------------------------------------------
| Methods inherited from enum.Enum:
|
| __dir__(self)
| Returns public methods and other interesting attributes.
|
| __init__(self, *args, **kwds)
| Initialize self. See help(type(self)) for accurate signature.
|
| __reduce_ex__(self, proto)
| Helper for pickle.
|
| ----------------------------------------------------------------------
| Data descriptors inherited from enum.Enum:
|
| name
| The name of the Enum member.
|
| value
| The value of the Enum member.
|
| ----------------------------------------------------------------------
| Readonly properties inherited from enum.EnumType:
|
| __members__
| Returns a mapping of member name->value.
|
| This mapping lists all enum members, including aliases. Note that this
| is a read-only view of the internal mapping.
class Vectors(BaseVectors)
| Vectors(strings=None, *, shape=None, data=None, keys=None, name=None, mode=Mode.default, minn=0, maxn=0, hash_count=1, hash_seed=0, bow='<', eow='>', attr='ORTH')
|
| Store, save and load word vectors.
|
| Vectors data is kept in the vectors.data attribute, which should be an
| instance of numpy.ndarray (for CPU vectors) or cupy.ndarray
| (for GPU vectors).
|
| In the default mode, `vectors.key2row` is a dictionary mapping word hashes
| to rows in the vectors.data table. Multiple keys can be mapped to the same
| vector, and not all of the rows in the table need to be assigned - so
| len(list(vectors.keys())) may be greater or smaller than vectors.shape[0].
|
| In floret mode, the floret settings (minn, maxn, etc.) are used to
| calculate the vector from the rows corresponding to the key's ngrams.
|
| DOCS: https://spacy.io/api/vectors
|
| Method resolution order:
| Vectors
| BaseVectors
| builtins.object
|
| Methods defined here:
|
| __contains__(...)
| Vectors.__contains__(self, key)
|
| Check whether a key has been mapped to a vector entry in the table.
|
| key (int): The key to check.
| RETURNS (bool): Whether the key has a vector entry.
|
| DOCS: https://spacy.io/api/vectors#contains
|
| __delitem__(self, key, /)
| Delete self[key].
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getitem__(...)
| Vectors.__getitem__(self, key)
|
| Get a vector by key. If the key is not found, a KeyError is raised.
|
| key (str/int): The key to get the vector for.
| RETURNS (ndarray): The vector for the key.
|
| DOCS: https://spacy.io/api/vectors#getitem
|
| __gt__(self, value, /)
| Return self>value.
|
| __init__(...)
| Create a new vector store.
|
| strings (StringStore): The string store.
| shape (tuple): Size of the table, as (# entries, # columns)
| data (numpy.ndarray or cupy.ndarray): The vector data.
| keys (iterable): A sequence of keys, aligned with the data.
| name (str): A name to identify the vectors table.
| mode (str): Vectors mode: "default" or "floret" (default: "default").
| minn (int): The floret char ngram minn (default: 0).
| maxn (int): The floret char ngram maxn (default: 0).
| hash_count (int): The floret hash count (1-4, default: 1).
| hash_seed (int): The floret hash seed (default: 0).
| bow (str): The floret BOW string (default: "<").
| eow (str): The floret EOW string (default: ">").
| attr (Union[int, str]): The token attribute for the vector keys
| (default: "ORTH").
|
| DOCS: https://spacy.io/api/vectors#init
|
| __iter__(...)
| Vectors.__iter__(self)
|
| Iterate over the keys in the table.
|
| YIELDS (int): A key in the table.
|
| DOCS: https://spacy.io/api/vectors#iter
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(...)
| Vectors.__len__(self)
|
| Return the number of vectors in the table.
|
| RETURNS (int): The number of vectors in the data.
|
| DOCS: https://spacy.io/api/vectors#len
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __reduce__(self)
| Vectors.__reduce__(self)
|
| __setitem__(...)
| Vectors.__setitem__(self, key, vector)
|
| Set a vector for the given key.
|
| key (str/int): The key to set the vector for.
| vector (ndarray): The vector to set.
|
| DOCS: https://spacy.io/api/vectors#setitem
|
| add(self, key, *, vector=None, row=None)
| Vectors.add(self, key, *, vector=None, row=None)
|
| Add a key to the table. Keys can be mapped to an existing vector
| by setting `row`, or a new vector can be added.
|
| key (int): The key to add.
| vector (ndarray / None): A vector to add for the key.
| row (int / None): The row number of a vector to map the key to.
| RETURNS (int): The row the vector was added to.
|
| DOCS: https://spacy.io/api/vectors#add
|
| clear(self)
| Vectors.clear(self)
|
| Clear all entries in the vector table.
|
| DOCS: https://spacy.io/api/vectors#clear
|
| find(self, *, key=None, keys=None, row=None, rows=None)
| Vectors.find(self, *, key=None, keys=None, row=None, rows=None)
|
| Look up one or more keys by row, or vice versa.
|
| key (Union[int, str]): Find the row that the given key points to.
| Returns int, -1 if missing.
| keys (Iterable[Union[int, str]]): Find rows that the keys point to.
| Returns ndarray.
| row (int): Find the first key that points to the row.
| Returns int.
| rows (Iterable[int]): Find the keys that point to the rows.
| Returns ndarray.
| RETURNS: The requested key, keys, row or rows.
|
| from_bytes(self, data, *, exclude=())
| Vectors.from_bytes(self, data, *, exclude=tuple())
|
| Load state from a binary string.
|
| data (bytes): The data to load from.
| exclude (list): String names of serialization fields to exclude.
| RETURNS (Vectors): The `Vectors` object.
|
| DOCS: https://spacy.io/api/vectors#from_bytes
|
| from_disk(self, path, *, exclude=())
| Vectors.from_disk(self, path, *, exclude=tuple())
|
| Loads state from a directory. Modifies the object in place and
| returns it.
|
| path (str / Path): Directory path, string or Path-like object.
| RETURNS (Vectors): The modified object.
|
| DOCS: https://spacy.io/api/vectors#from_disk
|
| get_batch(self, keys)
| Vectors.get_batch(self, keys)
|
| Get the vectors for the provided keys efficiently as a batch.
| keys (Iterable[Union[int, str]]): The keys.
| RETURNS: The requested vectors from the vector table.
|
| items(self)
| Vectors.items(self)
|
| Iterate over `(key, vector)` pairs.
|
| YIELDS (tuple): A key/vector pair.
|
| DOCS: https://spacy.io/api/vectors#items
|
| keys(self)
| Vectors.keys(self)
|
| RETURNS (iterable): A sequence of keys in the table.
|
| most_similar(self, queries, *, batch_size=1024, n=1, sort=True)
| Vectors.most_similar(self, queries, *, batch_size=1024, n=1, sort=True)
|
| For each of the given vectors, find the n most similar entries
| to it, by cosine.
|
| Queries are by vector. Results are returned as a `(keys, best_rows,
| scores)` tuple. If `queries` is large, the calculations are performed in
| chunks, to avoid consuming too much memory. You can set the `batch_size`
| to control the size/space trade-off during the calculations.
|
| queries (ndarray): An array with one or more vectors.
| batch_size (int): The batch size to use.
| n (int): The number of entries to return for each query.
| sort (bool): Whether to sort the n entries returned by score.
| RETURNS (tuple): The most similar entries as a `(keys, best_rows, scores)`
| tuple.
|
| resize(self, shape, inplace=False)
| Vectors.resize(self, shape, inplace=False)
|
| Resize the underlying vectors array. If inplace=True, the memory
| is reallocated. This may cause other references to the data to become
| invalid, so only use inplace=True if you're sure that's what you want.
|
| If the number of vectors is reduced, keys mapped to rows that have been
| deleted are removed. These removed items are returned as a list of
| `(key, row)` tuples.
|
| shape (tuple): A `(rows, dims)` tuple.
| inplace (bool): Reallocate the memory.
| RETURNS (list): The removed items as a list of `(key, row)` tuples.
|
| DOCS: https://spacy.io/api/vectors#resize
|
| to_bytes(self, *, exclude=())
| Vectors.to_bytes(self, *, exclude=tuple())
|
| Serialize the current state to a binary string.
|
| exclude (list): String names of serialization fields to exclude.
| RETURNS (bytes): The serialized form of the `Vectors` object.
|
| DOCS: https://spacy.io/api/vectors#to_bytes
|
| to_disk(self, path, *, exclude=())
| Vectors.to_disk(self, path, *, exclude=tuple())
|
| Save the current state to a directory.
|
| path (str / Path): A path to a directory, which will be created if
| it doesn't exists.
|
| DOCS: https://spacy.io/api/vectors#to_disk
|
| to_ops(self, ops: 'Ops')
| Vectors.to_ops(self, ops: Ops)
|
| values(self)
| Vectors.values(self)
|
| Iterate over vectors that have been assigned to at least one key.
|
| Note that some vectors may be unassigned, so the number of vectors
| returned may be less than the length of the vectors table.
|
| YIELDS (ndarray): A vector in the table.
|
| DOCS: https://spacy.io/api/vectors#values
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| attr
|
| bow
|
| data
| data: object
|
| eow
|
| hash_count
|
| hash_seed
|
| is_full
| Whether the vectors table is full.
|
| RETURNS (bool): `True` if no slots are available for new keys.
|
| DOCS: https://spacy.io/api/vectors#is_full
|
| key2row
| key2row: object
|
| maxn
|
| minn
|
| mode
|
| n_keys
| Get the number of keys in the table. Note that this is the number
| of all keys, not just unique vectors.
|
| RETURNS (int): The number of keys in the table for default vectors.
| For floret vectors, return -1.
|
| DOCS: https://spacy.io/api/vectors#n_keys
|
| name
| name: object
|
| shape
| Get `(rows, dims)` tuples of number of rows and number of dimensions
| in the vector table.
|
| RETURNS (tuple): A `(rows, dims)` pair.
|
| DOCS: https://spacy.io/api/vectors#shape
|
| size
| The vector size i,e. rows * dims.
|
| RETURNS (int): The vector size.
|
| DOCS: https://spacy.io/api/vectors#size
|
| strings
| strings: object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
|
| ----------------------------------------------------------------------
| Methods inherited from BaseVectors:
|
| __reduce_cython__(self)
| BaseVectors.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| BaseVectors.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| BaseVectors.__setstate_cython__(self, __pyx_state)
|
| ----------------------------------------------------------------------
| Data descriptors inherited from BaseVectors:
|
| vectors_length
FUNCTIONS
create_mode_vectors() -> "Callable[['Vocab'], BaseVectors]"
create_mode_vectors() -> Callable[['Vocab'], BaseVectors]
unpickle_vectors(bytes_data)
unpickle_vectors(bytes_data)
DATA
Callable = typing.Callable
Deprecated alias to collections.abc.Callable.
Callable[[int], str] signifies a function that takes a single
parameter of type int and returns a str.
The subscription syntax must always be used with exactly two
values: the argument list and the return type.
The argument list must be a list of types, a ParamSpec,
Concatenate or ellipsis. The return type must be a single type.
There is no syntax to indicate optional or keyword arguments;
such function types are rarely used as callback types.
IDS = {'': 0, 'DEP': 76, 'ENT_ID': 454, 'ENT_IOB': 77, 'ENT_KB_ID': 45...
TYPE_CHECKING = False
Union = typing.Union
Union type; Union[X, Y] means either X or Y.
On Python 3.10 and higher, the | operator
can also be used to denote unions;
X | Y means the same thing to the type checker as Union[X, Y].
To define a union, use e.g. Union[int, str]. Details:
- The arguments must be types and there must be at least one.
- None as an argument is a special case and is replaced by
type(None).
- Unions of unions are flattened, e.g.::
assert Union[Union[int, str], float] == Union[int, str, float]
- Unions of a single argument vanish, e.g.::
assert Union[int] == int # The constructor actually returns int
- Redundant arguments are skipped, e.g.::
assert Union[int, str, int] == Union[int, str]
- When comparing unions, the argument order is ignored, e.g.::
assert Union[int, str] == Union[str, int]
- You cannot subclass or instantiate a union.
- You can use Optional[X] as a shorthand for Union[X, None].
__test__ = {}
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\vectors.cp312-win_amd64.pyd
spacy.vocab
Python Library Documentation: module spacy.vocab in spacy
NAME
spacy.vocab
CLASSES
builtins.object
Vocab
class Vocab(builtins.object)
| Vocab(lex_attr_getters=None, strings=tuple(), lookups=None, oov_prob=-20., vectors_name=None, writing_system={}, get_noun_chunks=None, **deprecated_kwargs)
|
| A look-up table that allows you to access `Lexeme` objects. The `Vocab`
| instance also provides access to the `StringStore`, and owns underlying
| C-data that is shared between `Doc` objects.
|
| DOCS: https://spacy.io/api/vocab
|
| Methods defined here:
|
| __contains__(...)
| Vocab.__contains__(self, key)
|
| Check whether the string or int key has an entry in the vocabulary.
|
| string (str): The ID string.
| RETURNS (bool) Whether the string has an entry in the vocabulary.
|
| DOCS: https://spacy.io/api/vocab#contains
|
| __getitem__(...)
| Vocab.__getitem__(self, id_or_string)
|
| Retrieve a lexeme, given an int ID or a unicode string. If a
| previously unseen unicode string is given, a new lexeme is created and
| stored.
|
| id_or_string (int or str): The integer ID of a word, or its unicode
| string. If `int >= Lexicon.size`, `IndexError` is raised. If
| `id_or_string` is neither an int nor a unicode string, `ValueError`
| is raised.
| RETURNS (Lexeme): The lexeme indicated by the given ID.
|
| EXAMPLE:
| >>> apple = nlp.vocab.strings["apple"]
| >>> assert nlp.vocab[apple] == nlp.vocab[u"apple"]
|
| DOCS: https://spacy.io/api/vocab#getitem
|
| __init__(...)
| Create the vocabulary.
|
| lex_attr_getters (dict): A dictionary mapping attribute IDs to
| functions to compute them. Defaults to `None`.
| strings (StringStore): StringStore that maps strings to integers, and
| vice versa.
| lookups (Lookups): Container for large lookup tables and dictionaries.
| oov_prob (float): Default OOV probability.
| vectors_name (str): Optional name to identify the vectors table.
| get_noun_chunks (Optional[Callable[[Union[Doc, Span], Iterator[Tuple[int, int, int]]]]]):
| A function that yields base noun phrases used for Doc.noun_chunks.
|
| __iter__(...)
| Vocab.__iter__(self)
|
| Iterate over the lexemes in the vocabulary.
|
| YIELDS (Lexeme): An entry in the vocabulary.
|
| DOCS: https://spacy.io/api/vocab#iter
|
| __len__(...)
| Vocab.__len__(self)
|
| The current number of lexemes stored.
|
| RETURNS (int): The current number of lexemes stored.
|
| __reduce__ = __reduce_cython__(...)
| Vocab.__reduce_cython__(self)
|
| __reduce_cython__(self)
| Vocab.__reduce_cython__(self)
|
| __setstate__ = __setstate_cython__(...)
| Vocab.__setstate_cython__(self, __pyx_state)
|
| __setstate_cython__(self, __pyx_state)
| Vocab.__setstate_cython__(self, __pyx_state)
|
| add_flag(self, flag_getter, flag_id=-1)
| Vocab.add_flag(self, flag_getter, int flag_id=-1)
|
| Set a new boolean flag to words in the vocabulary.
|
| The flag_getter function will be called over the words currently in the
| vocab, and then applied to new words as they occur. You'll then be able
| to access the flag value on each token using token.check_flag(flag_id).
| See also: `Lexeme.set_flag`, `Lexeme.check_flag`, `Token.set_flag`,
| `Token.check_flag`.
|
| flag_getter (callable): A function `f(str) -> bool`, to get the
| flag value.
| flag_id (int): An integer between 1 and 63 (inclusive), specifying
| the bit at which the flag will be stored. If -1, the lowest
| available bit will be chosen.
| RETURNS (int): The integer ID by which the flag value can be checked.
|
| DOCS: https://spacy.io/api/vocab#add_flag
|
| deduplicate_vectors(self)
| Vocab.deduplicate_vectors(self)
|
| from_bytes(self, bytes_data, *, exclude=())
| Vocab.from_bytes(self, bytes_data, *, exclude=tuple())
|
| Load state from a binary string.
|
| bytes_data (bytes): The data to load from.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (Vocab): The `Vocab` object.
|
| DOCS: https://spacy.io/api/vocab#from_bytes
|
| from_disk(self, path, *, exclude=())
| Vocab.from_disk(self, path, *, exclude=tuple())
|
| Loads state from a directory. Modifies the object in place and
| returns it.
|
| path (str or Path): A path to a directory.
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (Vocab): The modified `Vocab` object.
|
| DOCS: https://spacy.io/api/vocab#to_disk
|
| get_vector(self, orth)
| Vocab.get_vector(self, orth)
|
| Retrieve a vector for a word in the vocabulary. Words can be looked
| up by string or int ID. If the current vectors do not contain an entry
| for the word, a 0-vector with the same number of dimensions as the
| current vectors is returned.
|
| orth (int / unicode): The hash value of a word, or its unicode string.
| RETURNS (numpy.ndarray or cupy.ndarray): A word vector. Size
| and shape determined by the `vocab.vectors` instance. Usually, a
| numpy ndarray of shape (300,) and dtype float32.
|
| DOCS: https://spacy.io/api/vocab#get_vector
|
| has_vector(self, orth)
| Vocab.has_vector(self, orth)
|
| Check whether a word has a vector. Returns False if no vectors have
| been loaded. Words can be looked up by string or int ID.
|
| orth (int / str): The word.
| RETURNS (bool): Whether the word has a vector.
|
| DOCS: https://spacy.io/api/vocab#has_vector
|
| memory_zone(self, mem: 'Optional[Pool]' = None) -> 'Iterator[Pool]'
| Vocab.memory_zone(self, mem: Optional[Pool] = None) -> Iterator[Pool]
|
| Begin a block where resources allocated during the block will
| be freed at the end of it. If a resources was created within the
| memory zone block, accessing it outside the block is invalid.
| Behaviour of this invalid access is undefined. Memory zones should
| not be nested.
|
| The memory zone is helpful for services that need to process large
| volumes of text with a defined memory budget.
|
| prune_vectors(self, nr_row, batch_size=1024)
| Vocab.prune_vectors(self, nr_row, batch_size=1024)
|
| Reduce the current vector table to `nr_row` unique entries. Words
| mapped to the discarded vectors will be remapped to the closest vector
| among those remaining.
|
| For example, suppose the original table had vectors for the words:
| ['sat', 'cat', 'feline', 'reclined']. If we prune the vector table to
| two rows, we would discard the vectors for 'feline' and 'reclined'.
| These words would then be remapped to the closest remaining vector
| -- so "feline" would have the same vector as "cat", and "reclined"
| would have the same vector as "sat".
|
| The similarities are judged by cosine. The original vectors may
| be large, so the cosines are calculated in minibatches, to reduce
| memory usage.
|
| nr_row (int): The number of rows to keep in the vector table.
| batch_size (int): Batch of vectors for calculating the similarities.
| Larger batch sizes might be faster, while temporarily requiring
| more memory.
| RETURNS (dict): A dictionary keyed by removed words mapped to
| `(string, score)` tuples, where `string` is the entry the removed
| word was mapped to, and `score` the similarity score between the
| two words.
|
| DOCS: https://spacy.io/api/vocab#prune_vectors
|
| reset_vectors(self, *, width=None, shape=None)
| Vocab.reset_vectors(self, *, width=None, shape=None)
|
| Drop the current vector table. Because all vectors must be the same
| width, you have to call this to change the size of the vectors.
|
| set_vector(self, orth, vector)
| Vocab.set_vector(self, orth, vector)
|
| Set a vector for a word in the vocabulary. Words can be referenced
| by string or int ID.
|
| orth (int / str): The word.
| vector (numpy.ndarray or cupy.nadarry[ndim=1, dtype='float32']): The vector to set.
|
| DOCS: https://spacy.io/api/vocab#set_vector
|
| to_bytes(self, *, exclude=())
| Vocab.to_bytes(self, *, exclude=tuple())
|
| Serialize the current state to a binary string.
|
| exclude (Iterable[str]): String names of serialization fields to exclude.
| RETURNS (bytes): The serialized form of the `Vocab` object.
|
| DOCS: https://spacy.io/api/vocab#to_bytes
|
| to_disk(self, path, *, exclude=())
| Vocab.to_disk(self, path, *, exclude=tuple())
|
| Save the current state to a directory.
|
| path (str or Path): A path to a directory, which will be created if
| it doesn't exist.
| exclude (Iterable[str]): String names of serialization fields to exclude.
|
| DOCS: https://spacy.io/api/vocab#to_disk
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs)
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| cfg
| cfg: object
|
| get_noun_chunks
| get_noun_chunks: object
|
| in_memory_zone
| Vocab.in_memory_zone: bool
|
| lang
|
| length
|
| lex_attr_getters
| lex_attr_getters: object
|
| lookups
|
| morphology
| morphology: spacy.morphology.Morphology
|
| strings
|
| vectors
|
| vectors_length
|
| writing_system
| writing_system: object
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __pyx_vtable__ = <capsule object NULL>
FUNCTIONS
create_vocab(lang, defaults, vectors_name=None)
create_vocab(lang, defaults, vectors_name=None)
pickle_vocab(vocab)
pickle_vocab(vocab)
unpickle_vocab(sstore, vectors, morphology, _unused_object, lex_attr_getters, lookups, get_noun_chunks)
unpickle_vocab(sstore, vectors, morphology, _unused_object, lex_attr_getters, lookups, get_noun_chunks)
DATA
BASE_NORMS = {"''": '"', "'S": "'s", "'s": "'s", '--': '-', '---': '-'...
IS_STOP = 12
Iterator = typing.Iterator
A generic version of collections.abc.Iterator.
LEX_ATTRS = {1: <function is_alpha>, 2: <function is_ascii>, 3: <funct...
NORM = 67
Optional = typing.Optional
Optional[X] is equivalent to Union[X, None].
__pyx_capi__ = {'EMPTY_LEXEME': <capsule object "struct __pyx_t_5spacy...
__test__ = {'Vocab.__getitem__ (line 289)': 'Retrieve a lexeme, given ...
FILE
c:\users\youse\appdata\local\programs\python\python312\lib\site-packages\spacy\vocab.cp312-win_amd64.pyd