rply-stubs 0.1.0.0.7.8__py3-none-any.whl

main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from rply-stubs!")
+
+
+if __name__ == "__main__":
+    main()

rply-stubs/__init__.pyi

@@ -0,0 +1,14 @@
+from .token import Token
+from . import lexer
+from . import lexergenerator
+from .lexergenerator import LexerGenerator
+from .errors import LexingError, ParsingError
+
+__all__ = [
+    "Token",
+    "lexer",
+    "lexergenerator",
+    "LexerGenerator",
+    "LexingError",
+    "ParsingError",
+]

rply-stubs/errors.pyi

@@ -0,0 +1,23 @@
+from rply.token import SourcePosition
+
+class ParserGeneratorError(Exception):
+    pass
+
+class LexingError(Exception):
+    message: str
+    source_pos: SourcePosition
+
+    def __init__(self, message: str, source_pos: SourcePosition): ...
+    def getsourcepos(self) -> SourcePosition: ...
+    def __repr__(self) -> str: ...
+
+class ParsingError(Exception):
+    message: str
+    source_pos: SourcePosition
+
+    def __init__(self, message: str, source_pos: SourcePosition): ...
+    def getsourcepos(self) -> SourcePosition: ...
+    def __repr__(self) -> str: ...
+
+class ParserGeneratorWarning(Warning):
+    pass

rply-stubs/grammar.pyi

@@ -0,0 +1,90 @@
+from typing import Callable, Literal, Never
+
+def rightmost_terminal(
+    symbols: list[str], terminals: dict[str, list[int]]
+) -> str | None: ...
+
+type PrecedenceAssociativity = Literal["left"] | Literal["right"] | Literal["nonassoc"]
+type PrecedenceTuple = tuple[PrecedenceAssociativity, int]
+
+type ProductionFunction = Callable
+
+class Grammar(object):
+    productions: list["None | Production"]
+    prod_names: dict[str, list["Production"]]
+    terminals: dict[str, list[int]]
+
+    nonterminals: dict[str, list[int]]
+    first: dict[str, list[str]]
+    follow: dict[str | None, list[str]]
+    precedence: dict[str | None, PrecedenceTuple]
+    start: str | None
+
+    def __init__(self, terminals: list[str]): ...
+    def add_production(
+        self,
+        prod_name: str,
+        syms: list[str],
+        func: ProductionFunction,
+        precedence: str | None,
+    ) -> None | Never: ...
+    def set_precedence(
+        self, term: str, assoc: PrecedenceAssociativity, level: int
+    ) -> None | Never: ...
+    def set_start(self) -> None: ...
+    def unused_terminals(self) -> list[str]: ...
+    def unused_productions(self) -> list[str]: ...
+    def build_lritems(self) -> None: ...
+    def _first(self, beta: str) -> list[str]: ...
+    def compute_first(self) -> None: ...
+    def compute_follow(self) -> None: ...
+
+class Production(object):
+    number: int
+    name: str
+    prod: list[str]
+    func: ProductionFunction | None
+    prec: PrecedenceTuple
+    unique_syms: list[str]
+
+    lr_items: list["LRItem | None"]
+    lr_next: "LRItem | None"
+    lr0_added: int
+    reduced: int
+
+    def __init__(
+        self,
+        num: int,
+        name: str,
+        prod: list[str],
+        precedence: PrecedenceTuple,
+        func: ProductionFunction | None,
+    ): ...
+    def __repr__(self) -> str: ...
+    def getlength(self) -> int: ...
+
+class LRItem(object):
+    name: str
+    prod: list[str]
+    number: int
+    lr_index: int
+    lookaheads: dict[Unknown, list[Unknown]]
+    unique_syms: list[str]
+    lr_before: str | None
+    lr_after: list[Production]
+
+    def __init__(
+        self, p: Production, n: int, before: str | None, after: list[Production]
+    ):
+        self.name = p.name
+        self.prod = p.prod[:]
+        self.prod.insert(n, ".")
+        self.number = p.number
+        self.lr_index = n
+        self.lookaheads = {}
+        self.unique_syms = p.unique_syms
+        self.lr_before = before
+        self.lr_after = after
+
+    def __repr__(self) -> str: ...
+    def getlength(self) -> int: ...

rply-stubs/lexer.pyi

