arcane-typing 0.1.0__py3-none-any.whl

arcane_typing/__init__.py

@@ -0,0 +1,8 @@
+"""Experimental and advanced Python typing patterns for ty users."""
+
+from .core import Bottom as Bottom
+from .core import Top as Top
+from .core import TypeOf as TypeOf
+from .narrowing import hasattr_of_type as hasattr_of_type
+from .narrowing import is_sequence_of as is_sequence_of
+from .typed_dict import Keys as Keys

arcane_typing/__init__.pyi

@@ -0,0 +1,6 @@
+from .core import Bottom as Bottom
+from .core import Top as Top
+from .core import TypeOf as TypeOf
+from .narrowing import hasattr_of_type as hasattr_of_type
+from .narrowing import is_sequence_of as is_sequence_of
+from .typed_dict import Keys as Keys

arcane_typing/core.py

@@ -0,0 +1,15 @@
+from typing import Any
+
+
+class _RuntimeSpecialForm:
+    def __class_getitem__(cls, _argument: object, /) -> Any:
+        return Any
+
+
+class TypeOf(_RuntimeSpecialForm): ...
+
+
+class Top(_RuntimeSpecialForm): ...
+
+
+class Bottom(_RuntimeSpecialForm): ...

arcane_typing/core.pyi

@@ -0,0 +1,3 @@
+from ty_extensions import Bottom as Bottom
+from ty_extensions import Top as Top
+from ty_extensions._internal import TypeOf as TypeOf

arcane_typing/narrowing.py

@@ -0,0 +1,26 @@
+from types import UnionType
+from typing import Sequence, get_args
+
+
+def hasattr_of_type(obj: object, key: str, clsinfo: object, /) -> bool:
+    try:
+        value = getattr(obj, key)
+    except AttributeError:
+        return False
+
+    return isinstance(value, _validate_clsinfo(clsinfo))
+
+
+def is_sequence_of(obj: object, clsinfo: object, /) -> bool:
+    clsinfo = _validate_clsinfo(clsinfo)
+    return isinstance(obj, Sequence) and all(isinstance(item, clsinfo) for item in obj)
+
+
+def _validate_clsinfo(clsinfo: object) -> type | UnionType:
+    if not isinstance(clsinfo, (type, UnionType)) or (
+        isinstance(clsinfo, UnionType)
+        and any(not isinstance(member, type) for member in get_args(clsinfo))
+    ):
+        raise TypeError("Expected a class or a union of classes")
+
+    return clsinfo

arcane_typing/narrowing.pyi

@@ -0,0 +1,17 @@
+from typing import LiteralString, Protocol, Sequence, TypeIs, overload
+
+from typing_extensions import TypeForm
+
+class _HasAttr[K: LiteralString, V](Protocol):
+    @overload
+    def __getattr__(self, name: K, /) -> V: ...
+    @overload
+    def __getattr__(self, name: str, /) -> object: ...
+
+def hasattr_of_type[K: LiteralString, V](
+    obj: object, key: K, clsinfo: TypeForm[V], /
+) -> TypeIs[_HasAttr[K, V]]:
+    """Check whether `obj` has an attribute `key` that matches a class or union of classes."""
+
+def is_sequence_of[T](obj: object, clsinfo: TypeForm[T], /) -> TypeIs[Sequence[T]]:
+    """Check whether `obj` is a sequence whose elements match a class or union of classes."""

arcane_typing/typed_dict.py

@@ -0,0 +1,3 @@
+class Keys:
+    def __class_getitem__(cls, _schema: object, /) -> None:
+        return None

arcane_typing/typed_dict.pyi

@@ -0,0 +1,18 @@
+from typing import Iterable, LiteralString, Mapping
+
+from typing_extensions import TypeForm
+
+class Keys:
+    """`TypeOf[Keys[T]]` is a union of string literals representing the keys of the TypedDict `T`.
+
+    Example:
+        class Movie(TypedDict, closed=True):
+            title: str
+            year: int
+
+        type MovieKey = TypeOf[Keys[Movie]]  # Literal["title", "year"]
+    """
+
+    def __class_getitem__[K: LiteralString](
+        cls, schema: TypeForm[Mapping[str, object] & Iterable[K]], /
+    ) -> K: ...

