Checks if the value is a string, and optionally meets some constraints. `IsStr` is a subclass of [`IsAnyStr`][dirty_equals.IsAnyStr] and the

Check if a datetime is close to now, this is similar to `IsDatetime(approx=datetime.now())`, but slightly more powerful.

Check if the value is a datetime, and matches the given conditions.

Base class for comparing dictionaries. By default, `IsDict` isn't particularly useful on its own (it behaves pretty much like a normal `dict`

A type which checks that the value is an instance of the expected type.

Checks that a value is an integer. Inherits from [`IsNumeric`][dirty_equals.IsNumeric] and can therefore be initialised with any of its argu

A class that checks if a value is a JSON object, and check the contents of the JSON.

All the same functionality as [`IsListOrTuple`][dirty_equals.IsListOrTuple], but the compared value must be a list. ```py title="IsList"

Comparison of `str` or `bytes` objects. This class allow comparison with both `str` and `bytes` but is subclassed by [`IsStr`][dirty_equ

Check if the value is False like. `IsFalseLike` allows comparison to anything and effectively uses `return not bool(other)` (with string chec

Check if a date is today, this is similar to `IsDate(approx=date.today())`, but slightly more powerful.

Use a function to check if a value "equals" whatever you want to check

A type which checks that the value has the given `__name__` attribute.

Checks if the value is a bytes object, and optionally meets some constraints. `IsBytes` is a subclass of [`IsAnyStr`][dirty_equals.IsAnyStr]

A class that checks if a value is a valid common hash type, using a simple length and allowed characters regex.

A type which checks that the value has the given `repr()` value.

Checks that an object is an instance of a dataclass. Inherits from [`DirtyEquals`][dirty_equals.DirtyEquals] and it can be initialised with

A class that checks if a value is a valid IP address, optionally checking IP version, netmask.

Dictionary comparison with `None` values ignored, this is the same as [`IsDict(...).settings(ignore={None})`][dirty_equals.IsDict.settings].

Partial dictionary comparison, this is the same as [`IsDict(...).settings(partial=True)`][dirty_equals.IsDict.settings]. ```py title="Is

A class that checks if a value is a valid UUID, optionally checking UUID version.

A class that checks if a value is a valid URL, optionally checking different URL types and attributes with [Pydantic](https://pydantic-docs.h

Check that an object contains one or more values.

Simplified subclass of [`IsNumber`][dirty_equals.IsNumber] that only allows approximate comparisons.

Check that a value is negative (`< 0`), can be an `int`, a `float` or a `Decimal` (or indeed any value which implements `__lt__` for `0`).

Check that a value is positive (`> 0`), can be an `int`, a `float` or a `Decimal` (or indeed any value which implements `__gt__` for `0`).

Dictionary comparison with order enforced, this is the same as [`IsDict(...).settings(strict=True)`][dirty_equals.IsDict.settings]. ```p

Hack to allow repr of string without quotes.

A type which matches any value. `AnyThing` isn't generally very useful on its own, but can be used within other comparisons. ```py title

Base type for all *dirty-equals* types.

A type which checks that the value has the given attributes. This is a partial check - e.g. the attributes provided to check do not need to

Check that some has a given length, or length in a given range.

Checks that an object is a dataclass type. Inherits from [`DirtyEquals`][dirty_equals.DirtyEquals]. ```py title="IsDataclassType" f

Check if the value is a date, and matches the given conditions.

Checks if an instance is an Enum. Inherits from [`DirtyEquals`][dirty_equals.DirtyEquals]. ```py title="IsEnum" from enum import En

Checks that a value is a float. Inherits from [`IsNumeric`][dirty_equals.IsNumeric] and can therefore be initialised with any of its argumen

Checks that a value is float and infinite (positive or negative). Inherits from [`IsFloat`][dirty_equals.IsFloat]. ```py title="IsFloat

Checks that a value is float and negative infinite. Inherits from [`IsFloatInf`][dirty_equals.IsFloatInf]. ```py title="IsFloatInfNeg"

Checks that a value is float and positive infinite. Inherits from [`IsFloatInf`][dirty_equals.IsFloatInf]. ```py title="IsFloatInfPos"

Checks that a value is float and nan (not a number). Inherits from [`IsFloat`][dirty_equals.IsFloat]. ```py title="IsFloatNan" from

Check that some object is a list or tuple and optionally its values match some constraints.

Like [`IsNegative`][dirty_equals.IsNegative] but only for `float`s. ```py title="IsNegativeFloat" from decimal import Decimal from

Like [`IsNegative`][dirty_equals.IsNegative] but only for `int`s. ```py title="IsNegativeInt" from decimal import Decimal from dirt

Check that a value is positive or zero (`>= 0`), can be an `int`, a `float` or a `Decimal` (or indeed any value which implements `__ge__` for

Check that a value is negative or zero (`<=0`), can be an `int`, a `float` or a `Decimal` (or indeed any value which implements `__le__` for

Base class for all types that can be used with all number types, e.g. numeric but not `date` or `datetime`. Inherits from [`IsNumeric`][dirt

Base class for all numeric types, `IsNumeric` implements approximate and inequality comparisons, as well as the type checks. This class

A type which checks that the value is equal to one of the given values. Can be useful with boolean operators.

Inherits from [`IsDataclass`][dirty_equals.IsDataclass] with `partial=True` by default. ```py title="IsPartialDataclass" from dataclasse

Like [`IsPositive`][dirty_equals.IsPositive] but only for `float`s. ```py title="IsPositiveFloat" from decimal import Decimal from

Like [`IsPositive`][dirty_equals.IsPositive] but only for `int`s. ```py title="IsPositiveInt" from decimal import Decimal from dirt

Inherits from [`IsDataclass`][dirty_equals.IsDataclass] with `strict=True` by default. ```py title="IsStrictDataclass" from dataclasses

Check if the value is True like. `IsTrueLike` allows comparison to anything and effectively uses just `return bool(other)`. Example of b

All the same functionality as [`IsListOrTuple`][dirty_equals.IsListOrTuple], but the compared value must be a tuple. ```py title="IsTuple"