@@ -0,0 +1,24 @@
+from typing import Self
+from .token import Token
+from .lexergenerator import Rule, Match
+
+class Lexer(object):
+    rules: list[Rule]
+    ignore_rules: list[Rule]
+
+    def __init__(self, rules: list[Rule], ignore_rules: list[Rule]): ...
+    def lex(self, s: str) -> "LexerStream": ...
+
+class LexerStream(object):
+    lexer: Lexer
+    s: str
+    idx: int
+
+    _lineno: int
+    _colno: int
+
+    def __init__(self, lexer: Lexer, s: str): ...
+    def __iter__(self) -> Self: ...
+    def _update_pos(self, match: Match) -> int: ...
+    def next(self) -> Token: ...
+    def __next__(self) -> Token: ...

rply-stubs/lexergenerator.pyi

@@ -0,0 +1,28 @@
+from typing import Any
+from .lexer import Lexer
+from .token import SourcePosition
+
+class Rule[N: str](object):
+    _attrs_ = ["name", "flags", "_pattern"]
+    name: N
+    pattern: str
+    flags: int
+
+    def __init__(self, name: N, pattern: str, flags=0): ...
+    def _freeze_(self) -> bool: ...
+    def matches(self, s: str, pos: SourcePosition): ...
+
+class Match(object):
+    start: int
+    end: int
+
+    def __init__(self, start: int, end: int): ...
+
+class LexerGenerator(object):
+    rules: list[Rule]
+    ignore_rules: list[Rule]
+
+    def __init__(self): ...
+    def add(self, name: str | Any, pattern: str, flags: int = 0): ...
+    def ignore(self, pattern: str, flags: int = 0): ...
+    def build(self) -> Lexer: ...

rply-stubs/parser.pyi

@@ -0,0 +1,17 @@
+from typing import Callable, Never
+
+from rply.lexer import LexerStream
+from rply.parsergenerator import LRTable
+from rply.token import Token
+
+class LRParser(object):
+    lr_table: LRTable
+    error_handler: Callable
+
+    def __init__(self, lr_table: LRTable, error_handler: Callable): ...
+    def parse(
+        self, tokenizer: LexerStream, state: int | None = None
+    ) -> Token | Never: ...
+    def _reduce_production(
+        self, t, symstack: list[Token], statestack: list[int], state: int | None
+    ) -> int: ...

rply-stubs/parsergenerator.pyi

