setcookie 0.2.0__py3-none-any.whl

setcookie/__init__.py

@@ -0,0 +1,24 @@
+"""Typed Set-Cookie codec: parse, validate and build one Set-Cookie line, and store it."""
+
+from __future__ import annotations
+
+from ._build import build, expire
+from ._dates import parse_date
+from ._errors import CookieError
+from ._model import Cookie, SameSite, StoredCookie
+from ._parse import parse
+from ._store import receive
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "Cookie",
+    "CookieError",
+    "SameSite",
+    "StoredCookie",
+    "build",
+    "expire",
+    "parse",
+    "parse_date",
+    "receive",
+]

setcookie/__main__.py

@@ -0,0 +1,9 @@
+"""Run the command line with ``python -m setcookie``."""
+
+from __future__ import annotations
+
+import sys
+
+from ._cli import main
+
+sys.exit(main())

setcookie/_build.py

@@ -0,0 +1,171 @@
+"""Build one Set-Cookie line that follows the server grammar of section 4.1.1."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from datetime import datetime, timezone
+from typing import NoReturn
+
+from ._chars import (
+    MAX_ATTRIBUTE_OCTETS,
+    MAX_PAIR_OCTETS,
+    WSP,
+    ascii_lower,
+    is_av_text,
+    is_cookie_value,
+    is_hostname,
+    is_token,
+    octets,
+)
+from ._dates import format_http_date
+from ._errors import CookieError
+from ._model import SameSite
+from ._rules import prefix_problem, secure_problem
+from ._strict import check_strict
+
+_SAME_SITE_VALUES = ("Lax", "Strict", "None")
+_KNOWN = frozenset(
+    {"expires", "max-age", "domain", "path", "secure", "httponly", "samesite", "partitioned"}
+)
+_EPOCH = datetime(1970, 1, 1, tzinfo=timezone.utc)
+_BIG = 10**MAX_ATTRIBUTE_OCTETS  # more digits than an attribute value may hold
+
+
+def build(
+    name: str,
+    value: str,
+    *,
+    expires: datetime | None = None,
+    max_age: int | None = None,
+    domain: str | None = None,
+    path: str | None = "/",
+    secure: bool = False,
+    http_only: bool = False,
+    same_site: SameSite | None = None,
+    partitioned: bool = False,
+    extensions: Iterable[tuple[str, str | None]] = (),
+) -> str:
+    """Assemble one Set-Cookie line; raise CookieError for anything unsafe or ignored.
+
+    Every part is checked on its own before it is joined, so no argument can end the
+    line, start another attribute or inject a header. Prefix rules, the Secure
+    requirement of SameSite=None and Partitioned, and the size limits are enforced.
+    A naive ``expires`` is taken to be UTC, not local time.
+    """
+    _check_pair(name, value)
+    parts = [f"{name}={value}"]
+    if expires is not None:
+        parts.append(f"Expires={_expires(expires)}")
+    if max_age is not None:
+        if isinstance(max_age, bool) or not isinstance(max_age, int) or not 0 < max_age < _BIG:
+            _fail("max_age must be a positive int below 10**1024; use expire() to delete")
+        parts.append(f"Max-Age={max_age}")
+    if domain is not None:
+        if not isinstance(domain, str) or not is_hostname(domain):
+            _fail(f"domain {domain!r} is not a host name (no leading dot, no port)")
+        parts.append(f"Domain={domain}")
+    if path is not None:
+        if not isinstance(path, str) or (path and not path.startswith("/")):
+            _fail(f"path {path!r} must be empty or start with '/'")
+        if path != path.strip(WSP):
+            _fail(f"path {path!r} has leading or trailing whitespace")
+        _check_attribute_value("path", path)
+        parts.append(f"Path={path}")
+    parts.extend(flag for flag, on in (("Secure", secure), ("HttpOnly", http_only)) if on)
+    if same_site is not None:
+        if same_site not in _SAME_SITE_VALUES:
+            _fail(f"same_site must be one of {_SAME_SITE_VALUES}, got {same_site!r}")
+        parts.append(f"SameSite={same_site}")
+    if partitioned:
+        parts.append("Partitioned")
+    parts.extend(_extension(item) for item in extensions)
+    problem = prefix_problem(
+        name, secure=secure, has_domain=domain is not None, path=path
+    ) or secure_problem(same_site=same_site, partitioned=partitioned, secure=secure)
+    if problem:
+        _fail(problem)
+    header = "; ".join(parts)
+    check_strict(header)
+    return header
+
+
+def expire(
+    name: str,
+    *,
+    domain: str | None = None,
+    path: str | None = "/",
+    secure: bool = False,
+    http_only: bool = False,
+    same_site: SameSite | None = None,
+    partitioned: bool = False,
+) -> str:
+    """Build a line that deletes the cookie: an empty value and an Expires in 1970.
+
+    Pass the same name, Domain and Path the cookie was set with; prefixed names still
+    need their Secure, Domain and Path rules.
+    """
+    return build(
+        name,
+        "",
+        expires=_EPOCH,
+        domain=domain,
+        path=path,
+        secure=secure,
+        http_only=http_only,
+        same_site=same_site,
+        partitioned=partitioned,
+    )
+
+
+def _check_pair(name: str, value: str) -> None:
+    if not isinstance(name, str) or not is_token(name):
+        _fail(f"cookie name {name!r} is not an HTTP token")
+    if not isinstance(value, str) or not is_cookie_value(value):
+        _fail(f"cookie value {value!r} has characters outside cookie-octet; encode it first")
+    if octets(name) + octets(value) > MAX_PAIR_OCTETS:
+        _fail("the name and value are longer than 4096 octets together")
+
+
+def _expires(moment: datetime) -> str:
+    if not isinstance(moment, datetime):
+        _fail(f"expires must be a datetime, got {type(moment).__name__}")
+    try:
+        text = format_http_date(moment)
+    except OverflowError:
+        _fail("expires is outside the range of representable UTC dates")
+    if int(text[12:16]) < 1601:
+        _fail("expires before the year 1601 is ignored by user agents")
+    return text
+
+
+def _extension(item: tuple[str, str | None]) -> str:
+    if not isinstance(item, tuple) or len(item) != 2:
+        _fail(f"each extension must be a (name, value) tuple, got {item!r}")
+    key, text = item
+    if (
+        not isinstance(key, str)
+        or not key
+        or key != key.strip(WSP)
+        or "=" in key
+        or not is_av_text(key)
+    ):
+        _fail(f"extension name {key!r} is not a valid attribute name")
+    if ascii_lower(key) in _KNOWN:
+        _fail(f"extension {key!r} would be read as a standard attribute; use its argument")
+    if text is None:
+        return key
+    if not isinstance(text, str) or text != text.strip(WSP):
+        _fail(f"extension value {text!r} must be a str without outer whitespace")
+    _check_attribute_value(key, text)
+    return f"{key}={text}"
+
+
+def _check_attribute_value(label: str, text: str) -> None:
+    if not is_av_text(text):
+        _fail(f"{label} value {text!r} has control characters or ';'")
+    if octets(text) > MAX_ATTRIBUTE_OCTETS:
+        _fail(f"{label} value is longer than 1024 octets")
+
+
+def _fail(reason: str) -> NoReturn:
+    raise CookieError(reason)

setcookie/_chars.py

@@ -0,0 +1,65 @@
+"""Character classes, limits and small text helpers from the cookie grammar."""
+
+from __future__ import annotations
+
+WSP = " \t"
+MAX_PAIR_OCTETS = 4096
+MAX_ATTRIBUTE_OCTETS = 1024
+MAX_AGE_LIMIT = 34560000  # 400 days in seconds, the cap of section 5.5
+
+_ALNUM = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+TCHAR = frozenset("!#$%&'*+-.^_`|~" + _ALNUM)
+# Visible ASCII without DQUOTE, comma, semicolon and backslash.
+COOKIE_OCTET = frozenset(chr(code) for code in range(0x21, 0x7F)) - frozenset('",;\\')
+# Any CHAR except CTLs and semicolon.
+AV_OCTET = frozenset(chr(code) for code in range(0x20, 0x7F)) - frozenset(";")
+_UPPER = str.maketrans("ABCDEFGHIJKLMNOPQRSTUVWXYZ", "abcdefghijklmnopqrstuvwxyz")
+
+
+def has_forbidden_ctl(text: str) -> bool:
+    """True for %x00-08, %x0A-1F or %x7F: control characters other than HTAB."""
+    return any((char < " " and char != "\t") or char == "\x7f" for char in text)
+
+
+def octets(text: str) -> int:
+    """Length in octets once the text is put on the wire as UTF-8."""
+    return len(text.encode("utf-8", "surrogatepass"))
+
+
+def trim(text: str) -> str:
+    """Remove leading and trailing WSP (space and horizontal tab) only."""
+    return text.strip(WSP)
+
+
+def ascii_lower(text: str) -> str:
+    """Lower-case A to Z only, so no Unicode folding can turn a name into a keyword."""
+    return text.translate(_UPPER)
+
+
+def is_token(text: str) -> bool:
+    """True for a non-empty HTTP token (RFC 9110 section 5.6.2)."""
+    return bool(text) and all(char in TCHAR for char in text)
+
+
+def is_cookie_value(text: str) -> bool:
+    """True for *cookie-octet, optionally wrapped in one pair of DQUOTEs."""
+    if len(text) >= 2 and text[0] == '"' == text[-1]:
+        text = text[1:-1]
+    return all(char in COOKIE_OCTET for char in text)
+
+
+def is_av_text(text: str) -> bool:
+    """True when every character is an av-octet: any CHAR except CTLs and ';'."""
+    return all(char in AV_OCTET for char in text)
+
+
+def is_hostname(text: str) -> bool:
+    """True for an RFC 1034 subdomain as relaxed by RFC 1123 (labels may start with a digit)."""
+    if not text or len(text) > 253 or not text.isascii():
+        return False
+    for label in text.split("."):
+        if not 0 < len(label) <= 63 or label[0] == "-" or label[-1] == "-":
+            return False
+        if not all(char.isalnum() or char == "-" for char in label):
+            return False
+    return True

setcookie/_cli.py

@@ -0,0 +1,91 @@
+"""Command line: read Set-Cookie lines and print what they mean as JSON."""
+
+from __future__ import annotations
+
+import argparse
+import dataclasses
+import json
+import re
+import sys
+from collections.abc import Sequence
+from datetime import datetime, timezone
+from typing import Any
+
+from ._errors import CookieError
+from ._parse import parse
+from ._store import receive
+
+_HEADER = re.compile(r"set-cookie[ \t]*:[ \t]*(.*)", re.IGNORECASE | re.DOTALL)
+
+
+def _lines(args: Sequence[str], stdin: str) -> list[str]:
+    """Explicit lines, or stdin; from a header dump only the Set-Cookie fields are kept."""
+    if args:
+        return list(args)
+    raw = [line.rstrip("\r") for line in stdin.split("\n")]
+    present = [line for line in raw if line.strip()]
+    headers = [match[1] for line in raw if (match := _HEADER.fullmatch(line))]
+    # A dump (curl -sI starts with a status line) yields only its Set-Cookie fields, maybe none.
+    if headers or (present and present[0].startswith("HTTP/")):
+        return headers
+    return present
+
+
+def _plain(value: object) -> Any:
+    if isinstance(value, datetime):
+        return value.isoformat()
+    if isinstance(value, tuple):
+        return [_plain(item) for item in value]
+    return value
+
+
+def _fields(record: Any) -> dict[str, Any]:
+    return {field.name: _plain(getattr(record, field.name)) for field in dataclasses.fields(record)}
+
+
+def _report(line: str, options: argparse.Namespace) -> tuple[dict[str, Any], bool]:
+    entry: dict[str, Any] = {"line": line}
+    try:
+        entry["cookie"] = _fields(parse(line, strict=options.strict))
+        if options.url:
+            entry["stored"] = _fields(receive(line, options.url, now=options.now))
+    except CookieError as error:
+        entry["error"] = str(error)
+        return entry, False
+    return entry, True
+
+
+def _moment(text: str) -> datetime:
+    # fromisoformat only reads a trailing "Z" from Python 3.11 on.
+    moment = datetime.fromisoformat(text[:-1] + "+00:00" if text.endswith("Z") else text)
+    return moment if moment.tzinfo else moment.replace(tzinfo=timezone.utc)
+
+
+_moment.__name__ = "ISO time"
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """Entry point of the ``setcookie`` command; returns the exit status."""
+    parser = argparse.ArgumentParser(
+        prog="setcookie",
+        description="Parse Set-Cookie lines (arguments, or stdin such as a curl -sI dump).",
+    )
+    parser.add_argument("lines", nargs="*", help="Set-Cookie values; read stdin when absent")
+    parser.add_argument("--strict", action="store_true", help="check the server grammar")
+    parser.add_argument("--url", help="show what a user agent stores for this request URL")
+    parser.add_argument(
+        "--now", type=_moment, default=None, help="ISO time for --url (default: the clock)"
+    )
+    options = parser.parse_args(argv)
+    if options.now is None:
+        options.now = datetime.now(timezone.utc)
+    lines = _lines(options.lines, "" if options.lines else sys.stdin.read())
+    if not lines:
+        parser.error("no Set-Cookie line given")
+    reports = [_report(line, options) for line in lines]
+    json.dump([entry for entry, _ in reports], sys.stdout, indent=2)
+    sys.stdout.write("\n")
+    failures = [entry["error"] for entry, ok in reports if not ok]
+    for reason in failures:
+        print(f"setcookie: {reason}", file=sys.stderr)
+    return 1 if failures else 0

setcookie/_dates.py

@@ -0,0 +1,121 @@
+"""Cookie dates: the parsing algorithm of section 5.1.1 and IMF-fixdate output."""
+
+from __future__ import annotations
+
+import re
+from datetime import datetime, timezone
+
+_DAYS = ("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun")
+_MONTHS = (
+    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+)  # fmt: skip
+_LOWER_MONTHS = tuple(month.lower() for month in _MONTHS)
+
+# The productions of section 5.1.1; [0-9] rather than \d so no non-ASCII digit matches.
+_TIME = re.compile(r"([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2})(?:[^0-9].*)?", re.DOTALL)
+_DAY = re.compile(r"([0-9]{1,2})(?:[^0-9].*)?", re.DOTALL)
+_YEAR = re.compile(r"([0-9]{2,4})(?:[^0-9].*)?", re.DOTALL)
+_FIXDATE = re.compile(
+    r"(Mon|Tue|Wed|Thu|Fri|Sat|Sun), ([0-9]{2}) "
+    r"(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ([0-9]{4}) "
+    r"([0-9]{2}):([0-9]{2}):([0-9]{2}) GMT"
+)
+
+
+def _is_delimiter(char: str) -> bool:
+    code = ord(char)
+    return (
+        code == 0x09
+        or 0x20 <= code <= 0x2F
+        or 0x3B <= code <= 0x40
+        or 0x5B <= code <= 0x60
+        or 0x7B <= code <= 0x7E
+    )
+
+
+def _tokens(text: str) -> list[str]:
+    tokens: list[str] = []
+    current: list[str] = []
+    for char in text:
+        if _is_delimiter(char):
+            if current:
+                tokens.append("".join(current))
+                current = []
+        else:
+            current.append(char)
+    if current:
+        tokens.append("".join(current))
+    return tokens
+
+
+def parse_date(text: str) -> datetime | None:
+    """Parse a cookie-date with the algorithm of section 5.1.1; None when it fails.
+
+    The result is an aware datetime in UTC. Zone names and offsets are not read: the
+    algorithm treats every time as UTC.
+    """
+    time: tuple[int, int, int] | None = None
+    day: int | None = None
+    month: int | None = None
+    year: int | None = None
+    for token in _tokens(text):
+        if time is None and (match := _TIME.fullmatch(token)):
+            time = (int(match[1]), int(match[2]), int(match[3]))
+        elif day is None and (match := _DAY.fullmatch(token)):
+            day = int(match[1])
+        elif month is None and token[:3].isascii() and token[:3].lower() in _LOWER_MONTHS:
+            month = _LOWER_MONTHS.index(token[:3].lower()) + 1
+        elif year is None and (match := _YEAR.fullmatch(token)):
+            year = int(match[1])
+    if time is None or day is None or month is None or year is None:
+        return None
+    if 70 <= year <= 99:
+        year += 1900
+    elif 0 <= year <= 69:
+        year += 2000
+    hour, minute, second = time
+    if not 1 <= day <= 31 or year < 1601 or hour > 23 or minute > 59 or second > 59:
+        return None
+    try:
+        return datetime(year, month, day, hour, minute, second, tzinfo=timezone.utc)
+    except ValueError:
+        return None
+
+
+def parse_fixdate(text: str) -> datetime | None:
+    """Parse an exact IMF-fixdate (RFC 9110 section 5.6.7); None for anything else.
+
+    Only the grammar and the calendar are checked, not that the day name fits the date:
+    the draft's own example in section 3.1 pairs "Wed" with 9 June 2026, a Tuesday.
+    """
+    match = _FIXDATE.fullmatch(text)
+    if match is None:
+        return None
+    try:
+        moment = datetime(
+            int(match[4]),
+            _MONTHS.index(match[3]) + 1,
+            int(match[2]),
+            int(match[5]),
+            int(match[6]),
+            int(match[7]),
+            tzinfo=timezone.utc,
+        )
+    except ValueError:
+        return None
+    return moment
+
+
+def format_http_date(value: datetime) -> str:
+    """Render a datetime as an IMF-fixdate in GMT, regardless of locale.
+
+    A naive datetime is taken to be UTC.
+    """
+    moment = value if value.tzinfo else value.replace(tzinfo=timezone.utc)
+    moment = moment.astimezone(timezone.utc)
+    return (
+        f"{_DAYS[moment.weekday()]}, "
+        f"{moment.day:02d} {_MONTHS[moment.month - 1]} {moment.year:04d} "
+        f"{moment.hour:02d}:{moment.minute:02d}:{moment.second:02d} GMT"
+    )

setcookie/_errors.py

@@ -0,0 +1,7 @@
+"""Errors raised by the codec."""
+
+from __future__ import annotations
+
+
+class CookieError(ValueError):
+    """A Set-Cookie line a user agent ignores, breaks the grammar, or cannot be built safely."""

setcookie/_match.py

@@ -0,0 +1,85 @@
+"""Request URLs, default-path, domain-match and path-match (sections 5.1.2 to 5.1.4)."""
+
+from __future__ import annotations
+
+import ipaddress
+from typing import TYPE_CHECKING, NamedTuple
+from urllib.parse import urlsplit
+
+from ._errors import CookieError
+
+if TYPE_CHECKING:
+    from ._model import StoredCookie
+
+_SECURE_SCHEMES = frozenset({"https", "wss"})
+
+
+class Request(NamedTuple):
+    host: str
+    path: str
+    secure: bool
+
+
+def request_of(url: str) -> Request:
+    """Split a request URL into its canonical host, path and whether it is secure.
+
+    Non-ASCII hosts go through the standard library's IDNA 2003 codec, which maps a few
+    characters (such as sharp s) differently from the IDNA 2008 rules of section 5.1.2.
+    """
+    try:
+        parts = urlsplit(url)
+        host = parts.hostname
+    except ValueError as error:
+        raise CookieError(f"the request URL is malformed: {url!r}") from error
+    if not host:
+        raise CookieError(f"the request URL has no host: {url!r}")
+    try:
+        canonical = host.rstrip(".").encode("idna").decode("ascii").lower()
+        # A label that claims to be an A-label must decode (section 5.1.2 step 4).
+        canonical.encode("ascii").decode("idna")
+    except UnicodeError:
+        raise CookieError(f"the request host cannot be canonicalized: {host!r}") from None
+    return Request(canonical, parts.path, parts.scheme.lower() in _SECURE_SCHEMES)
+
+
+def is_ip_address(host: str) -> bool:
+    try:
+        ipaddress.ip_address(host)
+    except ValueError:
+        return False
+    return True
+
+
+def domain_match(host: str, domain: str) -> bool:
+    """Section 5.1.3: identical, or a host name ending in '.' + domain."""
+    if host == domain:
+        return True
+    return host.endswith("." + domain) and not is_ip_address(host)
+
+
+def default_path(uri_path: str) -> str:
+    """Section 5.1.4: the directory of the request path, '/' when there is none."""
+    if not uri_path.startswith("/") or uri_path.count("/") <= 1:
+        return "/"
+    return uri_path[: uri_path.rindex("/")]
+
+
+def path_match(request_path: str, cookie_path: str) -> bool:
+    """Section 5.1.4: identical, or a prefix that ends at a '/' boundary."""
+    if request_path == cookie_path:
+        return True
+    if not request_path.startswith(cookie_path):
+        return False
+    return cookie_path.endswith("/") or request_path[len(cookie_path)] == "/"
+
+
+def request_matches(cookie: StoredCookie, url: str) -> bool:
+    request = request_of(url)
+    if cookie.host_only:
+        if request.host != cookie.domain:
+            return False
+    elif not domain_match(request.host, cookie.domain):
+        return False
+    if not path_match(request.path or "/", cookie.path):
+        return False
+    return request.secure or not cookie.secure

setcookie/_model.py

@@ -0,0 +1,84 @@
+"""Typed representations of a Set-Cookie line and of a cookie a user agent stores."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Literal
+
+SameSite = Literal["Lax", "Strict", "None"]
+
+
+@dataclass(frozen=True)
+class Cookie:
+    """One Set-Cookie line decomposed into its name, value and attributes.
+
+    When an attribute repeats, the last one wins as in a user agent: an unreadable Expires
+    or Max-Age is skipped, while an empty Domain or an unknown SameSite value resets the
+    earlier one. ``path`` is ``""`` when a Path attribute was given but was empty or
+    relative, which tells the user agent to use the default path. ``extensions`` keeps
+    unrecognised attributes in order as ``(name, value)``, with ``None`` for an attribute
+    that had no ``=``.
+    """
+
+    name: str
+    value: str
+    expires: datetime | None = None
+    max_age: int | None = None
+    domain: str | None = None
+    path: str | None = None
+    secure: bool = False
+    http_only: bool = False
+    same_site: SameSite | None = None
+    partitioned: bool = False
+    extensions: tuple[tuple[str, str | None], ...] = ()
+
+    def header(self) -> str:
+        """Render this cookie with `build`; raise CookieError when it breaks the grammar."""
+        from ._build import build
+
+        return build(
+            self.name,
+            self.value,
+            expires=self.expires,
+            max_age=self.max_age,
+            domain=self.domain,
+            path=self.path,
+            secure=self.secure,
+            http_only=self.http_only,
+            same_site=self.same_site,
+            partitioned=self.partitioned,
+            extensions=self.extensions,
+        )
+
+
+@dataclass(frozen=True)
+class StoredCookie:
+    """A cookie as the storage model of section 5.7 records it.
+
+    ``domain`` is the cookie's domain after matching against the request host;
+    ``host_only`` is true when no Domain attribute widened it. ``expiry`` is ``None`` for
+    a session cookie (``persistent`` false).
+    """
+
+    name: str
+    value: str
+    domain: str
+    path: str
+    host_only: bool
+    secure: bool
+    http_only: bool
+    same_site: SameSite | None
+    partitioned: bool
+    persistent: bool
+    expiry: datetime | None
+
+    def is_expired(self, now: datetime) -> bool:
+        """True when the expiry time has been reached at ``now`` (an aware datetime)."""
+        return self.expiry is not None and self.expiry <= now
+
+    def matches(self, url: str) -> bool:
+        """True when a request to ``url`` would carry this cookie (domain, path, secure)."""
+        from ._match import request_matches
+
+        return request_matches(self, url)

