pyfect-dev 0.1.0__py3-none-any.whl

pyfect/config/_config.py

@@ -0,0 +1,261 @@
+"""``Config[A]``: how to read and decode one value from a ``ConfigProvider``.
+
+A config resolves in two channels. Data that is simply not there is
+*absent*: an ``Err`` inside a successful evaluation, which ``with_default``
+and ``option`` recover. Data that is there but invalid, and a source that
+cannot be read, are *failures* of the evaluation, which only ``or_else``
+recovers. ``parse`` turns absence into a failure too, so a config run on its
+own fails with ``ConfigError`` either way.
+"""
+# pyright: reportPrivateUsage=false
+
+from __future__ import annotations
+
+from collections.abc import Callable, Generator, Mapping
+from typing import TYPE_CHECKING, Any, Never, overload, override
+
+from pyfect._core import Effect, _Suspend
+from pyfect._effect_base import A_co
+from pyfect.cause import Cause, Fail
+from pyfect.config._error import ConfigError
+from pyfect.config_provider import ConfigProvider, CurrentConfigProvider, Path, SourceError
+from pyfect.effect import fail_cause, succeed, sync
+from pyfect.option import Option, Some
+from pyfect.result import Err, Ok, Result
+from pyfect.schema import SchemaError
+
+if TYPE_CHECKING:
+    from pyfect._fiber import Fiber
+
+type Resolution[A] = Result[A, ConfigError]
+"""``Ok`` when the value was found, ``Err`` when it is absent."""
+
+type Evaluate[A] = Callable[[ConfigProvider, Path], Effect[Resolution[A], ConfigError]]
+"""Evaluate a config with a provider under a path prefix (from ``nested``)."""
+
+
+class Config(Effect[A_co, ConfigError]):
+    """A recipe for reading a typed value from a ``ConfigProvider``.
+
+    A config is an effect: running it (``yield from port`` inside
+    ``fx.gen``) reads the ``CurrentConfigProvider``. ``parse(provider)``
+    reads a given one. The methods build new configs (an ``Effect`` method
+    that ``Effect``'s ``Config`` module also defines, such as ``option``,
+    has the ``Config`` meaning); the constructors are in ``pyfect.config``."""
+
+    __slots__ = ("_evaluate",)
+
+    def __init__(self, evaluate: Evaluate[A_co]) -> None:
+        self._evaluate = evaluate
+
+    @override
+    def _step(self, fiber: Fiber[Any, Any]) -> Effect[A_co, ConfigError]:
+        return self.parse(fiber.get_ref(CurrentConfigProvider))
+
+    def parse(self, provider: ConfigProvider) -> Effect[A_co, ConfigError]:
+        """Read this config from ``provider``; absence fails too."""
+        return self._evaluate(provider, ()).flat_map(_present_or_fail)
+
+    @override
+    def map[B](self, f: Callable[[A_co], B]) -> Config[B]:
+        evaluate = self._evaluate
+        return Config(lambda provider, prefix: evaluate(provider, prefix).map(lambda r: r.map(f)))
+
+    @overload
+    def flat_map[B](self, f: Callable[[A_co], Config[B]]) -> Config[B]: ...
+    @overload
+    def flat_map[B, E2 = Never, R2 = Never](
+        self, f: Callable[[A_co], Effect[B, E2, R2]]
+    ) -> Effect[B, ConfigError | E2, R2]: ...
+    @override
+    def flat_map(self, f: Callable[[A_co], Effect[Any, Any, Any]]) -> Effect[Any, Any, Any]:
+        """Choose the next config from this one's value; it is read under
+        the same ``nested`` prefix. Absence of either is absence. A function
+        returning a plain effect gives a plain effect, as ``Effect.flat_map``
+        does."""
+        evaluate = self._evaluate
+
+        def run(provider: ConfigProvider, prefix: Path) -> Effect[Resolution[Any], Any]:
+            def next_config(resolution: Resolution[A_co]) -> Effect[Resolution[Any], Any]:
+                match resolution:
+                    case Ok(value):
+                        return _evaluate_at(f(value), provider, prefix)
+                    case Err():
+                        return succeed(resolution)
+
+            return evaluate(provider, prefix).flat_map(next_config)
+
+        return Config(run)
+
+    def map_effect[B](self, f: Callable[[A_co], Effect[B, ConfigError]]) -> Config[B]:
+        """Transform the value with an effect that may fail (Effect's
+        ``mapEffect``); its failure is a failure, not absence."""
+        evaluate = self._evaluate
+
+        def next_value(resolution: Resolution[A_co]) -> Effect[Resolution[B], ConfigError]:
+            match resolution:
+                case Ok(value):
+                    return f(value).map(Ok)
+                case Err():
+                    return succeed(resolution)
+
+        return Config(lambda provider, prefix: evaluate(provider, prefix).flat_map(next_value))
+
+    def or_else[B](self, that: Callable[[ConfigError], Config[B]]) -> Config[A_co | B]:
+        """Read ``that(error)`` when this config is absent or fails with a
+        ``ConfigError``. Defects and interruptions are not recovered, nor is
+        a failure that comes with one."""
+        evaluate = self._evaluate
+
+        def run(
+            provider: ConfigProvider, prefix: Path
+        ) -> Effect[Resolution[A_co | B], ConfigError]:
+            def on_failure(cause: Cause[ConfigError]) -> Effect[Resolution[B], ConfigError]:
+                match cause.reasons:
+                    case (Fail(error), *rest) if all(isinstance(r, Fail) for r in rest):
+                        return that(error)._evaluate(provider, prefix)
+                    case _:
+                        return fail_cause(cause)
+
+            def on_success(
+                resolution: Resolution[A_co],
+            ) -> Effect[Resolution[A_co | B], ConfigError]:
+                match resolution:
+                    case Ok():
+                        return succeed(resolution)
+                    case Err(error):
+                        return that(error)._evaluate(provider, prefix)
+
+            return evaluate(provider, prefix).match_cause_effect(
+                on_failure=on_failure, on_success=on_success
+            )
+
+        return Config(run)
+
+    @overload
+    def with_default[B](self: Config[B], default: B) -> Config[B]: ...
+    @overload
+    def with_default[B](  # pyright: ignore[reportOverlappingOverload]
+        self, default: B
+    ) -> Config[A_co | B]: ...
+    def with_default[B](self, default: B) -> Config[A_co | B]:
+        """``default`` when the value is absent. Invalid data and source
+        errors still fail. A group from ``all`` is absent as a whole when
+        any part is."""
+        evaluate = self._evaluate
+        present: Resolution[B] = Ok(default)
+
+        def recover(resolution: Resolution[A_co]) -> Resolution[A_co | B]:
+            return present if isinstance(resolution, Err) else resolution
+
+        return Config(lambda provider, prefix: evaluate(provider, prefix).map(recover))
+
+    @override
+    def option(self) -> Config[Option[A_co]]:  # pyright: ignore[reportIncompatibleMethodOverride]
+        """``Some(value)``, or ``None`` when the value is absent (Effect's
+        ``Config.option``). Invalid data and source errors still fail: this
+        is not ``Effect.option``, which would turn them into ``None``."""
+        return self.map(Some).with_default(None)
+
+    def nested(self, name: str) -> Config[A_co]:
+        """Read this config under ``name``: an object level in
+        ``from_unknown``, a ``name_`` prefix in ``from_env``. The outermost
+        ``nested`` is the outermost segment."""
+        evaluate = self._evaluate
+        return Config(lambda provider, prefix: evaluate(provider, (*prefix, name)))
+
+    @override
+    def __repr__(self) -> str:
+        return "Config()"
+
+
+def _present_or_fail[A](resolution: Resolution[A]) -> Effect[A, ConfigError]:
+    match resolution:
+        case Ok(value):
+            return succeed(value)
+        case Err(error):
+            return fail_cause(Cause((Fail(error),)))
+
+
+def _evaluate_at(
+    eff: Effect[Any, Any, Any], provider: ConfigProvider, prefix: Path
+) -> Effect[Resolution[Any], Any]:
+    """A config read under ``prefix``; any other effect run for its value."""
+    if isinstance(eff, Config):
+        return eff._evaluate(provider, prefix)
+    return eff.map(Ok)
+
+
+def require_config(value: object, name: str) -> None:
+    if not isinstance(value, Config):
+        raise TypeError(f"{name} must be a Config, got {type(value).__name__}: {value!r}")
+
+
+def succeed_config[A](value: A) -> Config[A]:
+    """A config that reads nothing and gives ``value``."""
+    present: Resolution[A] = Ok(value)
+    return Config(lambda _provider, _prefix: succeed(present))
+
+
+def fail_config(error: SourceError | SchemaError) -> Config[Never]:
+    """A config that always fails with ``ConfigError(error)``."""
+    failure: Effect[Never, ConfigError] = fail_cause(Cause((Fail(ConfigError(error)),)))
+    return Config(lambda _provider, _prefix: failure)
+
+
+def option[A](config: Config[A]) -> Config[Option[A]]:
+    """``config.option()``: ``Some(value)``, or ``None`` when the value is
+    absent. Invalid data and source errors still fail."""
+    return config.option()
+
+
+def gen[A](f: Callable[[], Generator[Effect[Any, ConfigError, Never], Any, A]]) -> Config[A]:
+    """Build a config from a generator: ``x = yield from cfg`` reads
+    ``cfg`` under the result's ``nested`` prefix, and the result is absent
+    as soon as one read is. Other effects run as they are (they may fail
+    only with ``ConfigError`` and need no services)::
+
+        @config.gen
+        def server():
+            host = yield from config.string("HOST")
+            port = yield from config.port("PORT").with_default(8080)
+            return f"{host}:{port}"
+    """
+
+    def run(provider: ConfigProvider, prefix: Path) -> Effect[Resolution[A], ConfigError]:
+        def start() -> Effect[Resolution[A], ConfigError]:
+            generator = f()
+
+            def advance(send: Callable[[], Effect[Any, ConfigError, Never]]) -> Effect[Any, Any]:
+                try:
+                    yielded = send()
+                except StopIteration as stop:
+                    done: Resolution[A] = Ok(stop.value)
+                    return succeed(done)
+
+                def next_step(resolution: Resolution[Any]) -> Effect[Any, Any]:
+                    match resolution:
+                        case Ok(value):
+                            return advance(lambda: generator.send(value))
+                        case Err():
+                            return succeed(resolution)
+
+                return _evaluate_at(yielded, provider, prefix).flat_map(next_step)
+
+            # Closing runs the generator's ``finally`` blocks however the
+            # read ends: absent, failed, interrupted or done (a no-op then).
+            return advance(lambda: next(generator)).ensuring(sync(generator.close))
+
+        return _Suspend(start)
+
+    return Config(run)
+
+
+def unwrap(wrapped: Config[Any] | Mapping[str, Any]) -> Config[Any]:
+    """A config itself, or a (nested) mapping of configs read as one
+    ``all_dict`` per level."""
+    from pyfect.config._all import all_dict
+
+    if isinstance(wrapped, Config):
+        return wrapped
+    return all_dict({key: unwrap(value) for key, value in wrapped.items()})