@@ -0,0 +1,295 @@
+import sys
+from typing import Callable, Final, Literal, Never, TypedDict
+
+from .grammar import LRItem, PrecedenceTuple, PrecedenceAssociativity
+from rply.grammar import Grammar
+from rply.parser import LRParser
+
+from rply.token import Token
+
+LARGE_VALUE = sys.maxsize
+
+type ProductionParts = tuple[
+    str, list[str], Callable, tuple[PrecedenceAssociativity, list[str]] | None
+]
+type Transition = list[tuple[int, LRItem]]
+type LookBacks = dict[tuple[int, LRItem], list[tuple[int, list]]]
+
+class SerializedLRTable(TypedDict):
+    lr_action: list[dict[str, int]]
+    lr_goto: list[dict[str, int]]
+    sr_conflicts: list[
+        tuple[int, str, Literal["reduce"] | Literal["nonassoc"] | Literal["shift"]]
+    ]
+    rr_conflicts: list[tuple[int, str, str]]
+    default_reductions: list[int]
+    start: str | None
+    terminals: list[str]
+    precedence: dict[str | None, PrecedenceTuple]
+    productions: list[tuple[str, list[str], PrecedenceTuple]]
+
+class ParserGenerator(object):
+
+    VERSION: Final[int]
+
+    tokens: list[Token]
+    productions: list[ProductionParts]
+    precedence: list[tuple[PrecedenceAssociativity, list[str]]]
+    cache_id: None | str
+    error_handler: None | Callable
+
+    def __init__(
+        self,
+        tokens: list[Token],
+        precedence: list[tuple[PrecedenceAssociativity, list[str]]] = [],
+        cache_id: str | None = None,
+    ): ...
+    def production(
+        self,
+        rule: str,
+        precedence: tuple[PrecedenceAssociativity, list[str]] | None = None,
+    ): ...
+    def error(self, func: Callable) -> Callable: ...
+    def compute_grammar_hash(self, g: Grammar) -> str: ...
+    def serialize_table(self, table: "LRTable") -> SerializedLRTable: ...
+    def data_is_valid(self, g: Grammar, data: SerializedLRTable) -> bool: ...
+    def build(self) -> LRParser: ...
+    def _write_cache(
+        self, cache_dir: str, cache_file: str, table: LRTable
+    ) -> None | Never: ...
+
+# TODO
+
+# def traverse(x, N, stack: list, F, X, R, FP):
+#     stack.append(x)
+#     d = len(stack)
+#     N[x] = d
+#     F[x] = FP(x)
+
+#     rel = R(x)
+#     for y in rel:
+#         if N[y] == 0:
+#             traverse(y, N, stack, F, X, R, FP)
+#         N[x] = min(N[x], N[y])
+#         for a in F.get(y, []):
+#             if a not in F[x]:
+#                 F[x].append(a)
+#     if N[x] == d:
+#         N[stack[-1]] = LARGE_VALUE
+#         F[stack[-1]] = F[x]
+#         element = stack.pop()
+#         while element != x:
+#             N[stack[-1]] = LARGE_VALUE
+#             F[stack[-1]] = F[x]
+#             element = stack.pop()
+
+class LRTable(object):
+    grammar: Grammar
+    lr_action: list[dict[str, int]]
+    lr_goto: list[dict[str, int]]
+    default_reductions: list[int]
+    sr_conflicts: list[
+        tuple[int, str, Literal["reduce"] | Literal["nonassoc"] | Literal["shift"]]
+    ]
+    rr_conflicts: list[tuple[int, str, str]]
+
+    def __init__(
+        self,
+        grammar: Grammar,
+        lr_action: list[dict[str, int]],
+        lr_goto: list[dict[str, int]],
+        default_reductions: list[int],
+        sr_conflicts: list[
+            tuple[int, str, Literal["reduce"] | Literal["nonassoc"] | Literal["shift"]]
+        ],
+        rr_conflicts: list[tuple[int, str, str]],
+    ): ...
+    @classmethod
+    def from_cache(cls, grammar: Grammar, data: SerializedLRTable) -> "LRTable": ...
+    @classmethod
+    def from_grammar(cls, grammar: Grammar) -> LRTable | Never: ...
+
+    # TODO
+    # @classmethod
+    # def lr0_items(cls, grammar: Grammar, add_count: Counter, cidhash: IdentityDict, goto_cache: GotoCache) -> list[list[LRItem]]:
+    #     C = [cls.lr0_closure([grammar.productions[0].lr_next], add_count)]
+    #     for i, I in enumerate(C):
+    #         cidhash[I] = i
+
+    #     i = 0
+    #     while i < len(C):
+    #         I = C[i]
+    #         i += 1
+
+    #         asyms = set()
+    #         for ii in I:
+    #             asyms.update(ii.unique_syms)
+    #         for x in asyms:
+    #             g = cls.lr0_goto(I, x, add_count, goto_cache)
+    #             if not g:
+    #                 continue
+    #             if g in cidhash:
+    #                 continue
+    #             cidhash[g] = len(C)
+    #             C.append(g)
+    #     return C
+
+    # @classmethod
+    # def lr0_closure(cls, I: list[LRItem], add_count: Counter) -> list[LRItem]:
+    #     add_count.incr()
+
+    #     J = I[:]
+    #     added = True
+    #     while added:
+    #         added = False
+    #         for j in J:
+    #             for x in j.lr_after:
+    #                 if x.lr0_added == add_count.value:
+    #                     continue
+    #                 J.append(x.lr_next)
+    #                 x.lr0_added = add_count.value
+    #                 added = True
+    #     return J
+
+    # @classmethod
+    # def lr0_goto(cls, I: Sequence[Production], x: str, add_count: Counter, goto_cache: GotoCache) -> ...:
+    #     s = goto_cache.setdefault(x, IdentityDict())
+
+    #     gs = []
+    #     for p in I:
+    #         n = p.lr_next
+    #         if n and n.lr_before == x:
+    #             s1 = s.get(n)
+    #             if not s1:
+    #                 s1 = {}
+    #                 s[n] = s1
+    #             gs.append(n)
+    #             s = s1
+    #     g = s.get("$end")
+    #     if not g:
+    #         if gs:
+    #             g = cls.lr0_closure(gs, add_count)
+    #             s["$end"] = g
+    #         else:
+    #             s["$end"] = gs
+    #     return g
+
+    # @classmethod
+    # def add_lalr_lookaheads(cls, grammar: Grammar, C: list[list[LRItem]], add_count: Counter, cidhash, goto_cache: GotoCache):
+    #     nullable = cls.compute_nullable_nonterminals(grammar)
+    #     trans = cls.find_nonterminal_transitions(grammar, C)
+    #     readsets = cls.compute_read_sets(grammar, C, trans, nullable, add_count, cidhash, goto_cache)
+    #     lookd, included = cls.compute_lookback_includes(grammar, C, trans, nullable, add_count, cidhash, goto_cache)
+    #     followsets = cls.compute_follow_sets(trans, readsets, included)
+    #     cls.add_lookaheads(lookd, followsets)
+
+    # @classmethod
+    # def compute_nullable_nonterminals(cls, grammar: Grammar) -> set[str]:
+    #     ...
+
+    # @classmethod
+    # def find_nonterminal_transitions(cls, grammar: Grammar, C: list[list[LRItem]]) -> Transition:
+    #     trans = []
+    #     for idx, state in enumerate(C):
+    #         for p in state:
+    #             if p.lr_index < p.getlength() - 1:
+    #                 t = (idx, p.prod[p.lr_index + 1])
+    #                 if t[1] in grammar.nonterminals and t not in trans:
+    #                     trans.append(t)
+    #     return trans
+
+    # @classmethod
+    # def compute_read_sets(cls, grammar: Grammar, C: list[list[LRItem]], ntrans, nullable, add_count: Counter, cidhash, goto_cache: GotoCache):
+    #     return digraph(
+    #         ntrans,
+    #         R=lambda x: cls.reads_relation(C, x, nullable, add_count, cidhash, goto_cache),
+    #         FP=lambda x: cls.dr_relation(grammar, C, x, nullable, add_count, goto_cache)
+    #     )
+
+    # @classmethod
+    # def compute_follow_sets(cls, ntrans, readsets, includesets):
+    #     return digraph(
+    #         ntrans,
+    #         R=lambda x: includesets.get(x, []),
+    #         FP=lambda x: readsets[x],
+    #     )
+
+    # @classmethod
+    # def dr_relation(cls, grammar: Grammar, C: list[list[Production]], trans: tuple[int, str], nullable: set[str], add_count: Counter, goto_cache: GotoCache) -> list[str]:
+    #     ...
+
+    # @classmethod
+    # def reads_relation(cls, C, trans: Transition, empty, add_count: Counter, cidhash: IdentityDict, goto_cache: GotoCache) -> list[tuple[int, str]]:
+    #     rel = []
+    #     state, N = trans
+
+    #     g = cls.lr0_goto(C[state], N, add_count, goto_cache)
+    #     j = cidhash.get(g, -1)
+    #     for p in g:
+    #         if p.lr_index < p.getlength() - 1:
+    #             a = p.prod[p.lr_index + 1]
+    #             if a in empty:
+    #                 rel.append((j, a))
+    #     return rel
+
+    # @classmethod
+    # def compute_lookback_includes(cls, grammar: Grammar, C, trans: Transition, nullable: set[str], add_count: Counter, cidhash: IdentityDict, goto_cache: GotoCache) -> tuple[dict[tuple[int, LRItem], LookBacks], dict[...,...]]:
+    #     lookdict = {}
+    #     includedict = {}
+
+    #     dtrans = dict.fromkeys(trans, 1)
+
+    #     for state, N in trans:
+    #         lookb = []
+    #         includes = []
+    #         for p in C[state]:
+    #             if p.name != N:
+    #                 continue
+
+    #             lr_index = p.lr_index
+    #             j = state
+    #             while lr_index < p.getlength() - 1:
+    #                 lr_index += 1
+    #                 t = p.prod[lr_index]
+
+    #                 if (j, t) in dtrans:
+    #                     li = lr_index + 1
+    #                     while li < p.getlength():
+    #                         if p.prod[li] in grammar.terminals:
+    #                             break
+    #                         if p.prod[li] not in nullable:
+    #                             break
+    #                         li += 1
+    #                     else:
+    #                         includes.append((j, t))
+
+    #                 g = cls.lr0_goto(C[j], t, add_count, goto_cache)
+    #                 j = cidhash.get(g, -1)
+
+    #             for r in C[j]:
+    #                 if r.name != p.name:
+    #                     continue
+    #                 if r.getlength() != p.getlength():
+    #                     continue
+    #                 i = 0
+    #                 while i < r.lr_index:
+    #                     if r.prod[i] != p.prod[i + 1]:
+    #                         break
+    #                     i += 1
+    #                 else:
+    #                     lookb.append((j, r))
+
+    #         for i in includes:
+    #             includedict.setdefault(i, []).append((state, N))
+    #         lookdict[state, N] = lookb
+    #     return lookdict, includedict
+
+    # @classmethod
+    # def add_lookaheads(cls, lookbacks: dict[Transition, LookBacks], followset: dict[Transition, list[tuple[int, list[...]]]]):
+    #     for trans, lb in iteritems(lookbacks):
+    #         for state, p in lb:
+    #             f = followset.get(trans, [])
+    #             laheads = p.lookaheads.setdefault(state, [])
+    #             for a in f:
+    #                 if a not in laheads:
+    #                     laheads.append(a)

