send_the_raven.address.Address#

class send_the_raven.address.Address[source]#

Bases: BaseModel

Represents a US address.

Parameters:

  • full_address (str) – full address.

  • street (str) – The street name and number.

  • address_line_2 (str) – The second line of the address.

  • city (str) – The city name.

  • state (str) – The state or province name.

  • zip_code (str) – The ZIP code or postal code.

  • id (str) – The address ID. If not present, one will be generated to keep track of the address.

full_address#

full address.

Type:

str

street#

The street name and number.

Type:

str

address_line_2#

The second line of the address.

Type:

str

city#

The city name.

Type:

str

state#

The state or province name.

Type:

str

zip_code#

The ZIP code or postal code.

Type:

str

id#

The address ID.

Type:

str

__init__(**data)#

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.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Parameters:

data (Any) –

Return type:

None

__call__(**kwargs)#

Call self as a function.

Methods

__eq__(b)

Compare two addresses.

__init__(**data)

Create a new model by parsing and validating input data from keyword arguments.

__iter__()

So dict(model) works.

construct([_fields_set])

copy(*[, include, exclude, update, deep])

Returns a copy of the model.

dict(*[, include, exclude, by_alias, ...])

extract_address()

Manually extract address directly using usaddress library.

fill_in_city()

Try to find the correct city by using difflib SequenceMatcher.

fill_in_state()

Try to convert state into its 2-letter abbreviation.

fill_in_zipcode()

Try to find the correct zipcode using city.

from_orm(obj)

json(*[, include, exclude, by_alias, ...])

model_construct([_fields_set])

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

model_copy(*[, update, deep])

Usage docs: https://docs.pydantic.dev/2.2/usage/serialization/#model_copy

model_dump(*[, mode, include, exclude, ...])

Usage docs: https://docs.pydantic.dev/2.2/usage/serialization/#modelmodel_dump

model_dump_json(*[, indent, include, ...])

Usage docs: https://docs.pydantic.dev/2.2/usage/serialization/#modelmodel_dump_json

model_json_schema([by_alias, ref_template, ...])

Generates a JSON schema for a model class.

model_parametrized_name(params)

Compute the class name for parametrizations of generic classes.

model_post_init(_BaseModel__context)

Override this method to perform additional initialization after __init__ and model_construct.

model_rebuild(*[, force, raise_errors, ...])

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

model_validate(obj, *[, strict, ...])

Validate a pydantic model instance.

model_validate_json(json_data, *[, strict, ...])

Validate the given JSON data against the Pydantic model.

normalize()

Normalize address using GreenBuildingRegistry/usaddress-scourgify

parse_file(path, *[, content_type, ...])

parse_obj(obj)

parse_raw(b, *[, content_type, encoding, ...])

schema([by_alias, ref_template])

schema_json(*[, by_alias, ref_template])

update_forward_refs(**localns)

validate(value)

Attributes

model_computed_fields

Get the computed fields of this model instance.

model_config

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

model_extra

Get extra fields set during validation.

model_fields

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

model_fields_set

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

full_address

street

address_line_2

city

state

zip_code

id

__init__(**data)#

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.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Parameters:

data (Any) –

Return type:

None

copy(*, include=None, exclude=None, update=None, deep=False)#

Returns a copy of the model.

!!! warning “Deprecated”

This method is now deprecated; use model_copy instead.

If you need include or exclude, use:

`py data = self.model_dump(include=include, exclude=exclude, round_trip=True) data = {**data, **(update or {})} copied = self.model_validate(data) `

Parameters:

  • include (AbstractSetIntStr | MappingIntStrAny | None) – Optional set or mapping specifying which fields to include in the copied model.

  • exclude (AbstractSetIntStr | MappingIntStrAny | None) – Optional set or mapping specifying which fields to exclude in the copied model.

  • update (Dict[str, Any] | None) – Optional dictionary of field-value pairs to override field values in the copied model.

  • deep (bool) – If True, the values of fields that are Pydantic models will be deep copied.

  • self (Model) –

