arcane-typing 0.1.0__tar.gz

arcane_typing-0.1.0/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.

arcane_typing-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,40 @@
+# `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/pyproject.toml

@@ -0,0 +1,36 @@
+[project]
+name = "arcane-typing"
+version = "0.1.0"
+description = "Experimental and advanced Python typing patterns for ty users."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.14"
+dependencies = []
+
+[[project.authors]]
+name = "Astral Software Inc."
+email = "hey@astral.sh"
+
+[build-system]
+requires = ["uv_build>=0.13.5,<0.14.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "ruff>=0.17.0",
+    "ty>=0.0.101",
+    "typing-extensions>=4.13",
+]
+
+[tool.uv]
+preview-features = ["check-command"]
+
+[tool.ruff]
+preview = true
+
+[tool.ruff.lint]
+ignore = ["deprecated-import"]
+
+[tool.ty.rules]
+experimental-syntax = "ignore"

arcane_typing-0.1.0/pyproject.toml.orig

@@ -0,0 +1,34 @@
+[project]
+name = "arcane-typing"
+version = "0.1.0"
+description = "Experimental and advanced Python typing patterns for ty users."
+authors = [{ name = "Astral Software Inc.", email = "hey@astral.sh" }]
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.14"
+dependencies = []
+
+[build-system]
+requires = ["uv_build>=0.13.5,<0.14.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "ruff>=0.17.0",
+    "ty>=0.0.101",
+    "typing-extensions>=4.13",
+]
+
+[tool.uv]
+preview-features = ["check-command"]
+
+[tool.ruff]
+preview = true
+
+[tool.ruff.lint]
+# Prefer the typing aliases for collection annotations.
+ignore = ["deprecated-import"]
+
+[tool.ty.rules]
+experimental-syntax = "ignore"

arcane_typing-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/arcane_typing/typed_dict.py

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

arcane_typing-0.1.0/src/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: ...