ty-extensions-unofficial 0.1.0.dev0__tar.gz

ty_extensions_unofficial-0.1.0.dev0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.3
+Name: ty-extensions-unofficial
+Version: 0.1.0.dev0
+Summary: A properly packaged fork of the official ty-extensions
+Author: InSyncWithFoo
+Author-email: InSyncWithFoo <insyncwithfoo@gmail.com>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# `ty-extensions-unofficial`
+
+This repository contains a properly packaged fork
+of [the official `ty-extensions`][1], whose [PyPI project][2] is empty.
+
+At runtime, the package simply raises a `RuntimeError`.
+As such, do not import it normally.
+
+
+  [1]: https://github.com/astral-sh/ruff/blob/HEAD/crates/ty_vendored/ty_extensions/ty_extensions.pyi
+  [2]: https://pypi.org/project/ty-extensions/

ty_extensions_unofficial-0.1.0.dev0/README.md

@@ -0,0 +1,11 @@
+# `ty-extensions-unofficial`
+
+This repository contains a properly packaged fork
+of [the official `ty-extensions`][1], whose [PyPI project][2] is empty.
+
+At runtime, the package simply raises a `RuntimeError`.
+As such, do not import it normally.
+
+
+  [1]: https://github.com/astral-sh/ruff/blob/HEAD/crates/ty_vendored/ty_extensions/ty_extensions.pyi
+  [2]: https://pypi.org/project/ty-extensions/

ty_extensions_unofficial-0.1.0.dev0/pyproject.toml