rply-stubs/token.pyi

@@ -0,0 +1,27 @@
+from typing import Any, Never, Self, overload
+
+class BaseBox(object):
+    _attrs_: list[str] = []
+
+class SourcePosition(object):
+    idx: int
+    lineno: int
+    colno: int
+
+    def __init__(self, idx: int, lineno: int, colno: int): ...
+    def __repr__(self) -> str: ...
+
+class Token[N: str, V](BaseBox):
+    name: N
+    value: V
+    source_pos: SourcePosition | None
+
+    def __init__(self, name: N, value: V, source_pos=None): ...
+    def __repr__(self) -> str: ...
+    @overload
+    def __eq__(self, other: Self) -> bool: ...
+    @overload
+    def __eq__(self, other: Any) -> Never: ...
+    def gettokentype(self) -> N: ...
+    def getsourcepos(self) -> SourcePosition: ...
+    def getstr(self) -> N: ...

rply-stubs/utils.pyi

@@ -0,0 +1,35 @@
+import sys
+from typing import Generator, ItemsView, ValuesView
+
+if sys.version_info >= (3, 3):
+    from collections.abc import MutableMapping
+else:
+    from collections import MutableMapping
+
+class IdentityDict[K: object, V: object](MutableMapping):
+    _contents: dict[int, tuple[K, V, int]]
+    _keepalive: list[K]
+
+    def __init__(self): ...
+    def __getitem__(self, key: K) -> V: ...
+    def __setitem__(self, key: K, value: V): ...
+    def __delitem__(self, key: K): ...
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Generator[K]: ...
+
+class Counter(object):
+    value: int
+
+    def __init__(self): ...
+    def incr(self): ...
+
+if sys.version_info >= (3,):
+    def itervalues[K, V](d: dict[K, V]) -> ValuesView[V]: ...
+    def iteritems[K, V](d: dict[K, V]) -> ItemsView[K, V]: ...
+
+else:
+    def itervalues(d):
+        return d.itervalues()
+
+    def iteritems(d):
+        return d.iteritems()

