Special Types#

SecretStr#

Wraps a string value so it is never exposed in str(), repr(), or logs:

"""SecretStr — masks secret values in str/repr."""

from dataclasses import dataclass

from dature.fields.secret_str import SecretStr

secret = SecretStr("my-database-password")


@dataclass
class Config:
    db_password: SecretStr


config = Config(db_password=secret)

assert str(config.db_password) == "**********"
assert repr(config.db_password) == "SecretStr('**********')"
assert config.db_password.get_secret_value() == "my-database-password"
assert len(config.db_password) == 20

Works with mask_secrets=True — fields of type SecretStr are always detected regardless of field name.

ByteSize#

Parses human-readable sizes into bytes. Supports comparison operators.

"""ByteSize — parses human-readable sizes."""

from dataclasses import dataclass

from dature.fields.byte_size import ByteSize


@dataclass
class Config:
    max_upload: ByteSize


config = Config(max_upload=ByteSize("1.5 GB"))

assert int(config.max_upload) == 1500000000
assert str(config.max_upload) == "1.4GiB"
assert repr(config.max_upload) == "ByteSize(1500000000)"
assert config.max_upload.human_readable() == "1.4GiB"
assert config.max_upload.human_readable(decimal=True) == "1.5GB"
assert ByteSize(1024) > ByteSize(512)

Supported units: B, KB, MB, GB, TB, PB, KiB, MiB, GiB, TiB, PiB.

PaymentCardNumber#

Validates using the Luhn algorithm and detects the brand:

"""PaymentCardNumber — validates via Luhn and detects brand."""

from dataclasses import dataclass

from dature.fields.payment_card import PaymentCardNumber


@dataclass
class Config:
    card: PaymentCardNumber


config = Config(card=PaymentCardNumber("42424242424242"))

assert str(config.card) == "**********4242"
assert repr(config.card) == "PaymentCardNumber('**********4242')"
assert config.card.masked == "**********4242"
assert config.card.brand == "Visa"
assert config.card.get_raw_number() == "42424242424242"

URL#

Type alias for urllib.parse.ParseResult:

"""URL — parsed into urllib.parse.ParseResult."""

from dataclasses import dataclass
from urllib.parse import urlparse

from dature.types import URL


@dataclass
class Config:
    api_url: URL


config = Config(
    api_url=urlparse("https://api.example.com:8080/v1?key=abc#section"),
)

assert config.api_url.scheme == "https"
assert config.api_url.netloc == "api.example.com:8080"
assert config.api_url.hostname == "api.example.com"
assert config.api_url.port == 8080
assert config.api_url.path == "/v1"
assert config.api_url.query == "key=abc"
assert config.api_url.fragment == "section"
assert (
    config.api_url.geturl() == "https://api.example.com:8080/v1?key=abc#section"
)

Base64UrlBytes / Base64UrlStr#

Type aliases decoded from Base64 string in the config. Base64UrlStr decodes to str, Base64UrlBytes decodes to bytes:

"""Base64UrlBytes / Base64UrlStr — decoded from Base64."""

from base64 import urlsafe_b64decode
from dataclasses import dataclass

from dature.types import Base64UrlBytes, Base64UrlStr

encoded = "aGVsbG8gd29ybGQ="


@dataclass
class Config:
    token: Base64UrlStr
    data: Base64UrlBytes


config = Config(
    token=urlsafe_b64decode(encoded).decode(),
    data=urlsafe_b64decode(encoded),
)

assert config.token == "hello world"
assert type(config.token) is str
assert config.data == b"hello world"
assert type(config.data) is bytes