types-antlr4-python3-runtime 4.13.0.20240116__tar.gz

types-antlr4-python3-runtime-4.13.0.20240116/CHANGELOG.md

@@ -0,0 +1,4 @@
+## 4.13.0.20240116 (2024-01-16)
+
+Add stubs for antlr4 (#11192)
+

types-antlr4-python3-runtime-4.13.0.20240116/MANIFEST.in

@@ -0,0 +1 @@
+include CHANGELOG.md

types-antlr4-python3-runtime-4.13.0.20240116/PKG-INFO

@@ -0,0 +1,37 @@
+Metadata-Version: 2.1
+Name: types-antlr4-python3-runtime
+Version: 4.13.0.20240116
+Summary: Typing stubs for antlr4-python3-runtime
+Home-page: https://github.com/python/typeshed
+License: Apache-2.0 license
+Project-URL: GitHub, https://github.com/python/typeshed
+Project-URL: Changes, https://github.com/typeshed-internal/stub_uploader/blob/main/data/changelogs/antlr4-python3-runtime.md
+Project-URL: Issue tracker, https://github.com/python/typeshed/issues
+Project-URL: Chat, https://gitter.im/python/typing
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Stubs Only
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+## Typing stubs for antlr4-python3-runtime
+
+This is a [PEP 561](https://peps.python.org/pep-0561/)
+type stub package for the [`antlr4-python3-runtime`](https://github.com/antlr/antlr4) package.
+It can be used by type-checking tools like
+[mypy](https://github.com/python/mypy/),
+[pyright](https://github.com/microsoft/pyright),
+[pytype](https://github.com/google/pytype/),
+PyCharm, etc. to check code that uses
+`antlr4-python3-runtime`.
+
+This version of `types-antlr4-python3-runtime` aims to provide accurate annotations
+for `antlr4-python3-runtime==4.13.*`.
+The source for this package can be found at
+https://github.com/python/typeshed/tree/main/stubs/antlr4-python3-runtime. All fixes for
+types and metadata should be contributed there.
+
+See https://github.com/python/typeshed/blob/main/README.md for more details.
+This package was generated from typeshed commit `26e77cbf67ee0e224808a85b18c08c1dda63aaec` and was tested
+with mypy 1.8.0, pyright 1.1.342, and
+pytype 2023.12.18.

types-antlr4-python3-runtime-4.13.0.20240116/antlr4-stubs/BufferedTokenStream.pyi

@@ -0,0 +1,39 @@
+from _typeshed import Incomplete
+
+from antlr4.error.Errors import IllegalStateException as IllegalStateException
+from antlr4.Token import Token as Token
+
+Lexer: Incomplete
+
+class TokenStream: ...
+
+class BufferedTokenStream(TokenStream):
+    tokenSource: Incomplete
+    tokens: Incomplete
+    index: int
+    fetchedEOF: bool
+    def __init__(self, tokenSource: Lexer) -> None: ...
+    def mark(self) -> int: ...
+    def release(self, marker: int) -> None: ...
+    def reset(self) -> None: ...
+    def seek(self, index: int) -> None: ...
+    def get(self, index: int) -> Token: ...
+    def consume(self) -> None: ...
+    def sync(self, i: int) -> bool: ...
+    def fetch(self, n: int) -> int: ...
+    def getTokens(self, start: int, stop: int, types: set[int] | None = None) -> list[Token]: ...
+    def LA(self, i: int) -> int: ...
+    def LB(self, k: int) -> Token | None: ...
+    def LT(self, k: int) -> Token | None: ...
+    def adjustSeekIndex(self, i: int): ...
+    def lazyInit(self) -> None: ...
+    def setup(self) -> None: ...
+    def setTokenSource(self, tokenSource: Lexer): ...
+    def nextTokenOnChannel(self, i: int, channel: int): ...
+    def previousTokenOnChannel(self, i: int, channel: int): ...
+    def getHiddenTokensToRight(self, tokenIndex: int, channel: int = -1): ...
+    def getHiddenTokensToLeft(self, tokenIndex: int, channel: int = -1): ...
+    def filterForChannel(self, left: int, right: int, channel: int): ...
+    def getSourceName(self): ...
+    def getText(self, start: int | None = None, stop: int | None = None): ...
+    def fill(self) -> None: ...

types-antlr4-python3-runtime-4.13.0.20240116/antlr4-stubs/CommonTokenFactory.pyi

@@ -0,0 +1,14 @@
+from _typeshed import Incomplete
+
+from antlr4.Token import CommonToken as CommonToken
+
+class TokenFactory: ...
+
+class CommonTokenFactory(TokenFactory):
+    DEFAULT: Incomplete
+    copyText: Incomplete
+    def __init__(self, copyText: bool = False) -> None: ...
+    def create(
+        self, source: tuple[Incomplete, ...], type: int, text: str, channel: int, start: int, stop: int, line: int, column: int
+    ): ...
+    def createThin(self, type: int, text: str): ...

types-antlr4-python3-runtime-4.13.0.20240116/antlr4-stubs/CommonTokenStream.pyi

@@ -0,0 +1,13 @@
+from _typeshed import Incomplete
+
+from antlr4.BufferedTokenStream import BufferedTokenStream as BufferedTokenStream
+from antlr4.Lexer import Lexer as Lexer
+from antlr4.Token import Token as Token
+
+class CommonTokenStream(BufferedTokenStream):
+    channel: Incomplete
+    def __init__(self, lexer: Lexer, channel: int = 0) -> None: ...
+    def adjustSeekIndex(self, i: int) -> int: ...
+    def LB(self, k: int) -> Token | None: ...
+    def LT(self, k: int) -> Token | None: ...
+    def getNumberOfOnChannelTokens(self) -> int: ...

types-antlr4-python3-runtime-4.13.0.20240116/antlr4-stubs/FileStream.pyi

@@ -0,0 +1,8 @@
+from _typeshed import Incomplete
+
+from antlr4.InputStream import InputStream as InputStream
+
+class FileStream(InputStream):
+    fileName: Incomplete
+    def __init__(self, fileName: str, encoding: str = "ascii", errors: str = "strict") -> None: ...
+    def readDataFrom(self, fileName: str, encoding: str, errors: str = "strict"): ...

types-antlr4-python3-runtime-4.13.0.20240116/antlr4-stubs/InputStream.pyi

@@ -0,0 +1,21 @@
+from _typeshed import Incomplete
+
+from antlr4.Token import Token as Token
+
+class InputStream:
+    name: str
+    strdata: Incomplete
+    data: Incomplete
+    def __init__(self, data: str) -> None: ...
+    @property
+    def index(self): ...
+    @property
+    def size(self): ...
+    def reset(self) -> None: ...
+    def consume(self) -> None: ...
+    def LA(self, offset: int): ...
+    def LT(self, offset: int): ...
+    def mark(self): ...
+    def release(self, marker: int): ...
+    def seek(self, _index: int): ...
+    def getText(self, start: int, stop: int): ...

types-antlr4-python3-runtime-4.13.0.20240116/antlr4-stubs/IntervalSet.pyi

@@ -0,0 +1,19 @@
+from antlr4.Token import Token as Token
+
+class IntervalSet:
+    intervals: list[range] | None
+    readonly: bool
+    def __init__(self) -> None: ...
+    def __iter__(self): ...
+    def __getitem__(self, item): ...
+    def addOne(self, v: int): ...
+    def addRange(self, v: range): ...
+    def addSet(self, other: IntervalSet): ...
+    def reduce(self, k: int): ...
+    def complement(self, start: int, stop: int): ...
+    def __contains__(self, item) -> bool: ...
+    def __len__(self) -> int: ...
+    def removeRange(self, v) -> None: ...
+    def removeOne(self, v) -> None: ...
+    def toString(self, literalNames: list[str], symbolicNames: list[str]): ...
+    def elementName(self, literalNames: list[str], symbolicNames: list[str], a: int): ...

types-antlr4-python3-runtime-4.13.0.20240116/antlr4-stubs/LL1Analyzer.pyi

@@ -0,0 +1,26 @@
+from _typeshed import Incomplete
+
+from antlr4.atn.ATN import ATN as ATN
+from antlr4.atn.ATNConfig import ATNConfig as ATNConfig
+from antlr4.atn.ATNState import ATNState as ATNState, RuleStopState as RuleStopState
+from antlr4.atn.Transition import (
+    AbstractPredicateTransition as AbstractPredicateTransition,
+    NotSetTransition as NotSetTransition,
+    RuleTransition as RuleTransition,
+    WildcardTransition as WildcardTransition,
+)
+from antlr4.IntervalSet import IntervalSet as IntervalSet
+from antlr4.PredictionContext import (
+    PredictionContext as PredictionContext,
+    PredictionContextFromRuleContext as PredictionContextFromRuleContext,
+    SingletonPredictionContext as SingletonPredictionContext,
+)
+from antlr4.RuleContext import RuleContext as RuleContext
+from antlr4.Token import Token as Token
+
+class LL1Analyzer:
+    HIT_PRED: Incomplete
+    atn: Incomplete
+    def __init__(self, atn: ATN) -> None: ...
+    def getDecisionLookahead(self, s: ATNState): ...
+    def LOOK(self, s: ATNState, stopState: ATNState | None = None, ctx: RuleContext | None = None): ...

types-antlr4-python3-runtime-4.13.0.20240116/antlr4-stubs/Lexer.pyi

@@ -0,0 +1,64 @@
+from _typeshed import Incomplete
+from typing import TextIO
+
+from antlr4.atn.LexerATNSimulator import LexerATNSimulator as LexerATNSimulator
+from antlr4.CommonTokenFactory import CommonTokenFactory as CommonTokenFactory
+from antlr4.error.Errors import (
+    IllegalStateException as IllegalStateException,
+    LexerNoViableAltException as LexerNoViableAltException,
+    RecognitionException as RecognitionException,
+)
+from antlr4.InputStream import InputStream as InputStream
+from antlr4.Recognizer import Recognizer as Recognizer
+from antlr4.Token import Token as Token
+
+class TokenSource: ...
+
+class Lexer(Recognizer, TokenSource):
+    DEFAULT_MODE: int
+    MORE: int
+    SKIP: int
+    DEFAULT_TOKEN_CHANNEL: Incomplete
+    HIDDEN: Incomplete
+    MIN_CHAR_VALUE: int
+    MAX_CHAR_VALUE: int
+    def __init__(self, input: InputStream, output: TextIO = ...) -> None: ...
+    def reset(self) -> None: ...
+    def nextToken(self): ...
+    def skip(self) -> None: ...
+    def more(self) -> None: ...
+    def mode(self, m: int): ...
+    def pushMode(self, m: int): ...
+    def popMode(self): ...
+    @property
+    def inputStream(self): ...
+    @inputStream.setter
+    def inputStream(self, input: InputStream): ...
+    @property
+    def sourceName(self): ...
+    def emitToken(self, token: Token): ...
+    def emit(self): ...
+    def emitEOF(self): ...
+    @property
+    def type(self): ...
+    @type.setter
+    def type(self, type: int): ...
+    @property
+    def line(self): ...
+    @line.setter
+    def line(self, line: int): ...
+    @property
+    def column(self): ...
+    @column.setter
+    def column(self, column: int): ...
+    def getCharIndex(self): ...
+    @property
+    def text(self): ...
+    @text.setter
+    def text(self, txt: str): ...
+    def getAllTokens(self): ...
+    def notifyListeners(self, e: LexerNoViableAltException): ...
+    def getErrorDisplay(self, s: str): ...
+    def getErrorDisplayForChar(self, c: str): ...
+    def getCharErrorDisplay(self, c: str): ...
+    def recover(self, re: RecognitionException): ...

types-antlr4-python3-runtime-4.13.0.20240116/antlr4-stubs/ListTokenSource.pyi

@@ -0,0 +1,19 @@
+from _typeshed import Incomplete
+
+from antlr4.CommonTokenFactory import CommonTokenFactory as CommonTokenFactory
+from antlr4.Lexer import TokenSource as TokenSource
+from antlr4.Token import Token as Token
+
+class ListTokenSource(TokenSource):
+    tokens: Incomplete
+    sourceName: Incomplete
+    pos: int
+    eofToken: Incomplete
+    def __init__(self, tokens: list[Token], sourceName: str | None = None) -> None: ...
+    @property
+    def column(self): ...
+    def nextToken(self): ...
+    @property
+    def line(self): ...
+    def getInputStream(self): ...
+    def getSourceName(self): ...

types-antlr4-python3-runtime-4.13.0.20240116/antlr4-stubs/METADATA.toml

@@ -0,0 +1,6 @@
+version = "4.13.*"
+upstream_repository = "https://github.com/antlr/antlr4"
+
+[tool.stubtest]
+ignore_missing_stub = true
+platforms = ["linux", "win32"]

types-antlr4-python3-runtime-4.13.0.20240116/antlr4-stubs/Parser.pyi

@@ -0,0 +1,74 @@
+from _typeshed import Incomplete
+from typing import TextIO
+
+from antlr4.atn.ATNDeserializationOptions import ATNDeserializationOptions as ATNDeserializationOptions
+from antlr4.atn.ATNDeserializer import ATNDeserializer as ATNDeserializer
+from antlr4.BufferedTokenStream import TokenStream as TokenStream
+from antlr4.CommonTokenFactory import TokenFactory as TokenFactory
+from antlr4.error.Errors import (
+    RecognitionException as RecognitionException,
+    UnsupportedOperationException as UnsupportedOperationException,
+)
+from antlr4.error.ErrorStrategy import DefaultErrorStrategy as DefaultErrorStrategy
+from antlr4.InputStream import InputStream as InputStream
+from antlr4.Lexer import Lexer as Lexer
+from antlr4.ParserRuleContext import ParserRuleContext as ParserRuleContext
+from antlr4.Recognizer import Recognizer as Recognizer
+from antlr4.RuleContext import RuleContext as RuleContext
+from antlr4.Token import Token as Token
+from antlr4.tree.ParseTreePatternMatcher import ParseTreePatternMatcher as ParseTreePatternMatcher
+from antlr4.tree.Tree import ErrorNode as ErrorNode, ParseTreeListener as ParseTreeListener, TerminalNode as TerminalNode
+
+class TraceListener(ParseTreeListener):
+    def __init__(self, parser) -> None: ...
+    def enterEveryRule(self, ctx) -> None: ...
+    def visitTerminal(self, node) -> None: ...
+    def visitErrorNode(self, node) -> None: ...
+    def exitEveryRule(self, ctx) -> None: ...
+
+class Parser(Recognizer):
+    bypassAltsAtnCache: Incomplete
+    buildParseTrees: bool
+    def __init__(self, input: TokenStream, output: TextIO = ...) -> None: ...
+    def reset(self) -> None: ...
+    def match(self, ttype: int): ...
+    def matchWildcard(self): ...
+    def getParseListeners(self): ...
+    def addParseListener(self, listener: ParseTreeListener): ...
+    def removeParseListener(self, listener: ParseTreeListener): ...
+    def removeParseListeners(self) -> None: ...
+    def triggerEnterRuleEvent(self) -> None: ...
+    def triggerExitRuleEvent(self) -> None: ...
+    def getNumberOfSyntaxErrors(self): ...
+    def getTokenFactory(self): ...
+    def setTokenFactory(self, factory: TokenFactory): ...
+    def getATNWithBypassAlts(self): ...
+    def compileParseTreePattern(self, pattern: str, patternRuleIndex: int, lexer: Lexer | None = None): ...
+    def getInputStream(self): ...
+    def setInputStream(self, input: InputStream): ...
+    def getTokenStream(self): ...
+    def setTokenStream(self, input: TokenStream): ...
+    def getCurrentToken(self): ...
+    def notifyErrorListeners(self, msg: str, offendingToken: Token | None = None, e: RecognitionException | None = None): ...
+    def consume(self): ...
+    def addContextToParseTree(self) -> None: ...
+    state: Incomplete
+    def enterRule(self, localctx: ParserRuleContext, state: int, ruleIndex: int): ...
+    def exitRule(self) -> None: ...
+    def enterOuterAlt(self, localctx: ParserRuleContext, altNum: int): ...
+    def getPrecedence(self): ...
+    def enterRecursionRule(self, localctx: ParserRuleContext, state: int, ruleIndex: int, precedence: int): ...
+    def pushNewRecursionContext(self, localctx: ParserRuleContext, state: int, ruleIndex: int): ...
+    def unrollRecursionContexts(self, parentCtx: ParserRuleContext): ...
+    def getInvokingContext(self, ruleIndex: int): ...
+    def precpred(self, localctx: RuleContext, precedence: int): ...
+    def inContext(self, context: str): ...
+    def isExpectedToken(self, symbol: int): ...
+    def getExpectedTokens(self): ...
+    def getExpectedTokensWithinCurrentRule(self): ...
+    def getRuleIndex(self, ruleName: str): ...
+    def getRuleInvocationStack(self, p: RuleContext | None = None): ...
+    def getDFAStrings(self): ...
+    def dumpDFA(self) -> None: ...
+    def getSourceName(self): ...
+    def setTrace(self, trace: bool): ...

types-antlr4-python3-runtime-4.13.0.20240116/antlr4-stubs/ParserInterpreter.pyi

@@ -0,0 +1,36 @@
+from _typeshed import Incomplete
+
+from antlr4.atn.ATN import ATN as ATN
+from antlr4.atn.ATNState import ATNState as ATNState, LoopEndState as LoopEndState, StarLoopEntryState as StarLoopEntryState
+from antlr4.atn.ParserATNSimulator import ParserATNSimulator as ParserATNSimulator
+from antlr4.atn.Transition import Transition as Transition
+from antlr4.BufferedTokenStream import TokenStream as TokenStream
+from antlr4.dfa.DFA import DFA as DFA
+from antlr4.error.Errors import (
+    FailedPredicateException as FailedPredicateException,
+    RecognitionException as RecognitionException,
+    UnsupportedOperationException as UnsupportedOperationException,
+)
+from antlr4.Lexer import Lexer as Lexer
+from antlr4.Parser import Parser as Parser
+from antlr4.ParserRuleContext import InterpreterRuleContext as InterpreterRuleContext, ParserRuleContext as ParserRuleContext
+from antlr4.PredictionContext import PredictionContextCache as PredictionContextCache
+from antlr4.Token import Token as Token
+
+class ParserInterpreter(Parser):
+    grammarFileName: Incomplete
+    atn: Incomplete
+    tokenNames: Incomplete
+    ruleNames: Incomplete
+    decisionToDFA: Incomplete
+    sharedContextCache: Incomplete
+    pushRecursionContextStates: Incomplete
+    def __init__(
+        self, grammarFileName: str, tokenNames: list[str], ruleNames: list[str], atn: ATN, input: TokenStream
+    ) -> None: ...
+    state: Incomplete
+    def parse(self, startRuleIndex: int): ...
+    def enterRecursionRule(self, localctx: ParserRuleContext, state: int, ruleIndex: int, precedence: int): ...
+    def getATNState(self): ...
+    def visitState(self, p: ATNState): ...
+    def visitRuleStopState(self, p: ATNState): ...

types-antlr4-python3-runtime-4.13.0.20240116/antlr4-stubs/ParserRuleContext.pyi

@@ -0,0 +1,41 @@
+from _typeshed import Incomplete
+from collections.abc import Generator
+
+from antlr4.RuleContext import RuleContext as RuleContext
+from antlr4.Token import Token as Token
+from antlr4.tree.Tree import (
+    INVALID_INTERVAL as INVALID_INTERVAL,
+    ErrorNodeImpl as ErrorNodeImpl,
+    ParseTree as ParseTree,
+    ParseTreeListener as ParseTreeListener,
+    TerminalNode as TerminalNode,
+    TerminalNodeImpl as TerminalNodeImpl,
+)
+
+class ParserRuleContext(RuleContext):
+    children: Incomplete
+    start: Incomplete
+    stop: Incomplete
+    exception: Incomplete
+    def __init__(self, parent: ParserRuleContext | None = None, invokingStateNumber: int | None = None) -> None: ...
+    parentCtx: Incomplete
+    invokingState: Incomplete
+    def copyFrom(self, ctx: ParserRuleContext): ...
+    def enterRule(self, listener: ParseTreeListener): ...
+    def exitRule(self, listener: ParseTreeListener): ...
+    def addChild(self, child: ParseTree): ...
+    def removeLastChild(self) -> None: ...
+    def addTokenNode(self, token: Token): ...
+    def addErrorNode(self, badToken: Token): ...
+    def getChild(self, i: int, ttype: type | None = None): ...
+    def getChildren(self, predicate: Incomplete | None = None) -> Generator[Incomplete, None, None]: ...
+    def getToken(self, ttype: int, i: int): ...
+    def getTokens(self, ttype: int): ...
+    def getTypedRuleContext(self, ctxType: type, i: int): ...
+    def getTypedRuleContexts(self, ctxType: type): ...
+    def getChildCount(self): ...
+    def getSourceInterval(self): ...
+
+class InterpreterRuleContext(ParserRuleContext):
+    ruleIndex: Incomplete
+    def __init__(self, parent: ParserRuleContext, invokingStateNumber: int, ruleIndex: int) -> None: ...

types-antlr4-python3-runtime-4.13.0.20240116/antlr4-stubs/PredictionContext.pyi

@@ -0,0 +1,87 @@
+from _typeshed import Incomplete, SupportsLenAndGetItem
+
+from antlr4.atn.ATN import ATN as ATN
+from antlr4.error.Errors import IllegalStateException as IllegalStateException
+from antlr4.RuleContext import RuleContext as RuleContext
+
+class PredictionContext:
+    EMPTY: Incomplete
+    EMPTY_RETURN_STATE: int
+    globalNodeCount: int
+    id = globalNodeCount
+    cachedHashCode: Incomplete
+    def __init__(self, cachedHashCode: int) -> None: ...
+    def __len__(self) -> int: ...
+    def isEmpty(self): ...
+    def hasEmptyPath(self): ...
+    def getReturnState(self, index: int): ...
+    def __hash__(self): ...
+
+def calculateHashCode(parent: PredictionContext, returnState: int): ...
+def calculateListsHashCode(parents: list[PredictionContext], returnStates: list[int]): ...
+
+class PredictionContextCache:
+    cache: Incomplete
+    def __init__(self) -> None: ...
+    def add(self, ctx: PredictionContext): ...
+    def get(self, ctx: PredictionContext): ...
+    def __len__(self) -> int: ...
+
+class SingletonPredictionContext(PredictionContext):
+    @staticmethod
+    def create(parent: PredictionContext, returnState: int): ...
+    parentCtx: Incomplete
+    returnState: Incomplete
+    def __init__(self, parent: PredictionContext, returnState: int) -> None: ...
+    def __len__(self) -> int: ...
+    def getParent(self, index: int): ...
+    def getReturnState(self, index: int): ...
+    def __eq__(self, other): ...
+    def __hash__(self): ...
+
+class EmptyPredictionContext(SingletonPredictionContext):
+    def __init__(self) -> None: ...
+    def isEmpty(self): ...
+    def __eq__(self, other): ...
+    def __hash__(self): ...
+
+class ArrayPredictionContext(PredictionContext):
+    parents: Incomplete
+    returnStates: Incomplete
+    def __init__(self, parents: list[PredictionContext], returnStates: list[int]) -> None: ...
+    def isEmpty(self): ...
+    def __len__(self) -> int: ...
+    def getParent(self, index: int): ...
+    def getReturnState(self, index: int): ...
+    def __eq__(self, other): ...
+    def __hash__(self): ...
+
+def PredictionContextFromRuleContext(atn: ATN, outerContext: RuleContext | None = None): ...
+def merge(
+    a: PredictionContext,
+    b: PredictionContext,
+    rootIsWildcard: bool,
+    mergeCache: dict[tuple[Incomplete, Incomplete], SingletonPredictionContext] | None,
+): ...
+def mergeSingletons(
+    a: SingletonPredictionContext,
+    b: SingletonPredictionContext,
+    rootIsWildcard: bool,
+    mergeCache: dict[tuple[Incomplete, Incomplete], SingletonPredictionContext] | None,
+): ...
+def mergeRoot(a: SingletonPredictionContext, b: SingletonPredictionContext, rootIsWildcard: bool): ...
+def mergeArrays(
+    a: ArrayPredictionContext,
+    b: ArrayPredictionContext,
+    rootIsWildcard: bool,
+    mergeCache: dict[tuple[Incomplete, Incomplete], SingletonPredictionContext] | None,
+): ...
+def combineCommonParents(parents: SupportsLenAndGetItem[PredictionContext]): ...
+def getCachedPredictionContext(
+    context: PredictionContext, contextCache: PredictionContextCache, visited: dict[PredictionContext, PredictionContext]
+): ...
+def getAllContextNodes(
+    context: PredictionContext,
+    nodes: list[Incomplete] | None = None,
+    visited: dict[PredictionContext, PredictionContext] | None = None,
+): ...

types-antlr4-python3-runtime-4.13.0.20240116/antlr4-stubs/Recognizer.pyi

@@ -0,0 +1,27 @@
+from _typeshed import Incomplete
+
+from antlr4.error.ErrorListener import ConsoleErrorListener as ConsoleErrorListener, ProxyErrorListener as ProxyErrorListener
+from antlr4.RuleContext import RuleContext as RuleContext
+from antlr4.Token import Token as Token
+
+class Recognizer:
+    tokenTypeMapCache: Incomplete
+    ruleIndexMapCache: Incomplete
+    def __init__(self) -> None: ...
+    def extractVersion(self, version): ...
+    def checkVersion(self, toolVersion) -> None: ...
+    def addErrorListener(self, listener) -> None: ...
+    def removeErrorListener(self, listener) -> None: ...
+    def removeErrorListeners(self) -> None: ...
+    def getTokenTypeMap(self): ...
+    def getRuleIndexMap(self): ...
+    def getTokenType(self, tokenName: str): ...
+    def getErrorHeader(self, e): ...
+    def getTokenErrorDisplay(self, t: Token): ...
+    def getErrorListenerDispatch(self): ...
+    def sempred(self, localctx: RuleContext, ruleIndex: int, actionIndex: int): ...
+    def precpred(self, localctx: RuleContext, precedence: int): ...
+    @property
+    def state(self): ...
+    @state.setter
+    def state(self, atnState: int): ...

types-antlr4-python3-runtime-4.13.0.20240116/antlr4-stubs/RuleContext.pyi

@@ -0,0 +1,28 @@
+from _typeshed import Incomplete
+from collections.abc import Generator
+
+from antlr4.tree.Tree import INVALID_INTERVAL as INVALID_INTERVAL, ParseTreeVisitor as ParseTreeVisitor, RuleNode as RuleNode
+from antlr4.tree.Trees import Trees as Trees
+
+Parser: Incomplete
+
+class RuleContext(RuleNode):
+    EMPTY: Incomplete
+    parentCtx: Incomplete
+    invokingState: Incomplete
+    def __init__(self, parent: RuleContext | None = None, invokingState: int = -1) -> None: ...
+    def depth(self): ...
+    def isEmpty(self): ...
+    def getSourceInterval(self): ...
+    def getRuleContext(self): ...
+    def getPayload(self): ...
+    def getText(self): ...
+    def getRuleIndex(self): ...
+    def getAltNumber(self): ...
+    def setAltNumber(self, altNumber: int): ...
+    def getChild(self, i: int): ...
+    def getChildCount(self): ...
+    def getChildren(self) -> Generator[Incomplete, None, None]: ...
+    def accept(self, visitor: ParseTreeVisitor): ...
+    def toStringTree(self, ruleNames: list[Incomplete] | None = None, recog: Parser | None = None): ...
+    def toString(self, ruleNames: list[Incomplete], stop: RuleContext) -> str: ...

types-antlr4-python3-runtime-4.13.0.20240116/antlr4-stubs/StdinStream.pyi

@@ -0,0 +1,4 @@
+from antlr4.InputStream import InputStream as InputStream
+
+class StdinStream(InputStream):
+    def __init__(self, encoding: str = "ascii", errors: str = "strict") -> None: ...

types-antlr4-python3-runtime-4.13.0.20240116/antlr4-stubs/Token.pyi

@@ -0,0 +1,48 @@
+from _typeshed import Incomplete
+
+class Token:
+    INVALID_TYPE: int
+    EPSILON: int
+    MIN_USER_TOKEN_TYPE: int
+    EOF: int
+    DEFAULT_CHANNEL: int
+    HIDDEN_CHANNEL: int
+    source: Incomplete
+    type: Incomplete
+    channel: Incomplete
+    start: Incomplete
+    stop: Incomplete
+    tokenIndex: Incomplete
+    line: Incomplete
+    column: Incomplete
+    def __init__(self) -> None: ...
+    @property
+    def text(self): ...
+    @text.setter
+    def text(self, text: str): ...
+    def getTokenSource(self): ...
+    def getInputStream(self): ...
+
+class CommonToken(Token):
+    EMPTY_SOURCE: Incomplete
+    source: Incomplete
+    type: Incomplete
+    channel: Incomplete
+    start: Incomplete
+    stop: Incomplete
+    tokenIndex: int
+    line: Incomplete
+    column: Incomplete
+    def __init__(
+        self,
+        source: tuple[Incomplete, Incomplete] = (None, None),
+        type: int | None = None,
+        channel: int = 0,
+        start: int = -1,
+        stop: int = -1,
+    ) -> None: ...
+    def clone(self): ...
+    @property
+    def text(self): ...
+    @text.setter
+    def text(self, text: str): ...