@@ -0,0 +1,17 @@
+[project]
+name = "ty-extensions-unofficial"
+version = "0.1.0.dev0"
+description = "A properly packaged fork of the official ty-extensions"
+readme = "README.md"
+authors = [
+    { name = "InSyncWithFoo", email = "insyncwithfoo@gmail.com" }
+]
+requires-python = ">=3.9"
+dependencies = []
+
+[build-system]
+requires = ["uv_build>=0.9.5,<0.10.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "ty_extensions"

ty_extensions_unofficial-0.1.0.dev0/src/ty_extensions/__init__.py

@@ -0,0 +1 @@
+raise RuntimeError('ty_extensions is not a runtime package')

ty_extensions_unofficial-0.1.0.dev0/src/ty_extensions/__init__.pyi

@@ -0,0 +1,157 @@
+# ruff: noqa: PYI021
+import sys
+import types
+from collections.abc import Iterable
+from enum import Enum
+from typing import (
+    Any,
+    ClassVar,
+    LiteralString,
+    Protocol,
+    _SpecialForm,
+)
+
+from typing_extensions import Self  # noqa: UP035
+
+# Special operations
+def static_assert(condition: object, msg: LiteralString | None = None) -> None: ...
+
+# Types
+Unknown = object()
+AlwaysTruthy = object()
+AlwaysFalsy = object()
+
+# Special forms
+Not: _SpecialForm
+Intersection: _SpecialForm
+TypeOf: _SpecialForm
+CallableTypeOf: _SpecialForm
+# Top[T] evaluates to the top materialization of T, a type that is a supertype
+# of every materialization of T.
+Top: _SpecialForm
+# Bottom[T] evaluates to the bottom materialization of T, a type that is a subtype
+# of every materialization of T.
+Bottom: _SpecialForm
+
+# ty treats annotations of `float` to mean `float | int`, and annotations of `complex`
+# to mean `complex | float | int`. This is to support a typing-system special case [1].
+# We therefore provide `JustFloat` and `JustComplex` to represent the "bare" `float` and
+# `complex` types, respectively.
+#
+# [1]: https://typing.readthedocs.io/en/latest/spec/special-types.html#special-cases-for-float-and-complex
+type JustFloat = TypeOf[1.0]
+type JustComplex = TypeOf[1.0j]
+
+# Constraints
+class ConstraintSet:
+    @staticmethod
+    def range(lower_bound: Any, typevar: Any, upper_bound: Any) -> Self:
+        """
+        Returns a constraint set that requires `typevar` to specialize to a type
+        that is a supertype of `lower_bound` and a subtype of `upper_bound`.
+        """
+
+    @staticmethod
+    def always() -> Self:
+        """Returns a constraint set that is always satisfied"""
+
+    @staticmethod
+    def never() -> Self:
+        """Returns a constraint set that is never satisfied"""
+
+    def implies_subtype_of(self, ty: Any, of: Any) -> Self:
+        """
+        Returns a constraint set that is satisfied when `ty` is a `subtype`_ of
+        `of`, assuming that all of the constraints in `self` hold.
+
+        .. _subtype: https://typing.python.org/en/latest/spec/concepts.html#subtype-supertype-and-type-equivalence
+        """
+
+    def __bool__(self) -> bool: ...
+    def __eq__(self, other: ConstraintSet) -> bool: ...
+    def __ne__(self, other: ConstraintSet) -> bool: ...
+    def __and__(self, other: ConstraintSet) -> ConstraintSet: ...
+    def __or__(self, other: ConstraintSet) -> ConstraintSet: ...
+    def __invert__(self) -> ConstraintSet: ...
+
+# Predicates on types
+#
+# Ideally, these would be annotated using `TypeForm`, but that has not been
+# standardized yet (https://peps.python.org/pep-0747).
+def is_equivalent_to(type_a: Any, type_b: Any) -> ConstraintSet:
+    """Returns a constraint set that is satisfied when `type_a` and `type_b` are
+    `equivalent`_ types.
+
+    .. _equivalent: https://typing.python.org/en/latest/spec/glossary.html#term-equivalent
+    """
+
+def is_subtype_of(ty: Any, of: Any) -> ConstraintSet:
+    """Returns a constraint set that is satisfied when `ty` is a `subtype`_ of `of`.
+
+    .. _subtype: https://typing.python.org/en/latest/spec/concepts.html#subtype-supertype-and-type-equivalence
+    """
+
+def is_assignable_to(ty: Any, to: Any) -> ConstraintSet:
+    """Returns a constraint set that is satisfied when `ty` is `assignable`_ to `to`.
+
+    .. _assignable: https://typing.python.org/en/latest/spec/concepts.html#the-assignable-to-or-consistent-subtyping-relation
+    """
+
+def is_disjoint_from(type_a: Any, type_b: Any) -> ConstraintSet:
+    """Returns a constraint set that is satisfied when `type_a` and `type_b` are disjoint types.
+
+    Two types are disjoint if they have no inhabitants in common.
+    """
+
+def is_singleton(ty: Any) -> bool:
+    """Returns `True` if `ty` is a singleton type with exactly one inhabitant."""
+
+def is_single_valued(ty: Any) -> bool:
+    """Returns `True` if `ty` is non-empty and all inhabitants compare equal to each other."""
+
+# Returns the generic context of a type as a tuple of typevars, or `None` if the
+# type is not generic.
+def generic_context(ty: Any) -> Any: ...
+
+# Returns the `__all__` names of a module as a tuple of sorted strings, or `None` if
+# either the module does not have `__all__` or it has invalid elements.
+def dunder_all_names(module: Any) -> Any: ...
+
+# List all members of an enum.
+def enum_members[E: type[Enum]](enum: E) -> tuple[str, ...]: ...
+
+# Returns a tuple of all members of the given object, similar to `dir(obj)` and
+# `inspect.getmembers(obj)`, with at least the following differences:
+#
+# * `dir` and `inspect.getmembers` may use runtime mutable state to construct
+# the list of attributes returned. In contrast, this routine is limited to
+# static information only.
+# * `dir` will respect an object's `__dir__` implementation, if present, but
+# this method (currently) does not.
+def all_members(obj: Any) -> tuple[str, ...]: ...
+
+# Returns `True` if the given object has a member with the given name.
+def has_member(obj: Any, name: str) -> bool: ...
+def reveal_protocol_interface(protocol: type) -> None:
+    """
+    Passing a protocol type to this function will cause ty to emit an info-level
+    diagnostic describing the protocol's interface.
+
+    Passing a non-protocol type will cause ty to emit an error diagnostic.
+    """
+
+def reveal_mro(cls: type | types.GenericAlias) -> None:
+    """Reveal the MRO that ty infers for the given class or generic alias."""
+
+# A protocol describing an interface that should be satisfied by all named tuples
+# created using `typing.NamedTuple` or `collections.namedtuple`.
+class NamedTupleLike(Protocol):
+    # from typing.NamedTuple stub
+    _field_defaults: ClassVar[dict[str, Any]]
+    _fields: ClassVar[tuple[str, ...]]
+    @classmethod
+    def _make(cls: type[Self], iterable: Iterable[Any]) -> Self: ...
+    def _asdict(self, /) -> dict[str, Any]: ...
+    def _replace(self, /, **kwargs) -> Self: ...
+    if sys.version_info >= (3, 13):
+        def __replace__(self, **kwargs) -> Self: ...