setcookie/_parse.py

@@ -0,0 +1,103 @@
+"""Parse one Set-Cookie line with the user agent algorithm of section 5.6."""
+
+from __future__ import annotations
+
+from datetime import datetime
+
+from ._chars import (
+    MAX_ATTRIBUTE_OCTETS,
+    MAX_PAIR_OCTETS,
+    ascii_lower,
+    has_forbidden_ctl,
+    octets,
+    trim,
+)
+from ._dates import parse_date
+from ._errors import CookieError
+from ._model import Cookie, SameSite
+from ._strict import check_strict
+
+_SAME_SITE: dict[str, SameSite] = {"lax": "Lax", "strict": "Strict", "none": "None"}
+
+
+def parse(line: str, *, strict: bool = False) -> Cookie:
+    """Decode one Set-Cookie line the way a user agent reads it.
+
+    Raise CookieError when a user agent ignores the whole line: a control character
+    other than HTAB, an empty name with an empty value, or a name and value longer than
+    4096 octets together. Unknown or malformed attributes are skipped, never rejected.
+    With ``strict=True`` the line must also follow the server grammar of section 4.1.1,
+    and CookieError names the first rule it breaks.
+    """
+    if not isinstance(line, str):
+        raise TypeError(f"expected str, got {type(line).__name__}")
+    if strict:
+        check_strict(line)
+    if has_forbidden_ctl(line):
+        raise CookieError(f"control character in the line: {line!r}")
+    pair, separator, attributes = line.partition(";")
+    if "=" in pair:
+        raw_name, _, raw_value = pair.partition("=")
+    else:
+        raw_name, raw_value = "", pair
+    name, value = trim(raw_name), trim(raw_value)
+    if octets(name) + octets(value) > MAX_PAIR_OCTETS:
+        raise CookieError("the name and value are longer than 4096 octets together")
+    if not name and not value:
+        raise CookieError(f"empty name and empty value: {line!r}")
+    return _read_attributes(name, value, attributes.split(";") if separator else [])
+
+
+def _read_attributes(name: str, value: str, avs: list[str]) -> Cookie:
+    expires: datetime | None = None
+    max_age: int | None = None
+    domain: str | None = None
+    path: str | None = None
+    secure = http_only = partitioned = False
+    same_site: SameSite | None = None
+    extensions: list[tuple[str, str | None]] = []
+    for av in avs:
+        raw_key, equals, raw = av.partition("=")
+        key, raw = trim(raw_key), trim(raw)
+        if not key or octets(raw) > MAX_ATTRIBUTE_OCTETS:
+            continue
+        keyword = ascii_lower(key)
+        if keyword == "expires":
+            expires = parse_date(raw) or expires
+        elif keyword == "max-age":
+            max_age = _delta_seconds(raw, max_age)
+        elif keyword == "domain":
+            domain = ascii_lower(raw[1:] if raw.startswith(".") else raw) or None
+        elif keyword == "path":
+            path = raw if raw.startswith("/") else ""
+        elif keyword == "secure":
+            secure = True
+        elif keyword == "httponly":
+            http_only = True
+        elif keyword == "partitioned":
+            partitioned = True
+        elif keyword == "samesite":
+            same_site = _SAME_SITE.get(ascii_lower(raw))
+        else:
+            extensions.append((key, raw if equals else None))
+    return Cookie(
+        name=name,
+        value=value,
+        expires=expires,
+        max_age=max_age,
+        domain=domain,
+        path=path,
+        secure=secure,
+        http_only=http_only,
+        same_site=same_site,
+        partitioned=partitioned,
+        extensions=tuple(extensions),
+    )
+
+
+def _delta_seconds(raw: str, previous: int | None) -> int | None:
+    """Section 5.6.2: DIGITs with an optional leading '-'; anything else keeps ``previous``."""
+    digits = raw[1:] if raw.startswith("-") else raw
+    if not digits or not all("0" <= char <= "9" for char in digits):
+        return previous
+    return int(raw)