arcane_typing-0.1.0.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: arcane-typing
+Version: 0.1.0
+Summary: Experimental and advanced Python typing patterns for ty users.
+Author: Astral Software Inc.
+Author-email: Astral Software Inc. <hey@astral.sh>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# `arcane-typing`
+
+This package provides advanced typing patterns for Python projects that use [ty](https://docs.astral.sh/ty/).
+
+> [!WARNING]
+> This project is highly experimental and currently makes no promises regarding backward compatibility.
+
+## Features
+
+### Core utilities
+
+- `TypeOf[expr]` can be used to obtain ty's inferred type for an expression in a type annotation or type alias.
+- `Top[T]` can be used to refer to the top-materialization of `T`.
+- `Bottom[T]` can be used to refer to the bottom-materialization of `T`.
+
+### TypedDict features
+
+- `TypeOf[Keys[T]]` gives a union of string literals for the keys that can appear in a `TypedDict` `T`.
+
+### Type Narrowing
+
+- `hasattr_of_type(obj, "name", T)` narrows `obj.name` to type `T` if the attribute exists and if
+  it is an instance of `T` (which can be a class or a union of classes)
+- `is_sequence_of(obj, T)` checks that `obj` is a sequence and that every element is an instance of `T` (which can be a class or a union of classes). It narrows `obj` to `Sequence[T]` on success.
+
+## Development
+
+Use [uv](https://docs.astral.sh/uv/) to run the following development tasks:
+
+```sh
+# Linting and formatting
+uv run ruff check
+uv run ruff format --check
+
+# Type checking
+TY_UV=scripts uv run ty check
+
+# Markdown tests
+uv run mdtest.py
+```

arcane_typing-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+arcane_typing/__init__.py,sha256=7V1z2t20E8uLzawsd2mQ-e55xxirVFmqzDrjIm-t-q4,320
+arcane_typing/__init__.pyi,sha256=ETknq9-z7ZbvF0WeuxMEwXe6geiGS3rZwjKGjHKvsfU,250
+arcane_typing/core.py,sha256=EOF3ESeyAtx9E2n2ekVUFjEaysyh5LS_fARwibZ7QfU,252
+arcane_typing/core.pyi,sha256=RDgqCIcje56quIsgmXTzPSQAWQ30Nu994ISk64l4bts,133
+arcane_typing/narrowing.py,sha256=Jq_7CbT3QsBWTbTBwcAz0ewDCZlZYeob_epCyF-4MTE,808
+arcane_typing/narrowing.pyi,sha256=l87M6V93BfeQNBM8M6exTElBpZdmLt2liFTC8j5HZog,685
+arcane_typing/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+arcane_typing/typed_dict.py,sha256=U5iBG3DKqKgrwdwUeKSfqwNYZnx7t4p0A5e6lyl-G-4,92
+arcane_typing/typed_dict.pyi,sha256=sdZG45yvsZjMdjUkumji_V_4ZWZ0h4Yw-bLp-cjyjKc,520
+arcane_typing-0.1.0.dist-info/licenses/LICENSE,sha256=fu2Ui0u0Eitn8XQofwtsZ1kW1MvfVNqJMMLfb5I6fuw,1077
+arcane_typing-0.1.0.dist-info/WHEEL,sha256=si2p8vW03RnhyBnhWl4tj-ObJa78SpE-c9HsEtblGR0,80
+arcane_typing-0.1.0.dist-info/METADATA,sha256=AlxCM2tBYcr9dbCxCT7eg3yfZEBXa-nE22-ty85o4cs,1626
+arcane_typing-0.1.0.dist-info/RECORD,,

arcane_typing-0.1.0.dist-info/WHEEL

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

arcane_typing-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Astral Software Inc.
+
+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.