rply_stubs-0.1.0.0.7.8.dist-info/METADATA

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: rply-stubs
+Version: 0.1.0.0.7.8
+Summary: A stubs library for RPLY
+Author: ArachnidAbby, Summersweet-Software
+License: MIT-only
+Project-URL: Homepage, https://summersweet.software
+Project-URL: Repository, https://github.com/summersweet-software/rply-stubs
+Project-URL: Issues, https://github.com/summersweet-software/rply-stubs/issues
+Keywords: stubs,typed,typing,rply,lexer generator,parser generator,lexer,parser,mypy,pyi,stubs only
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Natural Language :: English
+Classifier: Typing :: Stubs Only
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rply==0.7.8
+Dynamic: license-file
+
+# RPLY Stubs
+
+A stubs library for [RPLY](https://pypi.org/project/rply/)
+
+# Correctness
+
+This is an independent static analysis of the types being used. This is not the easiest task in a codebase so unmaintained and old (not to say that RPLY doesn't set out to accomplish all that it needs to. It is a well written and complete library from the way I see it.).
+
+This is all to say that the type annotations provided are not always correct but provide a firm guideline in an otherwise untyped library.
+
+# Completeness
+
+| symbol | meaning       |
+| ------ | ------------- |
+| ⚪     | partial       |
+| ❌     | Not worked on |
+| ✅     | completed     |
+
+| Module          | Status |
+| --------------- | :----: |
+| errors          |   ✅   |
+| grammar         |   ⚪   |
+| lexer           |   ✅   |
+| lexergenerator  |   ✅   |
+| parser          |   ✅   |
+| parsergenerator |   ⚪   |
+| token           |   ✅   |
+| utils           |   ✅   |
+
+# Difficulties In Completion
+
+This stubs library is made significantly more difficult to complete due to the fact that single-letter naming conventions are used in several places without explanation or comment in to what each variable means.
+For example:
+
+```python
+# rply/parsergenerator.py
+def traverse(x, N, stack, F, X, R, FP):
+    ...
+```
+
+It is clear that `stack` is some kind of list but what are `x`, `N`, `F`, `X`, `R`, and `FP`?
+
+FP could be a function pointer? But that is just an educated guess.
+
+Many such examples exist in the codebase and are hard to descern. That is also not mentioning the large amount of compounding types with signatures such as `list[dict[tuple[int, str], list[dict[...]]]]`. This is extremely hard to annotate or understand the individual parts of.
+
+Most of the examples come from the `parsergenerator` module which I will personally say is not very readable. I would love if the library author could provide some assistance.

rply_stubs-0.1.0.0.7.8.dist-info/RECORD

@@ -0,0 +1,16 @@
+main.py,sha256=txE1upXIhdhOkum6SOKKtJ9gfqSdIhUL7reh_vsOxSM,88
+rply-stubs/__init__.pyi,sha256=vWgVYCW30SyWRdkxg-Pls2q8t7iGPE8VUzTO_l_cO0U,287
+rply-stubs/errors.pyi,sha256=iL0FiGqGB8zufe5T2PUh3uxGXfVwu84grkqGhMnBUkY,630
+rply-stubs/grammar.pyi,sha256=F-RRDudzP0qZC1Q4-ekwRfo_jBqTVaunbw2nfDAgWBQ,2615
+rply-stubs/lexer.pyi,sha256=kykP3PuzGYWAnlmgYAuK6QNHswwenbybL1wQ7ECtIp8,596
+rply-stubs/lexergenerator.pyi,sha256=a1g-xINtcIfpde7spbqsqo8BnEZ_U1s9aehzmDmnRQo,724
+rply-stubs/parser.pyi,sha256=p6LjabGhgKNLyEAFKG_tbtWBejl5TbDToCzscg2N4I0,539
+rply-stubs/parsergenerator.pyi,sha256=dQFoVulMo8-xupbW4Fx8tBid3gxwCpoXRtXIR2n4DuQ,10756
+rply-stubs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rply-stubs/token.pyi,sha256=85HxzyeEahHH5HjOh-VwBT7qE_VvfKjXQgmtDzjESDk,709
+rply-stubs/utils.pyi,sha256=7lIPJGvqonCEkD1lkmuTPhde3JcmGlvcUMjPEbxN4ao,950
+rply_stubs-0.1.0.0.7.8.dist-info/licenses/LICENSE,sha256=1PlBa292DFNgPvvKohwHAcg064dl-GMc0fkyVhZJ8bY,1077
+rply_stubs-0.1.0.0.7.8.dist-info/METADATA,sha256=1k91tB3r0EdEDHP-VUDbgrldW9vK-1nb5DOXmy10iuQ,3032
+rply_stubs-0.1.0.0.7.8.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+rply_stubs-0.1.0.0.7.8.dist-info/top_level.txt,sha256=I3dV125hHsngaTY-V8SWAR7F440bY3bgU90PN1_XjYk,16
+rply_stubs-0.1.0.0.7.8.dist-info/RECORD,,

rply_stubs-0.1.0.0.7.8.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

rply_stubs-0.1.0.0.7.8.dist-info/licenses/LICENSE

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

rply_stubs-0.1.0.0.7.8.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+main
+rply-stubs