setcookie/_rules.py

@@ -0,0 +1,34 @@
+"""Rules shared by the builder, strict mode and the storage model."""
+
+from __future__ import annotations
+
+from ._chars import ascii_lower
+
+
+def prefix_problem(name: str, *, secure: bool, has_domain: bool, path: str | None) -> str | None:
+    """Explain how a name prefix rule (section 5.7 steps 20 and 21) is broken, or None.
+
+    Prefixes are matched case-insensitively, as user agents do (section 5.4).
+    """
+    folded = ascii_lower(name)
+    if folded.startswith("__secure-") and not secure:
+        return "a __Secure- cookie needs the Secure attribute"
+    if folded.startswith("__host-"):
+        if not secure:
+            return "a __Host- cookie needs the Secure attribute"
+        if has_domain:
+            return "a __Host- cookie must not have a Domain attribute"
+        if path != "/":
+            return "a __Host- cookie needs Path=/"
+    return None
+
+
+def secure_problem(*, same_site: str | None, partitioned: bool, secure: bool) -> str | None:
+    """Explain why SameSite=None or Partitioned is refused without Secure, or None."""
+    if secure:
+        return None
+    if same_site == "None":
+        return "SameSite=None needs the Secure attribute"
+    if partitioned:
+        return "Partitioned needs the Secure attribute"
+    return None