Returns:

A copy of the model with included, excluded and updated fields as specified.

Return type:

Model

extract_address()[source]#

Manually extract address directly using usaddress library.

fill_in_city()[source]#

Try to find the correct city by using difflib SequenceMatcher. If the ratio score is above 0.73, it will replace current city with it.

Example

>>> addr = Address(city="San Fran")
>>> addr.fill_in_city()
>>> print(addr.city)
San Francisco

Warning

Expensive operation.

fill_in_state()[source]#

Try to convert state into its 2-letter abbreviation. If not found, use SequenceMatcher to find the closest one.

USPS needs 2-letter abbreviation.

Example

>>> addr = Address(state="California")
>>> addr.fill_in_state()
>>> print(addr.state)
CA
fill_in_zipcode()[source]#

Try to find the correct zipcode using city. USPS validation will have more successful rate when zip code is present even though it’s the wrong zipcode but the city is the same.

Example

>>> addr = Address(city="San Francisco")
>>> print(addr.zipcode)
None
>>> addr.fill_in_zipcode()
>>> print(addr.zipcode)
94105
property model_computed_fields: dict[str, pydantic.fields.ComputedFieldInfo]#

Get the computed fields of this model instance.

Returns:

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

model_config: ClassVar[ConfigDict] = {}#

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

classmethod model_construct(_fields_set=None, **values)#

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

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

Parameters:

  • _fields_set (set[str] | None) – The set of field names accepted for the Model instance.

  • values (Any) – Trusted or pre-validated data dictionary.

Returns:

A new instance of the Model class with validated data.

Return type:

Model

model_copy(*, update=None, deep=False)#

Usage docs: https://docs.pydantic.dev/2.2/usage/serialization/#model_copy

Returns a copy of the model.

Parameters:

  • update (dict[str, Any] | None) – 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 (bool) – Set to True to make a deep copy of the model.

  • self (Model) –

Returns:

New model instance.

Return type:

Model

model_dump(*, mode='python', include=None, exclude=None, by_alias=False, exclude_unset=False, exclude_defaults=False, exclude_none=False, round_trip=False, warnings=True)#

Usage docs: https://docs.pydantic.dev/2.2/usage/serialization/#modelmodel_dump

Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.

Parameters:

  • mode (Literal['json', 'python'] | str) – The mode in which to_python should run. If mode is ‘json’, the dictionary will only contain JSON serializable types. If mode is ‘python’, the dictionary may contain any Python objects.

  • include (IncEx) – A list of fields to include in the output.

  • exclude (IncEx) – A list of fields to exclude from the output.

  • by_alias (bool) – Whether to use the field’s alias in the dictionary key if defined.

  • exclude_unset (bool) – Whether to exclude fields that are unset or None from the output.

  • exclude_defaults (bool) – Whether to exclude fields that are set to their default value from the output.

  • exclude_none (bool) – Whether to exclude fields that have a value of None from the output.

  • round_trip (bool) – Whether to enable serialization and deserialization round-trip support.

  • warnings (bool) – Whether to log warnings when invalid fields are encountered.

Returns:

A dictionary representation of the model.

Return type:

dict[str, Any]

model_dump_json(*, indent=None, include=None, exclude=None, by_alias=False, exclude_unset=False, exclude_defaults=False, exclude_none=False, round_trip=False, warnings=True)#

Usage docs: https://docs.pydantic.dev/2.2/usage/serialization/#modelmodel_dump_json

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