pyfect/config/_constructors.py

@@ -0,0 +1,106 @@
+"""The scalar config constructors. Each reads the string at ``name`` (or at
+the config's own path when ``name`` is omitted) and is absent when there is
+none."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, overload
+
+from pyfect._one_or_many import one_or_many
+from pyfect._url import Url
+from pyfect.byte_size import ByteSize
+from pyfect.config import _scalars
+from pyfect.config._config import Config
+from pyfect.config._leaf import scalar_config
+from pyfect.config._scalars import LiteralValue
+from pyfect.duration import Seconds
+from pyfect.logger import LogLevel
+from pyfect.redacted import Redacted
+
+
+def string(name: str | None = None) -> Config[str]:
+    """Any string."""
+    return scalar_config(_scalars.string, name)
+
+
+def non_empty_string(name: str | None = None) -> Config[str]:
+    """A string of at least one character."""
+    return scalar_config(_scalars.non_empty_string, name)
+
+
+def number(name: str | None = None) -> Config[float]:
+    """A number, ``"Infinity"``, ``"-Infinity"`` and ``"NaN"`` included
+    (Effect's ``Config.Number``)."""
+    return scalar_config(_scalars.number, name)
+
+
+def finite(name: str | None = None) -> Config[float]:
+    """A finite number."""
+    return scalar_config(_scalars.finite, name)
+
+
+def integer(name: str | None = None) -> Config[int]:
+    """A whole number, read exactly (``"1e3"`` is ``1000``; Effect's
+    ``Config.Int``)."""
+    return scalar_config(_scalars.integer, name)
+
+
+def port(name: str | None = None) -> Config[int]:
+    """An integer from 1 to 65535."""
+    return scalar_config(_scalars.port, name)
+
+
+def boolean(name: str | None = None) -> Config[bool]:
+    """``true`` / ``yes`` / ``on`` / ``1`` / ``y`` or ``false`` / ``no`` /
+    ``off`` / ``0`` / ``n``, in lower case."""
+    return scalar_config(_scalars.boolean, name)
+
+
+@overload
+def literal[L: LiteralValue](
+    values: list[L] | tuple[L, ...], /, *, name: str | None = None
+) -> Config[L]: ...
+@overload
+def literal[L: LiteralValue](*values: L, name: str | None = None) -> Config[L]: ...
+def literal(*values: Any, name: str | None = None) -> Config[Any]:
+    """One of ``values`` (as arguments or, as in Effect, one list or tuple),
+    written as Effect writes literals (``True`` is ``"true"``, ``None`` is
+    ``"null"``). Annotate the result to keep the literal types:
+    ``env: Config[Literal["dev", "prod"]] = config.literal("dev", "prod")``."""
+    return scalar_config(_scalars.literal(one_or_many(values)), name)
+
+
+def log_level(name: str | None = None) -> Config[LogLevel]:
+    """A ``LogLevel`` by Effect's name: ``All``, ``Fatal``, ``Error``,
+    ``Warn``, ``Info``, ``Debug``, ``Trace`` or ``None``."""
+    return scalar_config(_scalars.log_level, name)
+
+
+def duration(name: str | None = None) -> Config[Seconds]:
+    """A duration such as ``"10 seconds"`` or ``"500 millis"`` (``nanos``
+    to ``weeks``, singular or plural), or ``"Infinity"`` / ``"-Infinity"``."""
+    return scalar_config(_scalars.duration, name)
+
+
+def byte_size(name: str | None = None) -> Config[ByteSize]:
+    """An exact size such as ``"10 MB"`` or ``"1.5 KiB"``."""
+    return scalar_config(_scalars.byte_size, name)
+
+
+def date_time(name: str | None = None) -> Config[datetime]:
+    """An ISO 8601 date or date-time (read as JavaScript's ``Date`` reads it); one with
+    no offset is UTC (Effect's ``Config.Date``)."""
+    return scalar_config(_scalars.date_time, name)
+
+
+def url(name: str | None = None) -> Config[Url]:
+    """An absolute URL with a scheme (and a host for ``http``, ``https``,
+    ``ws``, ``wss`` and ``ftp``), split by ``urllib.parse.urlsplit`` into a
+    ``Url``, whose ``str()`` is the URL (``f"{url}/payouts"``)."""
+    return scalar_config(_scalars.url, name)
+
+
+def redacted(name: str | None = None) -> Config[Redacted[str]]:
+    """A string hidden in a ``Redacted``."""
+    return scalar_config(_scalars.redacted, name)

pyfect/config/_error.py

@@ -0,0 +1,27 @@
+"""``ConfigError``: reading configuration failed."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from pyfect.config_provider import SourceError
+from pyfect.errors import TaggedError
+from pyfect.schema import SchemaError
+
+
+@dataclass(eq=False)
+class ConfigError(TaggedError):
+    """Configuration could not be read: the source failed (``SourceError``)
+    or the data was missing or invalid (``SchemaError``). ``message`` is
+    Effect's (``SchemaError(Expected string\\n  at ["PORT"])``); the bare
+    text is ``error.cause.message``."""
+
+    cause: SourceError | SchemaError
+
+    @property
+    def message(self) -> str:
+        match self.cause:
+            case SchemaError():
+                return f"SchemaError({self.cause.message})"
+            case SourceError(message=message):
+                return f"SourceError: {message}"

pyfect/config/_leaf.py

@@ -0,0 +1,92 @@
+"""Reading one node: provider failures as ``ConfigError``, and the scalar
+configs built on a ``Scalar`` decoder."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Never
+
+from pyfect._core import Effect
+from pyfect.cause import Cause, Die, Fail, Interrupt, Reason
+from pyfect.config._config import Config, Resolution
+from pyfect.config._error import ConfigError
+from pyfect.config_provider import ConfigProvider, Node, Path, SourceError
+from pyfect.effect import fail, fail_cause, succeed
+from pyfect.result import Err, Ok, Result
+from pyfect.schema import SchemaError
+from pyfect.schema.ast import Unknown, string
+from pyfect.schema.issue import Composite, InvalidType, Issue, Pointer
+
+
+@dataclass(frozen=True, slots=True)
+class Scalar[A]:
+    """How a config reads a value from one string: ``missing`` is the issue
+    when the node holds no string, ``decode`` parses one."""
+
+    missing: Issue
+    decode: Callable[[str], Result[A, Issue]]
+
+
+def scalar_config[A](scalar: Scalar[A], name: str | None) -> Config[A]:
+    local: Path = () if name is None else (name,)
+
+    def run(provider: ConfigProvider, prefix: Path) -> Effect[Resolution[A], ConfigError]:
+        path = (*prefix, *local)
+
+        def decode(node: Node | None) -> Effect[Resolution[A], ConfigError]:
+            value = None if node is None else node.value
+            if value is None:
+                return succeed(absent(path, scalar.missing))
+            match scalar.decode(value):
+                case Ok() as ok:
+                    return succeed(ok)
+                case Err(issue):
+                    return fail(invalid(path, issue))
+
+        return load(provider, path).flat_map(decode)
+
+    return Config(run)
+
+
+def load(provider: ConfigProvider, path: Path) -> Effect[Node | None, ConfigError]:
+    """``provider.load(path)``, failing with ``ConfigError`` where the
+    provider fails, or dies, with a ``SourceError``. Other defects and
+    interruptions are kept."""
+    return provider.load(path).catch_cause(
+        lambda cause: fail_cause(Cause(tuple(map(_source_reason, cause.reasons))))
+    )
+
+
+def _source_reason(reason: Reason[SourceError]) -> Reason[ConfigError]:
+    match reason:
+        case Fail(error) | Die(SourceError() as error):
+            return Fail(ConfigError(error), annotations=reason.annotations)
+        case Die() | Interrupt():
+            return reason
+
+
+def at(path: Path, issue: Issue) -> Issue:
+    return Pointer(path, issue) if path else issue
+
+
+def invalid(path: Path, issue: Issue) -> ConfigError:
+    return ConfigError(SchemaError(at(path, issue)))
+
+
+def absent(path: Path, issue: Issue) -> Resolution[Never]:
+    return Err(invalid(path, issue))
+
+
+EXPECTED_STRING = InvalidType(string)
+
+
+def expected(text: str) -> InvalidType:
+    """``Expected <text>`` for a node with no schema of its own: an
+    ``Unknown`` node named by its ``identifier``."""
+    return InvalidType(Unknown(annotations={"identifier": text}))
+
+
+def composite(first: Issue, second: Issue) -> Composite:
+    """The issues of two readings of one string."""
+    return Composite(string, (first, second))

pyfect/config/_scalars.py

@@ -0,0 +1,193 @@
+"""The string decoders behind the scalar constructors, with Effect's
+messages (Effect's StringTree encodings of its schemas)."""
+
+from __future__ import annotations
+
+import math
+import re
+from collections.abc import Callable, Sequence
+from datetime import datetime
+
+from pyfect import _js_date as js_date
+from pyfect import _json_text
+from pyfect._js import js_number
+from pyfect._url import Url, parse_url
+from pyfect.byte_size import ByteSize
+from pyfect.byte_size import from_string as byte_size_from_string
+from pyfect.config._leaf import EXPECTED_STRING, Scalar, composite, expected
+from pyfect.duration import Seconds, parse_duration_text
+from pyfect.logger import LogLevel
+from pyfect.redacted import Redacted
+from pyfect.result import Err, Ok, Result
+from pyfect.schema.issue import InvalidValue, Issue
+
+type LiteralValue = str | int | float | bool | None
+
+_STRING = EXPECTED_STRING
+_FINITE = re.compile(r"[+-]?(?:[0-9]+(?:\.[0-9]+)?|\.[0-9]+)(?:[Ee][+-]?[0-9]+)?")
+_NOT_FINITE_STRING = InvalidValue({"message": "Expected a string representing a finite number"})
+_NON_FINITE = {"Infinity": math.inf, "-Infinity": -math.inf, "NaN": math.nan}
+_NON_FINITE_EXPECTED = " | ".join(_json_text.stringify(k) for k in _NON_FINITE)
+_INTEGER = InvalidValue({"message": "Expected an integer"})
+
+
+def _ok[A](value: A) -> Result[A, Issue]:
+    return Ok(value)
+
+
+string = Scalar[str](_STRING, _ok)
+
+
+def _non_empty(text: str) -> Result[str, Issue]:
+    return (
+        Ok(text)
+        if text
+        else Err(InvalidValue({"message": "Expected a value with a length of at least 1"}))
+    )
+
+
+non_empty_string = Scalar(_STRING, _non_empty)
+
+
+def _finite(text: str) -> Result[float, Issue]:
+    if not _FINITE.fullmatch(text):
+        return Err(_NOT_FINITE_STRING)
+    value = float(text)
+    return (
+        Ok(value)
+        if math.isfinite(value)
+        else Err(InvalidValue({"message": "Expected a finite number"}))
+    )
+
+
+finite = Scalar(_STRING, _finite)
+
+
+def _number(text: str) -> Result[float, Issue]:
+    if text in _NON_FINITE:
+        return Ok(_NON_FINITE[text])
+    if _FINITE.fullmatch(text):
+        return Ok(float(text))
+    return Err(composite(_NOT_FINITE_STRING, expected(_NON_FINITE_EXPECTED)))
+
+
+number = Scalar(expected(f"string | {_NON_FINITE_EXPECTED}"), _number)
+
+
+_MAX_SAFE_INTEGER = 2**53 - 1
+
+
+def _integer(text: str) -> Result[int, Issue]:
+    if not _FINITE.fullmatch(text):
+        return Err(_NOT_FINITE_STRING)
+    number = float(text)
+    # As Effect's ``Number`` then ``isSafeInteger``, read through a float.
+    if not math.isfinite(number) or number != int(number) or abs(number) > _MAX_SAFE_INTEGER:
+        return Err(_INTEGER)
+    return Ok(int(number))
+
+
+integer = Scalar(_STRING, _integer)
+
+
+def _port(text: str) -> Result[int, Issue]:
+    match _integer(text):
+        case Ok(value) if not 1 <= value <= 65535:
+            return Err(InvalidValue({"message": "Expected a value between 1 and 65535"}))
+        case decoded:
+            return decoded
+
+
+port = Scalar(_STRING, _port)
+
+
+def _choices[A](pairs: Sequence[tuple[str, A]]) -> Scalar[A]:
+    """A decoder accepting exactly the given spellings, the first match
+    winning; missing and invalid input both list them."""
+    expected_choice = expected(" | ".join(_json_text.stringify(text) for text, _ in pairs))
+    table: dict[str, A] = {}
+    for text, value in pairs:
+        table.setdefault(text, value)
+
+    def decode(text: str) -> Result[A, Issue]:
+        return Ok(table[text]) if text in table else Err(expected_choice)
+
+    return Scalar(expected_choice, decode)
+
+
+boolean = _choices(
+    [(t, True) for t in ("true", "yes", "on", "1", "y")]
+    + [(f, False) for f in ("false", "no", "off", "0", "n")]
+)
+
+log_level = _choices([(str(level), level) for level in LogLevel])
+
+
+def literal[L: LiteralValue](values: Sequence[L]) -> Scalar[L]:
+    return _choices([(_encode_literal(v), v) for v in values])
+
+
+def _encode_literal(value: LiteralValue) -> str:
+    """The literal as Effect writes it in a string: ``True`` is ``"true"``,
+    ``None`` is ``"null"``, numbers as JavaScript prints them."""
+    match value:
+        case bool():
+            return "true" if value else "false"
+        case None:
+            return "null"
+        case str():
+            return value
+        case int() | float():
+            return js_number(value)
+
+
+def _duration(text: str) -> Result[Seconds, Issue]:
+    parsed = parse_duration_text(text)
+    return (
+        Err(InvalidValue({"message": "Expected a valid Duration string"}))
+        if parsed is None
+        else Ok(parsed)
+    )
+
+
+duration = Scalar(_STRING, _duration)
+
+
+def _byte_size(text: str) -> Result[ByteSize, Issue]:
+    size = byte_size_from_string(text)
+    return (
+        Err(InvalidValue({"message": "Expected a valid ByteSize string"}))
+        if size is None
+        else Ok(size)
+    )
+
+
+byte_size = Scalar(_STRING, _byte_size)
+
+
+def _date_time(text: str) -> Result[datetime, Issue]:
+    parsed = js_date.parse_input(text)
+    if parsed is None:
+        return Err(InvalidValue({"message": "Expected a valid Date"}))
+    return Ok(parsed)
+
+
+date_time = Scalar(_STRING, _date_time)
+
+_INVALID_URL = InvalidValue({"message": "Expected a valid URL string"})
+
+
+def _url(text: str) -> Result[Url, Issue]:
+    url = parse_url(text)
+    return Err(_INVALID_URL) if url is None else Ok(url)
+
+
+url = Scalar(_STRING, _url)
+
+
+def _mapped[A, B](scalar: Scalar[A], f: Callable[[A], B]) -> Scalar[B]:
+    decode = scalar.decode
+    return Scalar(scalar.missing, lambda text: decode(text).map(f))
+
+
+redacted = _mapped(string, Redacted)