setcookie/_store.py

@@ -0,0 +1,97 @@
+"""The storage model of section 5.7 for one received cookie."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from datetime import datetime, timedelta, timezone
+
+from ._chars import MAX_AGE_LIMIT, ascii_lower
+from ._errors import CookieError
+from ._match import default_path, domain_match, request_of
+from ._model import Cookie, StoredCookie
+from ._parse import parse
+from ._rules import prefix_problem, secure_problem
+
+_EARLIEST = datetime.min.replace(tzinfo=timezone.utc)
+_LIMIT = timedelta(seconds=MAX_AGE_LIMIT)
+
+
+def receive(
+    line: str,
+    url: str,
+    *,
+    now: datetime,
+    cross_site: bool = False,
+    is_public_suffix: Callable[[str], bool] | None = None,
+) -> StoredCookie:
+    """Run the storage model for a Set-Cookie line received from ``url`` at ``now``.
+
+    Return the cookie a user agent would store, or raise CookieError naming the rule that
+    makes it ignore the line. ``now`` must be an aware datetime. ``cross_site`` marks a
+    cross-site request that is not a top-level navigation, where only SameSite=None
+    cookies may be set. ``is_public_suffix`` enables the public suffix check of step 9.
+    Rules that need the existing cookie store (steps 16, 23 and 24) are left to the caller.
+    """
+    if now.tzinfo is None:
+        raise ValueError("now must be an aware datetime")
+    cookie = parse(line)
+    request = request_of(url)
+    domain, host_only = _domain(cookie, request.host, is_public_suffix)
+    path = cookie.path or default_path(request.path)
+    if cookie.secure and not request.secure:
+        raise CookieError("a Secure cookie cannot be set from an insecure URL")
+    if cross_site and cookie.same_site != "None":
+        raise CookieError("a cross-site request can only set a SameSite=None cookie")
+    problem = secure_problem(
+        same_site=cookie.same_site, partitioned=cookie.partitioned, secure=cookie.secure
+    ) or prefix_problem(
+        cookie.name,
+        secure=cookie.secure,
+        has_domain=not host_only,
+        path=path if cookie.path is not None else None,
+    )
+    if problem:
+        raise CookieError(problem)
+    if not cookie.name and ascii_lower(cookie.value).startswith(("__secure-", "__host-")):
+        raise CookieError("a nameless cookie cannot carry a prefixed value")
+    expiry = _expiry(cookie, now)
+    return StoredCookie(
+        name=cookie.name,
+        value=cookie.value,
+        domain=domain,
+        path=path,
+        host_only=host_only,
+        secure=cookie.secure,
+        http_only=cookie.http_only,
+        same_site=cookie.same_site,
+        partitioned=cookie.partitioned,
+        persistent=expiry is not None,
+        expiry=expiry,
+    )
+
+
+def _domain(
+    cookie: Cookie, host: str, is_public_suffix: Callable[[str], bool] | None
+) -> tuple[str, bool]:
+    attribute = cookie.domain or ""
+    if not attribute.isascii():
+        raise CookieError(f"the Domain attribute {attribute!r} is not ASCII")
+    if attribute and is_public_suffix is not None and is_public_suffix(attribute):
+        if attribute != host:
+            raise CookieError(f"the Domain attribute {attribute!r} is a public suffix")
+        attribute = ""
+    if not attribute:
+        return host, True
+    if not domain_match(host, attribute):
+        raise CookieError(f"the host {host!r} does not domain-match {attribute!r}")
+    return attribute, False
+
+
+def _expiry(cookie: Cookie, now: datetime) -> datetime | None:
+    if cookie.max_age is not None:
+        if cookie.max_age <= 0:
+            return _EARLIEST
+        return now + timedelta(seconds=min(cookie.max_age, MAX_AGE_LIMIT))
+    if cookie.expires is not None:
+        return min(cookie.expires, now + _LIMIT)
+    return None

setcookie/_strict.py

@@ -0,0 +1,101 @@
+"""Strict mode: check a Set-Cookie line against the server grammar of section 4.1.1."""
+
+from __future__ import annotations
+
+import re
+from typing import NoReturn
+
+from ._chars import (
+    MAX_ATTRIBUTE_OCTETS,
+    MAX_PAIR_OCTETS,
+    WSP,
+    ascii_lower,
+    is_av_text,
+    is_cookie_value,
+    is_hostname,
+    is_token,
+    octets,
+)
+from ._dates import parse_fixdate
+from ._errors import CookieError
+from ._rules import prefix_problem, secure_problem
+
+_FLAGS = frozenset({"secure", "httponly", "partitioned"})
+_VALUED = frozenset({"expires", "max-age", "domain", "path", "samesite"})
+_MAX_AGE = re.compile(r"[1-9][0-9]*")
+_SAME_SITE = frozenset({"strict", "lax", "none"})
+
+
+def check_strict(line: str) -> None:
+    """Raise CookieError naming the first rule of the server grammar the line breaks."""
+    if line != line.rstrip(WSP):
+        _fail("trailing whitespace")
+    pair, *avs = line.split(";")
+    raw_name, equals, raw_value = pair.partition("=")
+    if not equals:
+        _fail("the cookie-pair has no '='")
+    name, value = raw_name.strip(WSP), raw_value.strip(WSP)
+    if not is_token(name):
+        _fail(f"the cookie-name {name!r} is not a token")
+    if not is_cookie_value(value):
+        _fail(f"the cookie-value {value!r} has characters outside cookie-octet")
+    if octets(name) + octets(value) > MAX_PAIR_OCTETS:
+        _fail("the name and value are longer than 4096 octets together")
+    seen: dict[str, str] = {}
+    for av in avs:
+        keyword, text = _attribute(av.strip(WSP))
+        if keyword in seen:
+            _fail(f"the {keyword} attribute appears twice")
+        seen[keyword] = text
+    _check_semantics(name, seen)
+
+
+def _attribute(av: str) -> tuple[str, str]:
+    """Validate one cookie-av; return its lower-cased name and its value."""
+    if not av:
+        _fail("empty attribute")
+    raw_key, equals, raw = av.partition("=")
+    keyword, text = ascii_lower(raw_key.strip(WSP)), raw.strip(WSP)
+    if octets(text) > MAX_ATTRIBUTE_OCTETS:
+        _fail(f"the {raw_key.strip(WSP)} value is longer than 1024 octets")
+    if keyword in _FLAGS:
+        if equals:
+            _fail(f"the {keyword} attribute takes no value")
+    elif keyword in _VALUED:
+        if not equals:
+            _fail(f"the {keyword} attribute needs a value")
+        _check_value(keyword, text)
+    elif not is_av_text(av):
+        _fail(f"the attribute {av!r} has characters outside av-octet")
+    return keyword, text
+
+
+def _check_value(keyword: str, text: str) -> None:
+    if keyword == "expires" and parse_fixdate(text) is None:
+        _fail(f"Expires={text!r} is not an IMF-fixdate")
+    if keyword == "max-age" and not _MAX_AGE.fullmatch(text):
+        _fail(f"Max-Age={text!r} is not a non-zero-digit followed by DIGITs")
+    if keyword == "domain" and not is_hostname(text):
+        _fail(f"Domain={text!r} is not a host name")
+    if keyword == "path" and not is_av_text(text):
+        _fail(f"Path={text!r} has characters outside av-octet")
+    if keyword == "samesite" and ascii_lower(text) not in _SAME_SITE:
+        _fail(f"SameSite={text!r} is not Strict, Lax or None")
+
+
+def _check_semantics(name: str, attributes: dict[str, str]) -> None:
+    secure = "secure" in attributes
+    same_site = attributes.get("samesite")
+    problem = prefix_problem(
+        name, secure=secure, has_domain="domain" in attributes, path=attributes.get("path")
+    ) or secure_problem(
+        same_site="None" if same_site is not None and ascii_lower(same_site) == "none" else None,
+        partitioned="partitioned" in attributes,
+        secure=secure,
+    )
+    if problem:
+        _fail(problem)
+
+
+def _fail(reason: str) -> NoReturn:
+    raise CookieError(f"strict: {reason}")

setcookie-0.2.0.dist-info/METADATA

@@ -0,0 +1,215 @@
+Metadata-Version: 2.5
+Name: setcookie
+Version: 0.2.0
+Summary: Parse, validate and safely build HTTP Set-Cookie headers, typed and zero-dependency, per RFC 6265bis
+Project-URL: Homepage, https://lianes8studio.com
+Project-URL: Repository, https://github.com/JaviLianes8/setcookie
+Project-URL: Issues, https://github.com/JaviLianes8/setcookie/issues
+Project-URL: Changelog, https://github.com/JaviLianes8/setcookie/blob/main/CHANGELOG.md
+Project-URL: LinkedIn, https://www.linkedin.com/in/jlianes/
+Project-URL: Funding, https://buymeacoffee.com/jlianesglrs
+Author-email: Javier Lianes <javier@lianes8studio.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: chips,cookie,headers,http,partitioned,rfc6265,rfc6265bis,samesite,set-cookie
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: Session
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# setcookie
+
+Typed Set-Cookie codec for Python: parse one Set-Cookie line the way browsers do, check
+it against the server grammar, build lines that cannot inject headers or break prefix
+rules, and see what a user agent would store. Zero dependencies.
+
+It follows the current cookie specification, draft-ietf-httpbis-rfc6265bis (revision 22,
+the successor of RFC 6265), plus the Partitioned attribute, and is checked against the
+web-platform-tests cookie parser cases.
+
+## Install
+
+```
+pip install setcookie
+```
+
+## Build a header
+
+```python
+from setcookie import build, expire
+
+print(build("sid", "a1b2c3", max_age=3600, secure=True, http_only=True, same_site="Lax"))
+# sid=a1b2c3; Max-Age=3600; Path=/; Secure; HttpOnly; SameSite=Lax
+print(build("__Host-session", "x9", secure=True, partitioned=True, same_site="None"))
+# __Host-session=x9; Path=/; Secure; SameSite=None; Partitioned
+print(expire("sid"))
+# sid=; Expires=Thu, 01 Jan 1970 00:00:00 GMT; Path=/
+```
+
+Every argument is checked on its own before it is joined, and anything a user agent
+would drop or misread raises `CookieError` (a `ValueError`):
+
+```python
+from setcookie import CookieError, build
+
+for name, value, options in [
+    ("sid", "a\r\nSet-Cookie: admin=1", {}),
+    ("sid", "abc", {"domain": "example.com; Secure"}),
+    ("__Host-sid", "abc", {"secure": True, "domain": "example.com"}),
+    ("sid", "abc", {"same_site": "None"}),
+]:
+    try:
+        build(name, value, **options)
+    except CookieError as error:
+        print(error)
+# cookie value 'a\r\nSet-Cookie: admin=1' has characters outside cookie-octet; encode it first
+# domain 'example.com; Secure' is not a host name (no leading dot, no port)
+# a __Host- cookie must not have a Domain attribute
+# SameSite=None needs the Secure attribute
+```
+
+Names must be HTTP tokens and values cookie-octets (encode arbitrary data, for example
+with Base64). `max_age` must be a positive int: the grammar has no `Max-Age=0`, so use
+`expire` to delete a cookie. `expires` is written as an IMF-fixdate in GMT whatever the
+locale or time zone of the datetime; a naive datetime is taken to be UTC, not local time.
+
+## Parse a header
+
+`parse` runs the user agent algorithm: whitespace is trimmed, the last attribute of each
+kind wins, malformed attributes are skipped, dates are read with the cookie date
+algorithm, and unknown attributes are kept.
+
+```python
+from setcookie import parse
+
+cookie = parse(
+    "sid=abc; expires=Fri Jan 01 2038 00:00:00 GMT; Domain=.Example.com; "
+    "Max-Age=+5; samesite=lax; Priority=High"
+)
+print(cookie.expires, cookie.domain, cookie.max_age, cookie.same_site)
+# 2038-01-01 00:00:00+00:00 example.com None Lax
+print(cookie.extensions)
+# (('Priority', 'High'),)
+print(parse("nameless").name == "", parse("nameless").value)
+# True nameless
+```
+
+A line a user agent ignores entirely (a control character, an empty name and value, a
+name and value over 4096 octets) raises `CookieError`. With `strict=True` the line must
+also follow the server grammar, and the error names the rule:
+
+```python
+from setcookie import CookieError, parse
+
+for line in ["sid=a b", "sid=abc; Max-Age=0", "__Secure-id=1", "sid=abc; Path=/; path=/x"]:
+    try:
+        parse(line, strict=True)
+    except CookieError as error:
+        print(error)
+# strict: the cookie-value 'a b' has characters outside cookie-octet
+# strict: Max-Age='0' is not a non-zero-digit followed by DIGITs
+# strict: a __Secure- cookie needs the Secure attribute
+# strict: the path attribute appears twice
+```
+
+## What a browser stores
+
+`receive` runs the storage model for one line received from a URL. It returns a
+`StoredCookie` with the resolved domain, path and expiry, or raises `CookieError` with
+the rule that makes a user agent ignore the line.
+
+```python
+from datetime import datetime, timezone
+
+from setcookie import CookieError, receive
+
+now = datetime(2026, 10, 13, tzinfo=timezone.utc)
+stored = receive(
+    "sid=1; Domain=example.com; Max-Age=999999999", "https://www.example.com/app/login", now=now
+)
+print(stored.domain, stored.host_only, stored.path, stored.expiry)
+# example.com False /app 2027-11-17 00:00:00+00:00
+print(
+    stored.matches("https://shop.example.com/app/cart"), stored.matches("https://example.org/app")
+)
+# True False
+try:
+    receive("sid=1; Secure", "http://www.example.com/", now=now)
+except CookieError as error:
+    print(error)
+# a Secure cookie cannot be set from an insecure URL
+```
+
+Expiry follows Max-Age over Expires and is capped at 400 days. Pass
+`is_public_suffix` to reject domains such as `co.uk`, and `cross_site=True` for a
+cross-site request that is not a top-level navigation. Rules that need the rest of the
+cookie store (overwriting, eviction, secure cookie shadowing) are left to the caller.
+Non-ASCII hosts are converted with the standard library's IDNA 2003 codec, which differs
+from IDNA 2008 for a few characters.
+
+## Command line
+
+```
+$ curl -sI https://example.com | setcookie --strict
+$ setcookie --url https://www.example.com/app "sid=1; Domain=example.com"
+```
+
+`setcookie` reads lines from its arguments or from stdin (from a header dump, which starts
+with an `HTTP/` status line, only the Set-Cookie fields are used) and prints JSON.
+`--strict` checks the server grammar, `--url` adds what a user agent would store, `--now`
+fixes the clock. The exit status is 1 when any line is refused. `python -m setcookie`
+works too.
+
+## API
+
+| Name | What it does |
+| --- | --- |
+| `build(name, value, *, expires, max_age, domain, path="/", secure, http_only, same_site, partitioned, extensions)` | One safe Set-Cookie line |
+| `expire(name, *, domain, path="/", secure, ...)` | A line that deletes the cookie |
+| `parse(line, *, strict=False)` | A frozen `Cookie`, read the way user agents read it |
+| `receive(line, url, *, now, cross_site=False, is_public_suffix=None)` | The `StoredCookie` a user agent keeps |
+| `parse_date(text)` | The cookie date algorithm, an aware UTC datetime or `None` |
+| `Cookie` | Name, value, attributes, `extensions`, and `header()` to render it again |
+| `StoredCookie` | Domain, path, flags, expiry, `is_expired(now)` and `matches(url)` |
+| `SameSite` | `Literal["Lax", "Strict", "None"]` |
+| `CookieError` | The `ValueError` raised for ignored, ungrammatical or unsafe lines |
+
+## Why
+
+`http.cookies.SimpleCookie` was written for the old Cookie header, not for one
+Set-Cookie line: it keeps `Expires` as a string, accepts any `SameSite` value, reads an
+unknown attribute such as `Priority=High` as a second cookie, silently drops the whole
+line when it meets a flag it does not know (`Foo`, and `Partitioned` before Python 3.14),
+drops nameless cookies, and
+writes a control character in a value as an octal escape that browsers do not decode.
+`setcookie` follows the current draft step by step, refuses to build what browsers would
+drop, and gives typed results.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Links
+
+- Website: https://lianes8studio.com
+- GitHub: https://github.com/JaviLianes8
+- LinkedIn: https://www.linkedin.com/in/jlianes/

setcookie-0.2.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+setcookie/__init__.py,sha256=eJuOsy4hZUHuOgh_fprcsy1k5gjVLElzDVG1U1hLrEQ,511
+setcookie/__main__.py,sha256=opkfF8RTjeDb9qj2vActbwsjJC-tHJc3ZOyH62beCHg,147
+setcookie/_build.py,sha256=0AgmjsPNcE5FRCXX3EvuWvYPluvLYlNQi4AvwR_vAxo,6044
+setcookie/_chars.py,sha256=H3xyr8msUgQSLObbonToZiRP9mU-UVPtGBgG0v-3rAo,2423
+setcookie/_cli.py,sha256=x3Gjto1XjiAKHZT-pCXfGcknJgMXJB1lMryKR6WHsuc,3411
+setcookie/_dates.py,sha256=IEpyN5WEjrl8tXIpqki8T3pkxS8GUKepzS1ynnnxUP8,4053
+setcookie/_errors.py,sha256=6PgsqhCuRfbK8BKYmsg5HJnYxAs1JY3LRfMp3HvXEe8,200
+setcookie/_match.py,sha256=RKhAC4AP3Ggadej8TM45Eo6SCJGQ5YdguprEGCFc9tk,2786
+setcookie/_model.py,sha256=_IriNlW0izfnVc4PW2iyKlnCsR16A1Ch6ALUI_J1l7E,2710
+setcookie/_parse.py,sha256=Zywf29EFFruFJQ7QuoSmb8Ozgpx0ZRnvr5RlBHBwXRU,3757
+setcookie/_rules.py,sha256=wW8STksRRy5wcKVdSMXBoRGMaXgbRp_DRYtIy6Fb6Nw,1267
+setcookie/_store.py,sha256=oBRQiStcpRukies3pklhXMMLihc-Ar5knS7kLplfX-w,3712
+setcookie/_strict.py,sha256=XjcMgJITl-MmzDsIFvC6Gba0SbM9FcRWp_JWR8a3i4c,3708
+setcookie/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+setcookie-0.2.0.dist-info/METADATA,sha256=mBxmwo3ZGAhmF0rMRZ2M9HJBCGdX3mYw4PXmpsXnujk,8779
+setcookie-0.2.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+setcookie-0.2.0.dist-info/entry_points.txt,sha256=vqrbPY9EfyH_hPSFyiAowTRVbCzFlDdDBLHnJy-ih58,50
+setcookie-0.2.0.dist-info/licenses/LICENSE,sha256=wirD5nCA2aQa5UusK_1YHLBogI3CGcw23xAnulp3L_U,1091
+setcookie-0.2.0.dist-info/RECORD,,

setcookie-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

setcookie-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+setcookie = setcookie._cli:main

setcookie-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Javier Lianes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.