Parameters:

  • indent (int | None) – Indentation to use in the JSON output. If None is passed, the output will be compact.

  • include (IncEx) – Field(s) to include in the JSON output. Can take either a string or set of strings.

  • exclude (IncEx) – Field(s) to exclude from the JSON output. Can take either a string or set of strings.

  • by_alias (bool) – Whether to serialize using field aliases.

  • exclude_unset (bool) – Whether to exclude fields that have not been explicitly set.

  • exclude_defaults (bool) – Whether to exclude fields that have the default value.

  • exclude_none (bool) – Whether to exclude fields that have a value of None.

  • round_trip (bool) – Whether to use serialization/deserialization between JSON and class instance.

  • warnings (bool) – Whether to show any warnings that occurred during serialization.

Returns:

A JSON string representation of the model.

Return type:

str

property model_extra: dict[str, Any] | None#

Get extra fields set during validation.

Returns:

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

model_fields: ClassVar[dict[str, FieldInfo]] = {'address_line_2': FieldInfo(annotation=Union[str, NoneType], required=False), 'city': FieldInfo(annotation=Union[str, NoneType], required=False), 'full_address': FieldInfo(annotation=Union[str, NoneType], required=False), 'id': FieldInfo(annotation=Union[str, NoneType], required=False, default='41190dd5a15c388'), 'state': FieldInfo(annotation=Union[str, NoneType], required=False), 'street': FieldInfo(annotation=Union[str, NoneType], required=False), 'zip_code': FieldInfo(annotation=Union[str, NoneType], required=False)}#

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

This replaces Model.__fields__ from Pydantic V1.

property model_fields_set: set[str]#

Returns the set of fields that have been 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.

classmethod model_json_schema(by_alias=True, ref_template='#/$defs/{model}', schema_generator=<class 'pydantic.json_schema.GenerateJsonSchema'>, mode='validation')#

Generates a JSON schema for a model class.

Parameters:

  • by_alias (bool) – Whether to use attribute aliases or not.

  • ref_template (str) – The reference template.

  • schema_generator (type[pydantic.json_schema.GenerateJsonSchema]) – To override the logic used to generate the JSON schema, as a subclass of GenerateJsonSchema with your desired modifications

  • mode (Literal['validation', 'serialization']) – The mode in which to generate the schema.

Returns:

The JSON schema for the given model class.

Return type:

dict[str, Any]

classmethod model_parametrized_name(params)#

Compute the class name for parametrizations of generic classes.

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

Parameters:

params (tuple[type[Any], ...]) – 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.

Return type:

str

model_post_init(_BaseModel__context)#

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.

Parameters:

_BaseModel__context (Any) –

Return type:

None

classmethod model_rebuild(*, force=False, raise_errors=True, _parent_namespace_depth=2, _types_namespace=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.

Parameters:

  • force (bool) – Whether to force the rebuilding of the model schema, defaults to False.

  • raise_errors (bool) – Whether to raise errors, defaults to True.

  • _parent_namespace_depth (int) – The depth level of the parent namespace, defaults to 2.

  • _types_namespace (dict[str, Any] | None) – 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.

Return type:

bool | None

classmethod model_validate(obj, *, strict=None, from_attributes=None, context=None)#

Validate a pydantic model instance.

Parameters:

  • obj (Any) – The object to validate.

  • strict (bool | None) – Whether to raise an exception on invalid fields.

  • from_attributes (bool | None) – Whether to extract data from object attributes.

  • context (dict[str, Any] | None) – Additional context to pass to the validator.

Raises:

ValidationError – If the object could not be validated.

Returns:

The validated model instance.

Return type:

Model

classmethod model_validate_json(json_data, *, strict=None, context=None)#

Validate the given JSON data against the Pydantic model.

Parameters:

  • json_data (str | bytes | bytearray) – The JSON data to validate.

  • strict (bool | None) – Whether to enforce types strictly.

  • context (dict[str, Any] | None) – Extra variables to pass to the validator.

Returns:

The validated Pydantic model.

Raises:

ValueError – If json_data is not a JSON string.

Return type:

Model

normalize()[source]#

Normalize address using GreenBuildingRegistry/usaddress-scourgify

Warning

When address is not parseable, it will be set to None. No error would be thrown.