Add files using upload-large-folder tool

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/atn/LexerATNSimulator.py

@@ -0,0 +1,570 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#/
+
+# When we hit an accept state in either the DFA or the ATN, we
+#  have to notify the character stream to start buffering characters
+#  via {@link IntStream#mark} and record the current state. The current sim state
+#  includes the current index into the input, the current line,
+#  and current character position in that line. Note that the Lexer is
+#  tracking the starting line and characterization of the token. These
+#  variables track the "state" of the simulator when it hits an accept state.
+#
+#  <p>We track these variables separately for the DFA and ATN simulation
+#  because the DFA simulation often has to fail over to the ATN
+#  simulation. If the ATN simulation fails, we need the DFA to fall
+#  back to its previously accepted state, if any. If the ATN succeeds,
+#  then the ATN does the accept and the DFA simulator that invoked it
+#  can simply return the predicted token type.</p>
+#/
+
+from antlr4.PredictionContext import PredictionContextCache, SingletonPredictionContext, PredictionContext
+from antlr4.InputStream import InputStream
+from antlr4.Token import Token
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNConfig import LexerATNConfig
+from antlr4.atn.ATNSimulator import ATNSimulator
+from antlr4.atn.ATNConfigSet import ATNConfigSet, OrderedATNConfigSet
+from antlr4.atn.ATNState import RuleStopState, ATNState
+from antlr4.atn.LexerActionExecutor import LexerActionExecutor
+from antlr4.atn.Transition import Transition
+from antlr4.dfa.DFAState import DFAState
+from antlr4.error.Errors import LexerNoViableAltException, UnsupportedOperationException
+
+class SimState(object):
+    __slots__ = ('index', 'line', 'column', 'dfaState')
+
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self.index = -1
+        self.line = 0
+        self.column = -1
+        self.dfaState = None
+
+# need forward declaration
+Lexer = None
+LexerATNSimulator = None
+
+class LexerATNSimulator(ATNSimulator):
+    __slots__ = (
+        'decisionToDFA', 'recog', 'startIndex', 'line', 'column', 'mode',
+        'DEFAULT_MODE', 'MAX_CHAR_VALUE', 'prevAccept'
+    )
+
+    debug = False
+    dfa_debug = False
+
+    MIN_DFA_EDGE = 0
+    MAX_DFA_EDGE = 127 # forces unicode to stay in ATN
+
+    ERROR = None
+
+    def __init__(self, recog:Lexer, atn:ATN, decisionToDFA:list, sharedContextCache:PredictionContextCache):
+        super().__init__(atn, sharedContextCache)
+        self.decisionToDFA = decisionToDFA
+        self.recog = recog
+        # The current token's starting index into the character stream.
+        #  Shared across DFA to ATN simulation in case the ATN fails and the
+        #  DFA did not have a previous accept state. In this case, we use the
+        #  ATN-generated exception object.
+        self.startIndex = -1
+        # line number 1..n within the input#/
+        self.line = 1
+        # The index of the character relative to the beginning of the line 0..n-1#/
+        self.column = 0
+        from antlr4.Lexer import Lexer
+        self.mode = Lexer.DEFAULT_MODE
+        # Cache Lexer properties to avoid further imports
+        self.DEFAULT_MODE = Lexer.DEFAULT_MODE
+        self.MAX_CHAR_VALUE = Lexer.MAX_CHAR_VALUE
+        # Used during DFA/ATN exec to record the most recent accept configuration info
+        self.prevAccept = SimState()
+
+
+    def copyState(self, simulator:LexerATNSimulator ):
+        self.column = simulator.column
+        self.line = simulator.line
+        self.mode = simulator.mode
+        self.startIndex = simulator.startIndex
+
+    def match(self, input:InputStream , mode:int):
+        self.mode = mode
+        mark = input.mark()
+        try:
+            self.startIndex = input.index
+            self.prevAccept.reset()
+            dfa = self.decisionToDFA[mode]
+            if dfa.s0 is None:
+                return self.matchATN(input)
+            else:
+                return self.execATN(input, dfa.s0)
+        finally:
+            input.release(mark)
+
+    def reset(self):
+        self.prevAccept.reset()
+        self.startIndex = -1
+        self.line = 1
+        self.column = 0
+        self.mode = self.DEFAULT_MODE
+
+    def matchATN(self, input:InputStream):
+        startState = self.atn.modeToStartState[self.mode]
+
+        if LexerATNSimulator.debug:
+            print("matchATN mode " + str(self.mode) + " start: " + str(startState))
+
+        old_mode = self.mode
+        s0_closure = self.computeStartState(input, startState)
+        suppressEdge = s0_closure.hasSemanticContext
+        s0_closure.hasSemanticContext = False
+
+        next = self.addDFAState(s0_closure)
+        if not suppressEdge:
+            self.decisionToDFA[self.mode].s0 = next
+
+        predict = self.execATN(input, next)
+
+        if LexerATNSimulator.debug:
+            print("DFA after matchATN: " + str(self.decisionToDFA[old_mode].toLexerString()))
+
+        return predict
+
+    def execATN(self, input:InputStream, ds0:DFAState):
+        if LexerATNSimulator.debug:
+            print("start state closure=" + str(ds0.configs))
+
+        if ds0.isAcceptState:
+            # allow zero-length tokens
+            self.captureSimState(self.prevAccept, input, ds0)
+
+        t = input.LA(1)
+        s = ds0 # s is current/from DFA state
+
+        while True: # while more work
+            if LexerATNSimulator.debug:
+                print("execATN loop starting closure:", str(s.configs))
+
+            # As we move src->trg, src->trg, we keep track of the previous trg to
+            # avoid looking up the DFA state again, which is expensive.
+            # If the previous target was already part of the DFA, we might
+            # be able to avoid doing a reach operation upon t. If s!=null,
+            # it means that semantic predicates didn't prevent us from
+            # creating a DFA state. Once we know s!=null, we check to see if
+            # the DFA state has an edge already for t. If so, we can just reuse
+            # it's configuration set; there's no point in re-computing it.
+            # This is kind of like doing DFA simulation within the ATN
+            # simulation because DFA simulation is really just a way to avoid
+            # computing reach/closure sets. Technically, once we know that
+            # we have a previously added DFA state, we could jump over to
+            # the DFA simulator. But, that would mean popping back and forth
+            # a lot and making things more complicated algorithmically.
+            # This optimization makes a lot of sense for loops within DFA.
+            # A character will take us back to an existing DFA state
+            # that already has lots of edges out of it. e.g., .* in comments.
+            # print("Target for:" + str(s) + " and:" + str(t))
+            target = self.getExistingTargetState(s, t)
+            # print("Existing:" + str(target))
+            if target is None:
+                target = self.computeTargetState(input, s, t)
+                # print("Computed:" + str(target))
+
+            if target == self.ERROR:
+                break
+
+            # If this is a consumable input element, make sure to consume before
+            # capturing the accept state so the input index, line, and char
+            # position accurately reflect the state of the interpreter at the
+            # end of the token.
+            if t != Token.EOF:
+                self.consume(input)
+
+            if target.isAcceptState:
+                self.captureSimState(self.prevAccept, input, target)
+                if t == Token.EOF:
+                    break
+
+            t = input.LA(1)
+
+            s = target # flip; current DFA target becomes new src/from state
+
+        return self.failOrAccept(self.prevAccept, input, s.configs, t)
+
+    # Get an existing target state for an edge in the DFA. If the target state
+    # for the edge has not yet been computed or is otherwise not available,
+    # this method returns {@code null}.
+    #
+    # @param s The current DFA state
+    # @param t The next input symbol
+    # @return The existing target DFA state for the given input symbol
+    # {@code t}, or {@code null} if the target state for this edge is not
+    # already cached
+    def getExistingTargetState(self, s:DFAState, t:int):
+        if s.edges is None or t < self.MIN_DFA_EDGE or t > self.MAX_DFA_EDGE:
+            return None
+
+        target = s.edges[t - self.MIN_DFA_EDGE]
+        if LexerATNSimulator.debug and target is not None:
+            print("reuse state", str(s.stateNumber), "edge to", str(target.stateNumber))
+
+        return target
+
+    # Compute a target state for an edge in the DFA, and attempt to add the
+    # computed state and corresponding edge to the DFA.
+    #
+    # @param input The input stream
+    # @param s The current DFA state
+    # @param t The next input symbol
+    #
+    # @return The computed target DFA state for the given input symbol
+    # {@code t}. If {@code t} does not lead to a valid DFA state, this method
+    # returns {@link #ERROR}.
+    def computeTargetState(self, input:InputStream, s:DFAState, t:int):
+        reach = OrderedATNConfigSet()
+
+        # if we don't find an existing DFA state
+        # Fill reach starting from closure, following t transitions
+        self.getReachableConfigSet(input, s.configs, reach, t)
+
+        if len(reach)==0: # we got nowhere on t from s
+            if not reach.hasSemanticContext:
+                # we got nowhere on t, don't throw out this knowledge; it'd
+                # cause a failover from DFA later.
+               self. addDFAEdge(s, t, self.ERROR)
+
+            # stop when we can't match any more char
+            return self.ERROR
+
+        # Add an edge from s to target DFA found/created for reach
+        return self.addDFAEdge(s, t, cfgs=reach)
+
+    def failOrAccept(self, prevAccept:SimState , input:InputStream, reach:ATNConfigSet, t:int):
+        if self.prevAccept.dfaState is not None:
+            lexerActionExecutor = prevAccept.dfaState.lexerActionExecutor
+            self.accept(input, lexerActionExecutor, self.startIndex, prevAccept.index, prevAccept.line, prevAccept.column)
+            return prevAccept.dfaState.prediction
+        else:
+            # if no accept and EOF is first char, return EOF
+            if t==Token.EOF and input.index==self.startIndex:
+                return Token.EOF
+            raise LexerNoViableAltException(self.recog, input, self.startIndex, reach)
+
+    # Given a starting configuration set, figure out all ATN configurations
+    #  we can reach upon input {@code t}. Parameter {@code reach} is a return
+    #  parameter.
+    def getReachableConfigSet(self, input:InputStream, closure:ATNConfigSet, reach:ATNConfigSet, t:int):
+        # this is used to skip processing for configs which have a lower priority
+        # than a config that already reached an accept state for the same rule
+        skipAlt = ATN.INVALID_ALT_NUMBER
+        for cfg in closure:
+            currentAltReachedAcceptState = ( cfg.alt == skipAlt )
+            if currentAltReachedAcceptState and cfg.passedThroughNonGreedyDecision:
+                continue
+
+            if LexerATNSimulator.debug:
+                print("testing", self.getTokenName(t), "at",  str(cfg))
+
+            for trans in cfg.state.transitions:          # for each transition
+                target = self.getReachableTarget(trans, t)
+                if target is not None:
+                    lexerActionExecutor = cfg.lexerActionExecutor
+                    if lexerActionExecutor is not None:
+                        lexerActionExecutor = lexerActionExecutor.fixOffsetBeforeMatch(input.index - self.startIndex)
+
+                    treatEofAsEpsilon = (t == Token.EOF)
+                    config = LexerATNConfig(state=target, lexerActionExecutor=lexerActionExecutor, config=cfg)
+                    if self.closure(input, config, reach, currentAltReachedAcceptState, True, treatEofAsEpsilon):
+                        # any remaining configs for this alt have a lower priority than
+                        # the one that just reached an accept state.
+                        skipAlt = cfg.alt
+
+    def accept(self, input:InputStream, lexerActionExecutor:LexerActionExecutor, startIndex:int, index:int, line:int, charPos:int):
+        if LexerATNSimulator.debug:
+            print("ACTION", lexerActionExecutor)
+
+        # seek to after last char in token
+        input.seek(index)
+        self.line = line
+        self.column = charPos
+
+        if lexerActionExecutor is not None and self.recog is not None:
+            lexerActionExecutor.execute(self.recog, input, startIndex)
+
+    def getReachableTarget(self, trans:Transition, t:int):
+        if trans.matches(t, 0, self.MAX_CHAR_VALUE):
+            return trans.target
+        else:
+            return None
+
+    def computeStartState(self, input:InputStream, p:ATNState):
+        initialContext = PredictionContext.EMPTY
+        configs = OrderedATNConfigSet()
+        for i in range(0,len(p.transitions)):
+            target = p.transitions[i].target
+            c = LexerATNConfig(state=target, alt=i+1, context=initialContext)
+            self.closure(input, c, configs, False, False, False)
+        return configs
+
+    # Since the alternatives within any lexer decision are ordered by
+    # preference, this method stops pursuing the closure as soon as an accept
+    # state is reached. After the first accept state is reached by depth-first
+    # search from {@code config}, all other (potentially reachable) states for
+    # this rule would have a lower priority.
+    #
+    # @return {@code true} if an accept state is reached, otherwise
+    # {@code false}.
+    def closure(self, input:InputStream, config:LexerATNConfig, configs:ATNConfigSet, currentAltReachedAcceptState:bool,
+                speculative:bool, treatEofAsEpsilon:bool):
+        if LexerATNSimulator.debug:
+            print("closure(" + str(config) + ")")
+
+        if isinstance( config.state, RuleStopState ):
+            if LexerATNSimulator.debug:
+                if self.recog is not None:
+                    print("closure at", self.recog.symbolicNames[config.state.ruleIndex],  "rule stop", str(config))
+                else:
+                    print("closure at rule stop", str(config))
+
+            if config.context is None or config.context.hasEmptyPath():
+                if config.context is None or config.context.isEmpty():
+                    configs.add(config)
+                    return True
+                else:
+                    configs.add(LexerATNConfig(state=config.state, config=config, context=PredictionContext.EMPTY))
+                    currentAltReachedAcceptState = True
+
+            if config.context is not None and not config.context.isEmpty():
+                for i in range(0,len(config.context)):
+                    if config.context.getReturnState(i) != PredictionContext.EMPTY_RETURN_STATE:
+                        newContext = config.context.getParent(i) # "pop" return state
+                        returnState = self.atn.states[config.context.getReturnState(i)]
+                        c = LexerATNConfig(state=returnState, config=config, context=newContext)
+                        currentAltReachedAcceptState = self.closure(input, c, configs,
+                                    currentAltReachedAcceptState, speculative, treatEofAsEpsilon)
+
+            return currentAltReachedAcceptState
+
+        # optimization
+        if not config.state.epsilonOnlyTransitions:
+            if not currentAltReachedAcceptState or not config.passedThroughNonGreedyDecision:
+                configs.add(config)
+
+        for t in config.state.transitions:
+            c = self.getEpsilonTarget(input, config, t, configs, speculative, treatEofAsEpsilon)
+            if c is not None:
+                currentAltReachedAcceptState = self.closure(input, c, configs, currentAltReachedAcceptState, speculative, treatEofAsEpsilon)
+
+        return currentAltReachedAcceptState
+
+    # side-effect: can alter configs.hasSemanticContext
+    def getEpsilonTarget(self, input:InputStream, config:LexerATNConfig, t:Transition, configs:ATNConfigSet,
+                                           speculative:bool, treatEofAsEpsilon:bool):
+        c = None
+        if t.serializationType==Transition.RULE:
+                newContext = SingletonPredictionContext.create(config.context, t.followState.stateNumber)
+                c = LexerATNConfig(state=t.target, config=config, context=newContext)
+
+        elif t.serializationType==Transition.PRECEDENCE:
+                raise UnsupportedOperationException("Precedence predicates are not supported in lexers.")
+
+        elif t.serializationType==Transition.PREDICATE:
+                #  Track traversing semantic predicates. If we traverse,
+                # we cannot add a DFA state for this "reach" computation
+                # because the DFA would not test the predicate again in the
+                # future. Rather than creating collections of semantic predicates
+                # like v3 and testing them on prediction, v4 will test them on the
+                # fly all the time using the ATN not the DFA. This is slower but
+                # semantically it's not used that often. One of the key elements to
+                # this predicate mechanism is not adding DFA states that see
+                # predicates immediately afterwards in the ATN. For example,
+
+                # a : ID {p1}? | ID {p2}? ;
+
+                # should create the start state for rule 'a' (to save start state
+                # competition), but should not create target of ID state. The
+                # collection of ATN states the following ID references includes
+                # states reached by traversing predicates. Since this is when we
+                # test them, we cannot cash the DFA state target of ID.
+
+                if LexerATNSimulator.debug:
+                    print("EVAL rule "+ str(t.ruleIndex) + ":" + str(t.predIndex))
+                configs.hasSemanticContext = True
+                if self.evaluatePredicate(input, t.ruleIndex, t.predIndex, speculative):
+                    c = LexerATNConfig(state=t.target, config=config)
+
+        elif t.serializationType==Transition.ACTION:
+                if config.context is None or config.context.hasEmptyPath():
+                    # execute actions anywhere in the start rule for a token.
+                    #
+                    # TODO: if the entry rule is invoked recursively, some
+                    # actions may be executed during the recursive call. The
+                    # problem can appear when hasEmptyPath() is true but
+                    # isEmpty() is false. In this case, the config needs to be
+                    # split into two contexts - one with just the empty path
+                    # and another with everything but the empty path.
+                    # Unfortunately, the current algorithm does not allow
+                    # getEpsilonTarget to return two configurations, so
+                    # additional modifications are needed before we can support
+                    # the split operation.
+                    lexerActionExecutor = LexerActionExecutor.append(config.lexerActionExecutor,
+                                    self.atn.lexerActions[t.actionIndex])
+                    c = LexerATNConfig(state=t.target, config=config, lexerActionExecutor=lexerActionExecutor)
+
+                else:
+                    # ignore actions in referenced rules
+                    c = LexerATNConfig(state=t.target, config=config)
+
+        elif t.serializationType==Transition.EPSILON:
+            c = LexerATNConfig(state=t.target, config=config)
+
+        elif t.serializationType in [ Transition.ATOM, Transition.RANGE, Transition.SET ]:
+            if treatEofAsEpsilon:
+                if t.matches(Token.EOF, 0, self.MAX_CHAR_VALUE):
+                    c = LexerATNConfig(state=t.target, config=config)
+
+        return c
+
+    # Evaluate a predicate specified in the lexer.
+    #
+    # <p>If {@code speculative} is {@code true}, this method was called before
+    # {@link #consume} for the matched character. This method should call
+    # {@link #consume} before evaluating the predicate to ensure position
+    # sensitive values, including {@link Lexer#getText}, {@link Lexer#getLine},
+    # and {@link Lexer#getcolumn}, properly reflect the current
+    # lexer state. This method should restore {@code input} and the simulator
+    # to the original state before returning (i.e. undo the actions made by the
+    # call to {@link #consume}.</p>
+    #
+    # @param input The input stream.
+    # @param ruleIndex The rule containing the predicate.
+    # @param predIndex The index of the predicate within the rule.
+    # @param speculative {@code true} if the current index in {@code input} is
+    # one character before the predicate's location.
+    #
+    # @return {@code true} if the specified predicate evaluates to
+    # {@code true}.
+    #/
+    def evaluatePredicate(self, input:InputStream, ruleIndex:int, predIndex:int, speculative:bool):
+        # assume true if no recognizer was provided
+        if self.recog is None:
+            return True
+
+        if not speculative:
+            return self.recog.sempred(None, ruleIndex, predIndex)
+
+        savedcolumn = self.column
+        savedLine = self.line
+        index = input.index
+        marker = input.mark()
+        try:
+            self.consume(input)
+            return self.recog.sempred(None, ruleIndex, predIndex)
+        finally:
+            self.column = savedcolumn
+            self.line = savedLine
+            input.seek(index)
+            input.release(marker)
+
+    def captureSimState(self, settings:SimState, input:InputStream, dfaState:DFAState):
+        settings.index = input.index
+        settings.line = self.line
+        settings.column = self.column
+        settings.dfaState = dfaState
+
+    def addDFAEdge(self, from_:DFAState, tk:int, to:DFAState=None, cfgs:ATNConfigSet=None) -> DFAState:
+
+        if to is None and cfgs is not None:
+            # leading to this call, ATNConfigSet.hasSemanticContext is used as a
+            # marker indicating dynamic predicate evaluation makes this edge
+            # dependent on the specific input sequence, so the static edge in the
+            # DFA should be omitted. The target DFAState is still created since
+            # execATN has the ability to resynchronize with the DFA state cache
+            # following the predicate evaluation step.
+            #
+            # TJP notes: next time through the DFA, we see a pred again and eval.
+            # If that gets us to a previously created (but dangling) DFA
+            # state, we can continue in pure DFA mode from there.
+            #/
+            suppressEdge = cfgs.hasSemanticContext
+            cfgs.hasSemanticContext = False
+
+            to = self.addDFAState(cfgs)
+
+            if suppressEdge:
+                return to
+
+        # add the edge
+        if tk < self.MIN_DFA_EDGE or tk > self.MAX_DFA_EDGE:
+            # Only track edges within the DFA bounds
+            return to
+
+        if LexerATNSimulator.debug:
+            print("EDGE " + str(from_) + " -> " + str(to) + " upon "+ chr(tk))
+
+        if from_.edges is None:
+            #  make room for tokens 1..n and -1 masquerading as index 0
+            from_.edges = [ None ] * (self.MAX_DFA_EDGE - self.MIN_DFA_EDGE + 1)
+
+        from_.edges[tk - self.MIN_DFA_EDGE] = to # connect
+
+        return to
+
+
+    # Add a new DFA state if there isn't one with this set of
+    # configurations already. This method also detects the first
+    # configuration containing an ATN rule stop state. Later, when
+    # traversing the DFA, we will know which rule to accept.
+    def addDFAState(self, configs:ATNConfigSet) -> DFAState:
+
+        proposed = DFAState(configs=configs)
+        firstConfigWithRuleStopState = next((cfg for cfg in configs if isinstance(cfg.state, RuleStopState)), None)
+
+        if firstConfigWithRuleStopState is not None:
+            proposed.isAcceptState = True
+            proposed.lexerActionExecutor = firstConfigWithRuleStopState.lexerActionExecutor
+            proposed.prediction = self.atn.ruleToTokenType[firstConfigWithRuleStopState.state.ruleIndex]
+
+        dfa = self.decisionToDFA[self.mode]
+        existing = dfa.states.get(proposed, None)
+        if existing is not None:
+            return existing
+
+        newState = proposed
+
+        newState.stateNumber = len(dfa.states)
+        configs.setReadonly(True)
+        newState.configs = configs
+        dfa.states[newState] = newState
+        return newState
+
+    def getDFA(self, mode:int):
+        return self.decisionToDFA[mode]
+
+    # Get the text matched so far for the current token.
+    def getText(self, input:InputStream):
+        # index is first lookahead char, don't include.
+        return input.getText(self.startIndex, input.index-1)
+
+    def consume(self, input:InputStream):
+        curChar = input.LA(1)
+        if curChar==ord('\n'):
+            self.line += 1
+            self.column = 0
+        else:
+            self.column += 1
+        input.consume()
+
+    def getTokenName(self, t:int):
+        if t==-1:
+            return "EOF"
+        else:
+            return "'" + chr(t) + "'"
+
+
+LexerATNSimulator.ERROR = DFAState(0x7FFFFFFF, ATNConfigSet())
+
+del Lexer

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/atn/LexerAction.py

@@ -0,0 +1,298 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+ #
+
+from enum import IntEnum
+
+# need forward declaration
+Lexer = None
+
+
+class LexerActionType(IntEnum):
+
+    CHANNEL = 0     #The type of a {@link LexerChannelAction} action.
+    CUSTOM = 1      #The type of a {@link LexerCustomAction} action.
+    MODE = 2        #The type of a {@link LexerModeAction} action.
+    MORE = 3        #The type of a {@link LexerMoreAction} action.
+    POP_MODE = 4    #The type of a {@link LexerPopModeAction} action.
+    PUSH_MODE = 5   #The type of a {@link LexerPushModeAction} action.
+    SKIP = 6        #The type of a {@link LexerSkipAction} action.
+    TYPE = 7        #The type of a {@link LexerTypeAction} action.
+
+class LexerAction(object):
+    __slots__ = ('actionType', 'isPositionDependent')
+
+    def __init__(self, action:LexerActionType):
+        self.actionType = action
+        self.isPositionDependent = False
+
+    def __hash__(self):
+        return hash(self.actionType)
+
+    def __eq__(self, other):
+        return self is other
+
+
+#
+# Implements the {@code skip} lexer action by calling {@link Lexer#skip}.
+#
+# <p>The {@code skip} command does not have any parameters, so this action is
+# implemented as a singleton instance exposed by {@link #INSTANCE}.</p>
+class LexerSkipAction(LexerAction):
+
+    # Provides a singleton instance of this parameterless lexer action.
+    INSTANCE = None
+
+    def __init__(self):
+        super().__init__(LexerActionType.SKIP)
+
+    def execute(self, lexer:Lexer):
+        lexer.skip()
+
+    def __str__(self):
+        return "skip"
+
+LexerSkipAction.INSTANCE = LexerSkipAction()
+
+#  Implements the {@code type} lexer action by calling {@link Lexer#setType}
+# with the assigned type.
+class LexerTypeAction(LexerAction):
+    __slots__ = 'type'
+
+    def __init__(self, type:int):
+        super().__init__(LexerActionType.TYPE)
+        self.type = type
+
+    def execute(self, lexer:Lexer):
+        lexer.type = self.type
+
+    def __hash__(self):
+        return hash((self.actionType, self.type))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerTypeAction):
+            return False
+        else:
+            return self.type == other.type
+
+    def __str__(self):
+        return "type(" + str(self.type) + ")"
+
+
+# Implements the {@code pushMode} lexer action by calling
+# {@link Lexer#pushMode} with the assigned mode.
+class LexerPushModeAction(LexerAction):
+    __slots__ = 'mode'
+
+    def __init__(self, mode:int):
+        super().__init__(LexerActionType.PUSH_MODE)
+        self.mode = mode
+
+    # <p>This action is implemented by calling {@link Lexer#pushMode} with the
+    # value provided by {@link #getMode}.</p>
+    def execute(self, lexer:Lexer):
+        lexer.pushMode(self.mode)
+
+    def __hash__(self):
+        return hash((self.actionType, self.mode))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerPushModeAction):
+            return False
+        else:
+            return self.mode == other.mode
+
+    def __str__(self):
+        return "pushMode(" + str(self.mode) + ")"
+
+
+# Implements the {@code popMode} lexer action by calling {@link Lexer#popMode}.
+#
+# <p>The {@code popMode} command does not have any parameters, so this action is
+# implemented as a singleton instance exposed by {@link #INSTANCE}.</p>
+class LexerPopModeAction(LexerAction):
+
+    INSTANCE = None
+
+    def __init__(self):
+        super().__init__(LexerActionType.POP_MODE)
+
+    # <p>This action is implemented by calling {@link Lexer#popMode}.</p>
+    def execute(self, lexer:Lexer):
+        lexer.popMode()
+
+    def __str__(self):
+        return "popMode"
+
+LexerPopModeAction.INSTANCE = LexerPopModeAction()
+
+# Implements the {@code more} lexer action by calling {@link Lexer#more}.
+#
+# <p>The {@code more} command does not have any parameters, so this action is
+# implemented as a singleton instance exposed by {@link #INSTANCE}.</p>
+class LexerMoreAction(LexerAction):
+
+    INSTANCE = None
+
+    def __init__(self):
+        super().__init__(LexerActionType.MORE)
+
+    # <p>This action is implemented by calling {@link Lexer#popMode}.</p>
+    def execute(self, lexer:Lexer):
+        lexer.more()
+
+    def __str__(self):
+        return "more"
+
+LexerMoreAction.INSTANCE = LexerMoreAction()
+
+# Implements the {@code mode} lexer action by calling {@link Lexer#mode} with
+# the assigned mode.
+class LexerModeAction(LexerAction):
+    __slots__ = 'mode'
+
+    def __init__(self, mode:int):
+        super().__init__(LexerActionType.MODE)
+        self.mode = mode
+
+    # <p>This action is implemented by calling {@link Lexer#mode} with the
+    # value provided by {@link #getMode}.</p>
+    def execute(self, lexer:Lexer):
+        lexer.mode(self.mode)
+
+    def __hash__(self):
+        return hash((self.actionType, self.mode))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerModeAction):
+            return False
+        else:
+            return self.mode == other.mode
+
+    def __str__(self):
+        return "mode(" + str(self.mode) + ")"
+
+# Executes a custom lexer action by calling {@link Recognizer#action} with the
+# rule and action indexes assigned to the custom action. The implementation of
+# a custom action is added to the generated code for the lexer in an override
+# of {@link Recognizer#action} when the grammar is compiled.
+#
+# <p>This class may represent embedded actions created with the <code>{...}</code>
+# syntax in ANTLR 4, as well as actions created for lexer commands where the
+# command argument could not be evaluated when the grammar was compiled.</p>
+
+class LexerCustomAction(LexerAction):
+    __slots__ = ('ruleIndex', 'actionIndex')
+
+    # Constructs a custom lexer action with the specified rule and action
+    # indexes.
+    #
+    # @param ruleIndex The rule index to use for calls to
+    # {@link Recognizer#action}.
+    # @param actionIndex The action index to use for calls to
+    # {@link Recognizer#action}.
+    #/
+    def __init__(self, ruleIndex:int, actionIndex:int):
+        super().__init__(LexerActionType.CUSTOM)
+        self.ruleIndex = ruleIndex
+        self.actionIndex = actionIndex
+        self.isPositionDependent = True
+
+    # <p>Custom actions are implemented by calling {@link Lexer#action} with the
+    # appropriate rule and action indexes.</p>
+    def execute(self, lexer:Lexer):
+        lexer.action(None, self.ruleIndex, self.actionIndex)
+
+    def __hash__(self):
+        return hash((self.actionType, self.ruleIndex, self.actionIndex))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerCustomAction):
+            return False
+        else:
+            return self.ruleIndex == other.ruleIndex and self.actionIndex == other.actionIndex
+
+# Implements the {@code channel} lexer action by calling
+# {@link Lexer#setChannel} with the assigned channel.
+class LexerChannelAction(LexerAction):
+    __slots__ = 'channel'
+
+    # Constructs a new {@code channel} action with the specified channel value.
+    # @param channel The channel value to pass to {@link Lexer#setChannel}.
+    def __init__(self, channel:int):
+        super().__init__(LexerActionType.CHANNEL)
+        self.channel = channel
+
+    # <p>This action is implemented by calling {@link Lexer#setChannel} with the
+    # value provided by {@link #getChannel}.</p>
+    def execute(self, lexer:Lexer):
+        lexer._channel = self.channel
+
+    def __hash__(self):
+        return hash((self.actionType, self.channel))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerChannelAction):
+            return False
+        else:
+            return self.channel == other.channel
+
+    def __str__(self):
+        return "channel(" + str(self.channel) + ")"
+
+# This implementation of {@link LexerAction} is used for tracking input offsets
+# for position-dependent actions within a {@link LexerActionExecutor}.
+#
+# <p>This action is not serialized as part of the ATN, and is only required for
+# position-dependent lexer actions which appear at a location other than the
+# end of a rule. For more information about DFA optimizations employed for
+# lexer actions, see {@link LexerActionExecutor#append} and
+# {@link LexerActionExecutor#fixOffsetBeforeMatch}.</p>
+class LexerIndexedCustomAction(LexerAction):
+    __slots__ = ('offset', 'action')
+
+    # Constructs a new indexed custom action by associating a character offset
+    # with a {@link LexerAction}.
+    #
+    # <p>Note: This class is only required for lexer actions for which
+    # {@link LexerAction#isPositionDependent} returns {@code true}.</p>
+    #
+    # @param offset The offset into the input {@link CharStream}, relative to
+    # the token start index, at which the specified lexer action should be
+    # executed.
+    # @param action The lexer action to execute at a particular offset in the
+    # input {@link CharStream}.
+    def __init__(self, offset:int, action:LexerAction):
+        super().__init__(action.actionType)
+        self.offset = offset
+        self.action = action
+        self.isPositionDependent = True
+
+    # <p>This method calls {@link #execute} on the result of {@link #getAction}
+    # using the provided {@code lexer}.</p>
+    def execute(self, lexer:Lexer):
+        # assume the input stream position was properly set by the calling code
+        self.action.execute(lexer)
+
+    def __hash__(self):
+        return hash((self.actionType, self.offset, self.action))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerIndexedCustomAction):
+            return False
+        else:
+            return self.offset == other.offset and self.action == other.action

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/atn/LexerActionExecutor.py

@@ -0,0 +1,143 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#/
+
+# Represents an executor for a sequence of lexer actions which traversed during
+# the matching operation of a lexer rule (token).
+#
+# <p>The executor tracks position information for position-dependent lexer actions
+# efficiently, ensuring that actions appearing only at the end of the rule do
+# not cause bloating of the {@link DFA} created for the lexer.</p>
+
+
+from antlr4.InputStream import InputStream
+from antlr4.atn.LexerAction import LexerAction, LexerIndexedCustomAction
+
+# need a forward declaration
+Lexer = None
+LexerActionExecutor = None
+
+class LexerActionExecutor(object):
+    __slots__ = ('lexerActions', 'hashCode')
+
+    def __init__(self, lexerActions:list=list()):
+        self.lexerActions = lexerActions
+        # Caches the result of {@link #hashCode} since the hash code is an element
+        # of the performance-critical {@link LexerATNConfig#hashCode} operation.
+        self.hashCode = hash("".join([str(la) for la in lexerActions]))
+
+
+    # Creates a {@link LexerActionExecutor} which executes the actions for
+    # the input {@code lexerActionExecutor} followed by a specified
+    # {@code lexerAction}.
+    #
+    # @param lexerActionExecutor The executor for actions already traversed by
+    # the lexer while matching a token within a particular
+    # {@link LexerATNConfig}. If this is {@code null}, the method behaves as
+    # though it were an empty executor.
+    # @param lexerAction The lexer action to execute after the actions
+    # specified in {@code lexerActionExecutor}.
+    #
+    # @return A {@link LexerActionExecutor} for executing the combine actions
+    # of {@code lexerActionExecutor} and {@code lexerAction}.
+    @staticmethod
+    def append(lexerActionExecutor:LexerActionExecutor , lexerAction:LexerAction ):
+        if lexerActionExecutor is None:
+            return LexerActionExecutor([ lexerAction ])
+
+        lexerActions = lexerActionExecutor.lexerActions + [ lexerAction ]
+        return LexerActionExecutor(lexerActions)
+
+    # Creates a {@link LexerActionExecutor} which encodes the current offset
+    # for position-dependent lexer actions.
+    #
+    # <p>Normally, when the executor encounters lexer actions where
+    # {@link LexerAction#isPositionDependent} returns {@code true}, it calls
+    # {@link IntStream#seek} on the input {@link CharStream} to set the input
+    # position to the <em>end</em> of the current token. This behavior provides
+    # for efficient DFA representation of lexer actions which appear at the end
+    # of a lexer rule, even when the lexer rule matches a variable number of
+    # characters.</p>
+    #
+    # <p>Prior to traversing a match transition in the ATN, the current offset
+    # from the token start index is assigned to all position-dependent lexer
+    # actions which have not already been assigned a fixed offset. By storing
+    # the offsets relative to the token start index, the DFA representation of
+    # lexer actions which appear in the middle of tokens remains efficient due
+    # to sharing among tokens of the same length, regardless of their absolute
+    # position in the input stream.</p>
+    #
+    # <p>If the current executor already has offsets assigned to all
+    # position-dependent lexer actions, the method returns {@code this}.</p>
+    #
+    # @param offset The current offset to assign to all position-dependent
+    # lexer actions which do not already have offsets assigned.
+    #
+    # @return A {@link LexerActionExecutor} which stores input stream offsets
+    # for all position-dependent lexer actions.
+    #/
+    def fixOffsetBeforeMatch(self, offset:int):
+        updatedLexerActions = None
+        for i in range(0, len(self.lexerActions)):
+            if self.lexerActions[i].isPositionDependent and not isinstance(self.lexerActions[i], LexerIndexedCustomAction):
+                if updatedLexerActions is None:
+                    updatedLexerActions = [ la for la in self.lexerActions ]
+                updatedLexerActions[i] = LexerIndexedCustomAction(offset, self.lexerActions[i])
+
+        if updatedLexerActions is None:
+            return self
+        else:
+            return LexerActionExecutor(updatedLexerActions)
+
+
+    # Execute the actions encapsulated by this executor within the context of a
+    # particular {@link Lexer}.
+    #
+    # <p>This method calls {@link IntStream#seek} to set the position of the
+    # {@code input} {@link CharStream} prior to calling
+    # {@link LexerAction#execute} on a position-dependent action. Before the
+    # method returns, the input position will be restored to the same position
+    # it was in when the method was invoked.</p>
+    #
+    # @param lexer The lexer instance.
+    # @param input The input stream which is the source for the current token.
+    # When this method is called, the current {@link IntStream#index} for
+    # {@code input} should be the start of the following token, i.e. 1
+    # character past the end of the current token.
+    # @param startIndex The token start index. This value may be passed to
+    # {@link IntStream#seek} to set the {@code input} position to the beginning
+    # of the token.
+    #/
+    def execute(self, lexer:Lexer, input:InputStream, startIndex:int):
+        requiresSeek = False
+        stopIndex = input.index
+        try:
+            for lexerAction in self.lexerActions:
+                if isinstance(lexerAction, LexerIndexedCustomAction):
+                    offset = lexerAction.offset
+                    input.seek(startIndex + offset)
+                    lexerAction = lexerAction.action
+                    requiresSeek = (startIndex + offset) != stopIndex
+                elif lexerAction.isPositionDependent:
+                    input.seek(stopIndex)
+                    requiresSeek = False
+                lexerAction.execute(lexer)
+        finally:
+            if requiresSeek:
+                input.seek(stopIndex)
+
+    def __hash__(self):
+        return self.hashCode
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, LexerActionExecutor):
+            return False
+        else:
+            return self.hashCode == other.hashCode \
+                and self.lexerActions == other.lexerActions
+
+del Lexer

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/atn/ParserATNSimulator.py

@@ -0,0 +1,1649 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+#
+# The embodiment of the adaptive LL(*), ALL(*), parsing strategy.
+#
+# <p>
+# The basic complexity of the adaptive strategy makes it harder to understand.
+# We begin with ATN simulation to build paths in a DFA. Subsequent prediction
+# requests go through the DFA first. If they reach a state without an edge for
+# the current symbol, the algorithm fails over to the ATN simulation to
+# complete the DFA path for the current input (until it finds a conflict state
+# or uniquely predicting state).</p>
+#
+# <p>
+# All of that is done without using the outer context because we want to create
+# a DFA that is not dependent upon the rule invocation stack when we do a
+# prediction. One DFA works in all contexts. We avoid using context not
+# necessarily because it's slower, although it can be, but because of the DFA
+# caching problem. The closure routine only considers the rule invocation stack
+# created during prediction beginning in the decision rule. For example, if
+# prediction occurs without invoking another rule's ATN, there are no context
+# stacks in the configurations. When lack of context leads to a conflict, we
+# don't know if it's an ambiguity or a weakness in the strong LL(*) parsing
+# strategy (versus full LL(*)).</p>
+#
+# <p>
+# When SLL yields a configuration set with conflict, we rewind the input and
+# retry the ATN simulation, this time using full outer context without adding
+# to the DFA. Configuration context stacks will be the full invocation stacks
+# from the start rule. If we get a conflict using full context, then we can
+# definitively say we have a true ambiguity for that input sequence. If we
+# don't get a conflict, it implies that the decision is sensitive to the outer
+# context. (It is not context-sensitive in the sense of context-sensitive
+# grammars.)</p>
+#
+# <p>
+# The next time we reach this DFA state with an SLL conflict, through DFA
+# simulation, we will again retry the ATN simulation using full context mode.
+# This is slow because we can't save the results and have to "interpret" the
+# ATN each time we get that input.</p>
+#
+# <p>
+# <strong>CACHING FULL CONTEXT PREDICTIONS</strong></p>
+#
+# <p>
+# We could cache results from full context to predicted alternative easily and
+# that saves a lot of time but doesn't work in presence of predicates. The set
+# of visible predicates from the ATN start state changes depending on the
+# context, because closure can fall off the end of a rule. I tried to cache
+# tuples (stack context, semantic context, predicted alt) but it was slower
+# than interpreting and much more complicated. Also required a huge amount of
+# memory. The goal is not to create the world's fastest parser anyway. I'd like
+# to keep this algorithm simple. By launching multiple threads, we can improve
+# the speed of parsing across a large number of files.</p>
+#
+# <p>
+# There is no strict ordering between the amount of input used by SLL vs LL,
+# which makes it really hard to build a cache for full context. Let's say that
+# we have input A B C that leads to an SLL conflict with full context X. That
+# implies that using X we might only use A B but we could also use A B C D to
+# resolve conflict. Input A B C D could predict alternative 1 in one position
+# in the input and A B C E could predict alternative 2 in another position in
+# input. The conflicting SLL configurations could still be non-unique in the
+# full context prediction, which would lead us to requiring more input than the
+# original A B C.	To make a	prediction cache work, we have to track	the exact
+# input	used during the previous prediction. That amounts to a cache that maps
+# X to a specific DFA for that context.</p>
+#
+# <p>
+# Something should be done for left-recursive expression predictions. They are
+# likely LL(1) + pred eval. Easier to do the whole SLL unless error and retry
+# with full LL thing Sam does.</p>
+#
+# <p>
+# <strong>AVOIDING FULL CONTEXT PREDICTION</strong></p>
+#
+# <p>
+# We avoid doing full context retry when the outer context is empty, we did not
+# dip into the outer context by falling off the end of the decision state rule,
+# or when we force SLL mode.</p>
+#
+# <p>
+# As an example of the not dip into outer context case, consider as super
+# constructor calls versus function calls. One grammar might look like
+# this:</p>
+#
+# <pre>
+# ctorBody
+#   : '{' superCall? stat* '}'
+#   ;
+# </pre>
+#
+# <p>
+# Or, you might see something like</p>
+#
+# <pre>
+# stat
+#   : superCall ';'
+#   | expression ';'
+#   | ...
+#   ;
+# </pre>
+#
+# <p>
+# In both cases I believe that no closure operations will dip into the outer
+# context. In the first case ctorBody in the worst case will stop at the '}'.
+# In the 2nd case it should stop at the ';'. Both cases should stay within the
+# entry rule and not dip into the outer context.</p>
+#
+# <p>
+# <strong>PREDICATES</strong></p>
+#
+# <p>
+# Predicates are always evaluated if present in either SLL or LL both. SLL and
+# LL simulation deals with predicates differently. SLL collects predicates as
+# it performs closure operations like ANTLR v3 did. It delays predicate
+# evaluation until it reaches and accept state. This allows us to cache the SLL
+# ATN simulation whereas, if we had evaluated predicates on-the-fly during
+# closure, the DFA state configuration sets would be different and we couldn't
+# build up a suitable DFA.</p>
+#
+# <p>
+# When building a DFA accept state during ATN simulation, we evaluate any
+# predicates and return the sole semantically valid alternative. If there is
+# more than 1 alternative, we report an ambiguity. If there are 0 alternatives,
+# we throw an exception. Alternatives without predicates act like they have
+# true predicates. The simple way to think about it is to strip away all
+# alternatives with false predicates and choose the minimum alternative that
+# remains.</p>
+#
+# <p>
+# When we start in the DFA and reach an accept state that's predicated, we test
+# those and return the minimum semantically viable alternative. If no
+# alternatives are viable, we throw an exception.</p>
+#
+# <p>
+# During full LL ATN simulation, closure always evaluates predicates and
+# on-the-fly. This is crucial to reducing the configuration set size during
+# closure. It hits a landmine when parsing with the Java grammar, for example,
+# without this on-the-fly evaluation.</p>
+#
+# <p>
+# <strong>SHARING DFA</strong></p>
+#
+# <p>
+# All instances of the same parser share the same decision DFAs through a
+# static field. Each instance gets its own ATN simulator but they share the
+# same {@link #decisionToDFA} field. They also share a
+# {@link PredictionContextCache} object that makes sure that all
+# {@link PredictionContext} objects are shared among the DFA states. This makes
+# a big size difference.</p>
+#
+# <p>
+# <strong>THREAD SAFETY</strong></p>
+#
+# <p>
+# The {@link ParserATNSimulator} locks on the {@link #decisionToDFA} field when
+# it adds a new DFA object to that array. {@link #addDFAEdge}
+# locks on the DFA for the current decision when setting the
+# {@link DFAState#edges} field. {@link #addDFAState} locks on
+# the DFA for the current decision when looking up a DFA state to see if it
+# already exists. We must make sure that all requests to add DFA states that
+# are equivalent result in the same shared DFA object. This is because lots of
+# threads will be trying to update the DFA at once. The
+# {@link #addDFAState} method also locks inside the DFA lock
+# but this time on the shared context cache when it rebuilds the
+# configurations' {@link PredictionContext} objects using cached
+# subgraphs/nodes. No other locking occurs, even during DFA simulation. This is
+# safe as long as we can guarantee that all threads referencing
+# {@code s.edge[t]} get the same physical target {@link DFAState}, or
+# {@code null}. Once into the DFA, the DFA simulation does not reference the
+# {@link DFA#states} map. It follows the {@link DFAState#edges} field to new
+# targets. The DFA simulator will either find {@link DFAState#edges} to be
+# {@code null}, to be non-{@code null} and {@code dfa.edges[t]} null, or
+# {@code dfa.edges[t]} to be non-null. The
+# {@link #addDFAEdge} method could be racing to set the field
+# but in either case the DFA simulator works; if {@code null}, and requests ATN
+# simulation. It could also race trying to get {@code dfa.edges[t]}, but either
+# way it will work because it's not doing a test and set operation.</p>
+#
+# <p>
+# <strong>Starting with SLL then failing to combined SLL/LL (Two-Stage
+# Parsing)</strong></p>
+#
+# <p>
+# Sam pointed out that if SLL does not give a syntax error, then there is no
+# point in doing full LL, which is slower. We only have to try LL if we get a
+# syntax error. For maximum speed, Sam starts the parser set to pure SLL
+# mode with the {@link BailErrorStrategy}:</p>
+#
+# <pre>
+# parser.{@link Parser#getInterpreter() getInterpreter()}.{@link #setPredictionMode setPredictionMode}{@code (}{@link PredictionMode#SLL}{@code )};
+# parser.{@link Parser#setErrorHandler setErrorHandler}(new {@link BailErrorStrategy}());
+# </pre>
+#
+# <p>
+# If it does not get a syntax error, then we're done. If it does get a syntax
+# error, we need to retry with the combined SLL/LL strategy.</p>
+#
+# <p>
+# The reason this works is as follows. If there are no SLL conflicts, then the
+# grammar is SLL (at least for that input set). If there is an SLL conflict,
+# the full LL analysis must yield a set of viable alternatives which is a
+# subset of the alternatives reported by SLL. If the LL set is a singleton,
+# then the grammar is LL but not SLL. If the LL set is the same size as the SLL
+# set, the decision is SLL. If the LL set has size &gt; 1, then that decision
+# is truly ambiguous on the current input. If the LL set is smaller, then the
+# SLL conflict resolution might choose an alternative that the full LL would
+# rule out as a possibility based upon better context information. If that's
+# the case, then the SLL parse will definitely get an error because the full LL
+# analysis says it's not viable. If SLL conflict resolution chooses an
+# alternative within the LL set, them both SLL and LL would choose the same
+# alternative because they both choose the minimum of multiple conflicting
+# alternatives.</p>
+#
+# <p>
+# Let's say we have a set of SLL conflicting alternatives {@code {1, 2, 3}} and
+# a smaller LL set called <em>s</em>. If <em>s</em> is {@code {2, 3}}, then SLL
+# parsing will get an error because SLL will pursue alternative 1. If
+# <em>s</em> is {@code {1, 2}} or {@code {1, 3}} then both SLL and LL will
+# choose the same alternative because alternative one is the minimum of either
+# set. If <em>s</em> is {@code {2}} or {@code {3}} then SLL will get a syntax
+# error. If <em>s</em> is {@code {1}} then SLL will succeed.</p>
+#
+# <p>
+# Of course, if the input is invalid, then we will get an error for sure in
+# both SLL and LL parsing. Erroneous input will therefore require 2 passes over
+# the input.</p>
+#
+import sys
+from antlr4 import DFA
+from antlr4.PredictionContext import PredictionContextCache, PredictionContext, SingletonPredictionContext, \
+    PredictionContextFromRuleContext
+from antlr4.BufferedTokenStream import TokenStream
+from antlr4.Parser import Parser
+from antlr4.ParserRuleContext import ParserRuleContext
+from antlr4.RuleContext import RuleContext
+from antlr4.Token import Token
+from antlr4.Utils import str_list
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNConfig import ATNConfig
+from antlr4.atn.ATNConfigSet import ATNConfigSet
+from antlr4.atn.ATNSimulator import ATNSimulator
+from antlr4.atn.ATNState import StarLoopEntryState, DecisionState, RuleStopState, ATNState
+from antlr4.atn.PredictionMode import PredictionMode
+from antlr4.atn.SemanticContext import SemanticContext, AND, andContext, orContext
+from antlr4.atn.Transition import Transition, RuleTransition, ActionTransition, PrecedencePredicateTransition, \
+    PredicateTransition, AtomTransition, SetTransition, NotSetTransition
+from antlr4.dfa.DFAState import DFAState, PredPrediction
+from antlr4.error.Errors import NoViableAltException
+
+
+class ParserATNSimulator(ATNSimulator):
+    __slots__ = (
+        'parser', 'decisionToDFA', 'predictionMode', '_input', '_startIndex',
+        '_outerContext', '_dfa', 'mergeCache'
+    )
+
+    debug = False
+    debug_list_atn_decisions = False
+    dfa_debug = False
+    retry_debug = False
+
+
+    def __init__(self, parser:Parser, atn:ATN, decisionToDFA:list, sharedContextCache:PredictionContextCache):
+        super().__init__(atn, sharedContextCache)
+        self.parser = parser
+        self.decisionToDFA = decisionToDFA
+        # SLL, LL, or LL + exact ambig detection?#
+        self.predictionMode = PredictionMode.LL
+        # LAME globals to avoid parameters!!!!! I need these down deep in predTransition
+        self._input = None
+        self._startIndex = 0
+        self._outerContext = None
+        self._dfa = None
+        # Each prediction operation uses a cache for merge of prediction contexts.
+        #  Don't keep around as it wastes huge amounts of memory. DoubleKeyMap
+        #  isn't synchronized but we're ok since two threads shouldn't reuse same
+        #  parser/atnsim object because it can only handle one input at a time.
+        #  This maps graphs a and b to merged result c. (a,b)&rarr;c. We can avoid
+        #  the merge if we ever see a and b again.  Note that (b,a)&rarr;c should
+        #  also be examined during cache lookup.
+        #
+        self.mergeCache = None
+
+
+    def reset(self):
+        pass
+
+    def adaptivePredict(self, input:TokenStream, decision:int, outerContext:ParserRuleContext):
+        if ParserATNSimulator.debug or ParserATNSimulator.debug_list_atn_decisions:
+            print("adaptivePredict decision " + str(decision) +
+                                   " exec LA(1)==" + self.getLookaheadName(input) +
+                                   " line " + str(input.LT(1).line) + ":" +
+                                   str(input.LT(1).column))
+        self._input = input
+        self._startIndex = input.index
+        self._outerContext = outerContext
+
+        dfa = self.decisionToDFA[decision]
+        self._dfa = dfa
+        m = input.mark()
+        index = input.index
+
+        # Now we are certain to have a specific decision's DFA
+        # But, do we still need an initial state?
+        try:
+            if dfa.precedenceDfa:
+                # the start state for a precedence DFA depends on the current
+                # parser precedence, and is provided by a DFA method.
+                s0 = dfa.getPrecedenceStartState(self.parser.getPrecedence())
+            else:
+                # the start state for a "regular" DFA is just s0
+                s0 = dfa.s0
+
+            if s0 is None:
+                if outerContext is None:
+                    outerContext = ParserRuleContext.EMPTY
+                if ParserATNSimulator.debug or ParserATNSimulator.debug_list_atn_decisions:
+                    print("predictATN decision " + str(dfa.decision) +
+                                       " exec LA(1)==" + self.getLookaheadName(input) +
+                                       ", outerContext=" + outerContext.toString(self.parser.literalNames, None))
+
+                fullCtx = False
+                s0_closure = self.computeStartState(dfa.atnStartState, ParserRuleContext.EMPTY, fullCtx)
+
+                if dfa.precedenceDfa:
+                    # If this is a precedence DFA, we use applyPrecedenceFilter
+                    # to convert the computed start state to a precedence start
+                    # state. We then use DFA.setPrecedenceStartState to set the
+                    # appropriate start state for the precedence level rather
+                    # than simply setting DFA.s0.
+                    #
+                    dfa.s0.configs = s0_closure # not used for prediction but useful to know start configs anyway
+                    s0_closure = self.applyPrecedenceFilter(s0_closure)
+                    s0 = self.addDFAState(dfa, DFAState(configs=s0_closure))
+                    dfa.setPrecedenceStartState(self.parser.getPrecedence(), s0)
+                else:
+                    s0 = self.addDFAState(dfa, DFAState(configs=s0_closure))
+                    dfa.s0 = s0
+
+            alt = self.execATN(dfa, s0, input, index, outerContext)
+            if ParserATNSimulator.debug:
+                print("DFA after predictATN: " + dfa.toString(self.parser.literalNames))
+            return alt
+        finally:
+            self._dfa = None
+            self.mergeCache = None # wack cache after each prediction
+            input.seek(index)
+            input.release(m)
+
+    # Performs ATN simulation to compute a predicted alternative based
+    #  upon the remaining input, but also updates the DFA cache to avoid
+    #  having to traverse the ATN again for the same input sequence.
+
+    # There are some key conditions we're looking for after computing a new
+    # set of ATN configs (proposed DFA state):
+          # if the set is empty, there is no viable alternative for current symbol
+          # does the state uniquely predict an alternative?
+          # does the state have a conflict that would prevent us from
+          #   putting it on the work list?
+
+    # We also have some key operations to do:
+          # add an edge from previous DFA state to potentially new DFA state, D,
+          #   upon current symbol but only if adding to work list, which means in all
+          #   cases except no viable alternative (and possibly non-greedy decisions?)
+          # collecting predicates and adding semantic context to DFA accept states
+          # adding rule context to context-sensitive DFA accept states
+          # consuming an input symbol
+          # reporting a conflict
+          # reporting an ambiguity
+          # reporting a context sensitivity
+          # reporting insufficient predicates
+
+    # cover these cases:
+    #    dead end
+    #    single alt
+    #    single alt + preds
+    #    conflict
+    #    conflict + preds
+    #
+    def execATN(self, dfa:DFA, s0:DFAState, input:TokenStream, startIndex:int, outerContext:ParserRuleContext ):
+        if ParserATNSimulator.debug or ParserATNSimulator.debug_list_atn_decisions:
+            print("execATN decision " + str(dfa.decision) +
+                    " exec LA(1)==" + self.getLookaheadName(input) +
+                    " line " + str(input.LT(1).line) + ":" + str(input.LT(1).column))
+
+        previousD = s0
+
+        if ParserATNSimulator.debug:
+            print("s0 = " + str(s0))
+
+        t = input.LA(1)
+
+        while True: # while more work
+            D = self.getExistingTargetState(previousD, t)
+            if D is None:
+                D = self.computeTargetState(dfa, previousD, t)
+            if D is self.ERROR:
+                # if any configs in previous dipped into outer context, that
+                # means that input up to t actually finished entry rule
+                # at least for SLL decision. Full LL doesn't dip into outer
+                # so don't need special case.
+                # We will get an error no matter what so delay until after
+                # decision; better error message. Also, no reachable target
+                # ATN states in SLL implies LL will also get nowhere.
+                # If conflict in states that dip out, choose min since we
+                # will get error no matter what.
+                e = self.noViableAlt(input, outerContext, previousD.configs, startIndex)
+                input.seek(startIndex)
+                alt = self.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previousD.configs, outerContext)
+                if alt!=ATN.INVALID_ALT_NUMBER:
+                    return alt
+                raise e
+
+            if D.requiresFullContext and self.predictionMode != PredictionMode.SLL:
+                # IF PREDS, MIGHT RESOLVE TO SINGLE ALT => SLL (or syntax error)
+                conflictingAlts = D.configs.conflictingAlts
+                if D.predicates is not None:
+                    if ParserATNSimulator.debug:
+                        print("DFA state has preds in DFA sim LL failover")
+                    conflictIndex = input.index
+                    if conflictIndex != startIndex:
+                        input.seek(startIndex)
+
+                    conflictingAlts = self.evalSemanticContext(D.predicates, outerContext, True)
+                    if len(conflictingAlts)==1:
+                        if ParserATNSimulator.debug:
+                            print("Full LL avoided")
+                        return min(conflictingAlts)
+
+                    if conflictIndex != startIndex:
+                        # restore the index so reporting the fallback to full
+                        # context occurs with the index at the correct spot
+                        input.seek(conflictIndex)
+
+                if ParserATNSimulator.dfa_debug:
+                    print("ctx sensitive state " + str(outerContext) +" in " + str(D))
+                fullCtx = True
+                s0_closure = self.computeStartState(dfa.atnStartState, outerContext, fullCtx)
+                self.reportAttemptingFullContext(dfa, conflictingAlts, D.configs, startIndex, input.index)
+                alt = self.execATNWithFullContext(dfa, D, s0_closure, input, startIndex, outerContext)
+                return alt
+
+            if D.isAcceptState:
+                if D.predicates is None:
+                    return D.prediction
+
+                stopIndex = input.index
+                input.seek(startIndex)
+                alts = self.evalSemanticContext(D.predicates, outerContext, True)
+                if len(alts)==0:
+                    raise self.noViableAlt(input, outerContext, D.configs, startIndex)
+                elif len(alts)==1:
+                    return min(alts)
+                else:
+                    # report ambiguity after predicate evaluation to make sure the correct
+                    # set of ambig alts is reported.
+                    self.reportAmbiguity(dfa, D, startIndex, stopIndex, False, alts, D.configs)
+                    return min(alts)
+
+            previousD = D
+
+            if t != Token.EOF:
+                input.consume()
+                t = input.LA(1)
+
+    #
+    # Get an existing target state for an edge in the DFA. If the target state
+    # for the edge has not yet been computed or is otherwise not available,
+    # this method returns {@code null}.
+    #
+    # @param previousD The current DFA state
+    # @param t The next input symbol
+    # @return The existing target DFA state for the given input symbol
+    # {@code t}, or {@code null} if the target state for this edge is not
+    # already cached
+    #
+    def getExistingTargetState(self, previousD:DFAState, t:int):
+        edges = previousD.edges
+        if edges is None or t + 1 < 0 or t + 1 >= len(edges):
+            return None
+        else:
+            return edges[t + 1]
+
+    #
+    # Compute a target state for an edge in the DFA, and attempt to add the
+    # computed state and corresponding edge to the DFA.
+    #
+    # @param dfa The DFA
+    # @param previousD The current DFA state
+    # @param t The next input symbol
+    #
+    # @return The computed target DFA state for the given input symbol
+    # {@code t}. If {@code t} does not lead to a valid DFA state, this method
+    # returns {@link #ERROR}.
+    #
+    def computeTargetState(self, dfa:DFA, previousD:DFAState, t:int):
+        reach = self.computeReachSet(previousD.configs, t, False)
+        if reach is None:
+            self.addDFAEdge(dfa, previousD, t, self.ERROR)
+            return self.ERROR
+
+        # create new target state; we'll add to DFA after it's complete
+        D = DFAState(configs=reach)
+
+        predictedAlt = self.getUniqueAlt(reach)
+
+        if ParserATNSimulator.debug:
+            altSubSets = PredictionMode.getConflictingAltSubsets(reach)
+            print("SLL altSubSets=" + str(altSubSets) + ", configs=" + str(reach) +
+                        ", predict=" + str(predictedAlt) + ", allSubsetsConflict=" +
+                        str(PredictionMode.allSubsetsConflict(altSubSets)) + ", conflictingAlts=" +
+                        str(self.getConflictingAlts(reach)))
+
+        if predictedAlt!=ATN.INVALID_ALT_NUMBER:
+            # NO CONFLICT, UNIQUELY PREDICTED ALT
+            D.isAcceptState = True
+            D.configs.uniqueAlt = predictedAlt
+            D.prediction = predictedAlt
+        elif PredictionMode.hasSLLConflictTerminatingPrediction(self.predictionMode, reach):
+            # MORE THAN ONE VIABLE ALTERNATIVE
+            D.configs.conflictingAlts = self.getConflictingAlts(reach)
+            D.requiresFullContext = True
+            # in SLL-only mode, we will stop at this state and return the minimum alt
+            D.isAcceptState = True
+            D.prediction = min(D.configs.conflictingAlts)
+
+        if D.isAcceptState and D.configs.hasSemanticContext:
+            self.predicateDFAState(D, self.atn.getDecisionState(dfa.decision))
+            if D.predicates is not None:
+                D.prediction = ATN.INVALID_ALT_NUMBER
+
+        # all adds to dfa are done after we've created full D state
+        D = self.addDFAEdge(dfa, previousD, t, D)
+        return D
+
+    def predicateDFAState(self, dfaState:DFAState, decisionState:DecisionState):
+        # We need to test all predicates, even in DFA states that
+        # uniquely predict alternative.
+        nalts = len(decisionState.transitions)
+        # Update DFA so reach becomes accept state with (predicate,alt)
+        # pairs if preds found for conflicting alts
+        altsToCollectPredsFrom = self.getConflictingAltsOrUniqueAlt(dfaState.configs)
+        altToPred = self.getPredsForAmbigAlts(altsToCollectPredsFrom, dfaState.configs, nalts)
+        if altToPred is not None:
+            dfaState.predicates = self.getPredicatePredictions(altsToCollectPredsFrom, altToPred)
+            dfaState.prediction = ATN.INVALID_ALT_NUMBER # make sure we use preds
+        else:
+            # There are preds in configs but they might go away
+            # when OR'd together like {p}? || NONE == NONE. If neither
+            # alt has preds, resolve to min alt
+            dfaState.prediction = min(altsToCollectPredsFrom)
+
+    # comes back with reach.uniqueAlt set to a valid alt
+    def execATNWithFullContext(self, dfa:DFA, D:DFAState, # how far we got before failing over
+                                         s0:ATNConfigSet,
+                                         input:TokenStream,
+                                         startIndex:int,
+                                         outerContext:ParserRuleContext):
+        if ParserATNSimulator.debug or ParserATNSimulator.debug_list_atn_decisions:
+            print("execATNWithFullContext", str(s0))
+        fullCtx = True
+        foundExactAmbig = False
+        reach = None
+        previous = s0
+        input.seek(startIndex)
+        t = input.LA(1)
+        predictedAlt = -1
+        while (True): # while more work
+            reach = self.computeReachSet(previous, t, fullCtx)
+            if reach is None:
+                # if any configs in previous dipped into outer context, that
+                # means that input up to t actually finished entry rule
+                # at least for LL decision. Full LL doesn't dip into outer
+                # so don't need special case.
+                # We will get an error no matter what so delay until after
+                # decision; better error message. Also, no reachable target
+                # ATN states in SLL implies LL will also get nowhere.
+                # If conflict in states that dip out, choose min since we
+                # will get error no matter what.
+                e = self.noViableAlt(input, outerContext, previous, startIndex)
+                input.seek(startIndex)
+                alt = self.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previous, outerContext)
+                if alt!=ATN.INVALID_ALT_NUMBER:
+                    return alt
+                else:
+                    raise e
+
+            altSubSets = PredictionMode.getConflictingAltSubsets(reach)
+            if ParserATNSimulator.debug:
+                print("LL altSubSets=" + str(altSubSets) + ", predict=" +
+                      str(PredictionMode.getUniqueAlt(altSubSets)) + ", resolvesToJustOneViableAlt=" +
+                      str(PredictionMode.resolvesToJustOneViableAlt(altSubSets)))
+
+            reach.uniqueAlt = self.getUniqueAlt(reach)
+            # unique prediction?
+            if reach.uniqueAlt!=ATN.INVALID_ALT_NUMBER:
+                predictedAlt = reach.uniqueAlt
+                break
+            elif self.predictionMode is not PredictionMode.LL_EXACT_AMBIG_DETECTION:
+                predictedAlt = PredictionMode.resolvesToJustOneViableAlt(altSubSets)
+                if predictedAlt != ATN.INVALID_ALT_NUMBER:
+                    break
+            else:
+                # In exact ambiguity mode, we never try to terminate early.
+                # Just keeps scarfing until we know what the conflict is
+                if PredictionMode.allSubsetsConflict(altSubSets) and PredictionMode.allSubsetsEqual(altSubSets):
+                    foundExactAmbig = True
+                    predictedAlt = PredictionMode.getSingleViableAlt(altSubSets)
+                    break
+                # else there are multiple non-conflicting subsets or
+                # we're not sure what the ambiguity is yet.
+                # So, keep going.
+
+            previous = reach
+            if t != Token.EOF:
+                input.consume()
+                t = input.LA(1)
+
+        # If the configuration set uniquely predicts an alternative,
+        # without conflict, then we know that it's a full LL decision
+        # not SLL.
+        if reach.uniqueAlt != ATN.INVALID_ALT_NUMBER :
+            self.reportContextSensitivity(dfa, predictedAlt, reach, startIndex, input.index)
+            return predictedAlt
+
+        # We do not check predicates here because we have checked them
+        # on-the-fly when doing full context prediction.
+
+        #
+        # In non-exact ambiguity detection mode, we might	actually be able to
+        # detect an exact ambiguity, but I'm not going to spend the cycles
+        # needed to check. We only emit ambiguity warnings in exact ambiguity
+        # mode.
+        #
+        # For example, we might know that we have conflicting configurations.
+        # But, that does not mean that there is no way forward without a
+        # conflict. It's possible to have nonconflicting alt subsets as in:
+
+        # altSubSets=[{1, 2}, {1, 2}, {1}, {1, 2}]
+
+        # from
+        #
+        #    [(17,1,[5 $]), (13,1,[5 10 $]), (21,1,[5 10 $]), (11,1,[$]),
+        #     (13,2,[5 10 $]), (21,2,[5 10 $]), (11,2,[$])]
+        #
+        # In this case, (17,1,[5 $]) indicates there is some next sequence that
+        # would resolve this without conflict to alternative 1. Any other viable
+        # next sequence, however, is associated with a conflict.  We stop
+        # looking for input because no amount of further lookahead will alter
+        # the fact that we should predict alternative 1.  We just can't say for
+        # sure that there is an ambiguity without looking further.
+
+        self.reportAmbiguity(dfa, D, startIndex, input.index, foundExactAmbig, None, reach)
+
+        return predictedAlt
+
+    def computeReachSet(self, closure:ATNConfigSet, t:int, fullCtx:bool):
+        if ParserATNSimulator.debug:
+            print("in computeReachSet, starting closure: " + str(closure))
+
+        if self.mergeCache is None:
+            self.mergeCache = dict()
+
+        intermediate = ATNConfigSet(fullCtx)
+
+        # Configurations already in a rule stop state indicate reaching the end
+        # of the decision rule (local context) or end of the start rule (full
+        # context). Once reached, these configurations are never updated by a
+        # closure operation, so they are handled separately for the performance
+        # advantage of having a smaller intermediate set when calling closure.
+        #
+        # For full-context reach operations, separate handling is required to
+        # ensure that the alternative matching the longest overall sequence is
+        # chosen when multiple such configurations can match the input.
+
+        skippedStopStates = None
+
+        # First figure out where we can reach on input t
+        for c in closure:
+            if ParserATNSimulator.debug:
+                print("testing " + self.getTokenName(t) + " at " + str(c))
+
+            if isinstance(c.state, RuleStopState):
+                if fullCtx or t == Token.EOF:
+                    if skippedStopStates is None:
+                        skippedStopStates = list()
+                    skippedStopStates.append(c)
+                continue
+
+            for trans in c.state.transitions:
+                target = self.getReachableTarget(trans, t)
+                if target is not None:
+                    intermediate.add(ATNConfig(state=target, config=c), self.mergeCache)
+
+        # Now figure out where the reach operation can take us...
+
+        reach = None
+
+        # This block optimizes the reach operation for intermediate sets which
+        # trivially indicate a termination state for the overall
+        # adaptivePredict operation.
+        #
+        # The conditions assume that intermediate
+        # contains all configurations relevant to the reach set, but this
+        # condition is not true when one or more configurations have been
+        # withheld in skippedStopStates, or when the current symbol is EOF.
+        #
+        if skippedStopStates is None and t!=Token.EOF:
+            if len(intermediate)==1:
+                # Don't pursue the closure if there is just one state.
+                # It can only have one alternative; just add to result
+                # Also don't pursue the closure if there is unique alternative
+                # among the configurations.
+                reach = intermediate
+            elif self.getUniqueAlt(intermediate)!=ATN.INVALID_ALT_NUMBER:
+                # Also don't pursue the closure if there is unique alternative
+                # among the configurations.
+                reach = intermediate
+
+        # If the reach set could not be trivially determined, perform a closure
+        # operation on the intermediate set to compute its initial value.
+        #
+        if reach is None:
+            reach = ATNConfigSet(fullCtx)
+            closureBusy = set()
+            treatEofAsEpsilon = t == Token.EOF
+            for c in intermediate:
+                self.closure(c, reach, closureBusy, False, fullCtx, treatEofAsEpsilon)
+
+        if t == Token.EOF:
+            # After consuming EOF no additional input is possible, so we are
+            # only interested in configurations which reached the end of the
+            # decision rule (local context) or end of the start rule (full
+            # context). Update reach to contain only these configurations. This
+            # handles both explicit EOF transitions in the grammar and implicit
+            # EOF transitions following the end of the decision or start rule.
+            #
+            # When reach==intermediate, no closure operation was performed. In
+            # this case, removeAllConfigsNotInRuleStopState needs to check for
+            # reachable rule stop states as well as configurations already in
+            # a rule stop state.
+            #
+            # This is handled before the configurations in skippedStopStates,
+            # because any configurations potentially added from that list are
+            # already guaranteed to meet this condition whether or not it's
+            # required.
+            #
+            reach = self.removeAllConfigsNotInRuleStopState(reach, reach is intermediate)
+
+        # If skippedStopStates is not null, then it contains at least one
+        # configuration. For full-context reach operations, these
+        # configurations reached the end of the start rule, in which case we
+        # only add them back to reach if no configuration during the current
+        # closure operation reached such a state. This ensures adaptivePredict
+        # chooses an alternative matching the longest overall sequence when
+        # multiple alternatives are viable.
+        #
+        if skippedStopStates is not None and ( (not fullCtx) or (not PredictionMode.hasConfigInRuleStopState(reach))):
+            for c in skippedStopStates:
+                reach.add(c, self.mergeCache)
+        if len(reach)==0:
+            return None
+        else:
+            return reach
+
+    #
+    # Return a configuration set containing only the configurations from
+    # {@code configs} which are in a {@link RuleStopState}. If all
+    # configurations in {@code configs} are already in a rule stop state, this
+    # method simply returns {@code configs}.
+    #
+    # <p>When {@code lookToEndOfRule} is true, this method uses
+    # {@link ATN#nextTokens} for each configuration in {@code configs} which is
+    # not already in a rule stop state to see if a rule stop state is reachable
+    # from the configuration via epsilon-only transitions.</p>
+    #
+    # @param configs the configuration set to update
+    # @param lookToEndOfRule when true, this method checks for rule stop states
+    # reachable by epsilon-only transitions from each configuration in
+    # {@code configs}.
+    #
+    # @return {@code configs} if all configurations in {@code configs} are in a
+    # rule stop state, otherwise return a new configuration set containing only
+    # the configurations from {@code configs} which are in a rule stop state
+    #
+    def removeAllConfigsNotInRuleStopState(self, configs:ATNConfigSet, lookToEndOfRule:bool):
+        if PredictionMode.allConfigsInRuleStopStates(configs):
+            return configs
+        result = ATNConfigSet(configs.fullCtx)
+        for config in configs:
+            if isinstance(config.state, RuleStopState):
+                result.add(config, self.mergeCache)
+                continue
+            if lookToEndOfRule and config.state.epsilonOnlyTransitions:
+                nextTokens = self.atn.nextTokens(config.state)
+                if Token.EPSILON in nextTokens:
+                    endOfRuleState = self.atn.ruleToStopState[config.state.ruleIndex]
+                    result.add(ATNConfig(state=endOfRuleState, config=config), self.mergeCache)
+        return result
+
+    def computeStartState(self, p:ATNState, ctx:RuleContext, fullCtx:bool):
+        # always at least the implicit call to start rule
+        initialContext = PredictionContextFromRuleContext(self.atn, ctx)
+        configs = ATNConfigSet(fullCtx)
+
+        for i in range(0, len(p.transitions)):
+            target = p.transitions[i].target
+            c = ATNConfig(target, i+1, initialContext)
+            closureBusy = set()
+            self.closure(c, configs, closureBusy, True, fullCtx, False)
+        return configs
+
+    #
+    # This method transforms the start state computed by
+    # {@link #computeStartState} to the special start state used by a
+    # precedence DFA for a particular precedence value. The transformation
+    # process applies the following changes to the start state's configuration
+    # set.
+    #
+    # <ol>
+    # <li>Evaluate the precedence predicates for each configuration using
+    # {@link SemanticContext#evalPrecedence}.</li>
+    # <li>Remove all configurations which predict an alternative greater than
+    # 1, for which another configuration that predicts alternative 1 is in the
+    # same ATN state with the same prediction context. This transformation is
+    # valid for the following reasons:
+    # <ul>
+    # <li>The closure block cannot contain any epsilon transitions which bypass
+    # the body of the closure, so all states reachable via alternative 1 are
+    # part of the precedence alternatives of the transformed left-recursive
+    # rule.</li>
+    # <li>The "primary" portion of a left recursive rule cannot contain an
+    # epsilon transition, so the only way an alternative other than 1 can exist
+    # in a state that is also reachable via alternative 1 is by nesting calls
+    # to the left-recursive rule, with the outer calls not being at the
+    # preferred precedence level.</li>
+    # </ul>
+    # </li>
+    # </ol>
+    #
+    # <p>
+    # The prediction context must be considered by this filter to address
+    # situations like the following.
+    # </p>
+    # <code>
+    # <pre>
+    # grammar TA;
+    # prog: statement* EOF;
+    # statement: letterA | statement letterA 'b' ;
+    # letterA: 'a';
+    # </pre>
+    # </code>
+    # <p>
+    # If the above grammar, the ATN state immediately before the token
+    # reference {@code 'a'} in {@code letterA} is reachable from the left edge
+    # of both the primary and closure blocks of the left-recursive rule
+    # {@code statement}. The prediction context associated with each of these
+    # configurations distinguishes between them, and prevents the alternative
+    # which stepped out to {@code prog} (and then back in to {@code statement}
+    # from being eliminated by the filter.
+    # </p>
+    #
+    # @param configs The configuration set computed by
+    # {@link #computeStartState} as the start state for the DFA.
+    # @return The transformed configuration set representing the start state
+    # for a precedence DFA at a particular precedence level (determined by
+    # calling {@link Parser#getPrecedence}).
+    #
+    def applyPrecedenceFilter(self, configs:ATNConfigSet):
+        statesFromAlt1 = dict()
+        configSet = ATNConfigSet(configs.fullCtx)
+        for config in configs:
+            # handle alt 1 first
+            if config.alt != 1:
+                continue
+            updatedContext = config.semanticContext.evalPrecedence(self.parser, self._outerContext)
+            if updatedContext is None:
+                # the configuration was eliminated
+                continue
+
+            statesFromAlt1[config.state.stateNumber] = config.context
+            if updatedContext is not config.semanticContext:
+                configSet.add(ATNConfig(config=config, semantic=updatedContext), self.mergeCache)
+            else:
+                configSet.add(config, self.mergeCache)
+
+        for config in configs:
+            if config.alt == 1:
+                # already handled
+                continue
+
+            # In the future, this elimination step could be updated to also
+            # filter the prediction context for alternatives predicting alt>1
+            # (basically a graph subtraction algorithm).
+            #
+            if not config.precedenceFilterSuppressed:
+                context = statesFromAlt1.get(config.state.stateNumber, None)
+                if context==config.context:
+                    # eliminated
+                    continue
+
+            configSet.add(config, self.mergeCache)
+
+        return configSet
+
+    def getReachableTarget(self, trans:Transition, ttype:int):
+        if trans.matches(ttype, 0, self.atn.maxTokenType):
+            return trans.target
+        else:
+            return None
+
+    def getPredsForAmbigAlts(self, ambigAlts:set, configs:ATNConfigSet, nalts:int):
+        # REACH=[1|1|[]|0:0, 1|2|[]|0:1]
+        # altToPred starts as an array of all null contexts. The entry at index i
+        # corresponds to alternative i. altToPred[i] may have one of three values:
+        #   1. null: no ATNConfig c is found such that c.alt==i
+        #   2. SemanticContext.NONE: At least one ATNConfig c exists such that
+        #      c.alt==i and c.semanticContext==SemanticContext.NONE. In other words,
+        #      alt i has at least one unpredicated config.
+        #   3. Non-NONE Semantic Context: There exists at least one, and for all
+        #      ATNConfig c such that c.alt==i, c.semanticContext!=SemanticContext.NONE.
+        #
+        # From this, it is clear that NONE||anything==NONE.
+        #
+        altToPred = [None] * (nalts + 1)
+        for c in configs:
+            if c.alt in ambigAlts:
+                altToPred[c.alt] = orContext(altToPred[c.alt], c.semanticContext)
+
+        nPredAlts = 0
+        for i in range(1, nalts+1):
+            if altToPred[i] is None:
+                altToPred[i] = SemanticContext.NONE
+            elif altToPred[i] is not SemanticContext.NONE:
+                nPredAlts += 1
+
+        # nonambig alts are null in altToPred
+        if nPredAlts==0:
+            altToPred = None
+        if ParserATNSimulator.debug:
+            print("getPredsForAmbigAlts result " + str_list(altToPred))
+        return altToPred
+
+    def getPredicatePredictions(self, ambigAlts:set, altToPred:list):
+        pairs = []
+        containsPredicate = False
+        for i in range(1, len(altToPred)):
+            pred = altToPred[i]
+            # unpredicated is indicated by SemanticContext.NONE
+            if ambigAlts is not None and i in ambigAlts:
+                pairs.append(PredPrediction(pred, i))
+            if pred is not SemanticContext.NONE:
+                containsPredicate = True
+
+        if not containsPredicate:
+            return None
+
+        return pairs
+
+    #
+    # This method is used to improve the localization of error messages by
+    # choosing an alternative rather than throwing a
+    # {@link NoViableAltException} in particular prediction scenarios where the
+    # {@link #ERROR} state was reached during ATN simulation.
+    #
+    # <p>
+    # The default implementation of this method uses the following
+    # algorithm to identify an ATN configuration which successfully parsed the
+    # decision entry rule. Choosing such an alternative ensures that the
+    # {@link ParserRuleContext} returned by the calling rule will be complete
+    # and valid, and the syntax error will be reported later at a more
+    # localized location.</p>
+    #
+    # <ul>
+    # <li>If a syntactically valid path or paths reach the end of the decision rule and
+    # they are semantically valid if predicated, return the min associated alt.</li>
+    # <li>Else, if a semantically invalid but syntactically valid path exist
+    # or paths exist, return the minimum associated alt.
+    # </li>
+    # <li>Otherwise, return {@link ATN#INVALID_ALT_NUMBER}.</li>
+    # </ul>
+    #
+    # <p>
+    # In some scenarios, the algorithm described above could predict an
+    # alternative which will result in a {@link FailedPredicateException} in
+    # the parser. Specifically, this could occur if the <em>only</em> configuration
+    # capable of successfully parsing to the end of the decision rule is
+    # blocked by a semantic predicate. By choosing this alternative within
+    # {@link #adaptivePredict} instead of throwing a
+    # {@link NoViableAltException}, the resulting
+    # {@link FailedPredicateException} in the parser will identify the specific
+    # predicate which is preventing the parser from successfully parsing the
+    # decision rule, which helps developers identify and correct logic errors
+    # in semantic predicates.
+    # </p>
+    #
+    # @param configs The ATN configurations which were valid immediately before
+    # the {@link #ERROR} state was reached
+    # @param outerContext The is the \gamma_0 initial parser context from the paper
+    # or the parser stack at the instant before prediction commences.
+    #
+    # @return The value to return from {@link #adaptivePredict}, or
+    # {@link ATN#INVALID_ALT_NUMBER} if a suitable alternative was not
+    # identified and {@link #adaptivePredict} should report an error instead.
+    #
+    def getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(self, configs:ATNConfigSet, outerContext:ParserRuleContext):
+        semValidConfigs, semInvalidConfigs = self.splitAccordingToSemanticValidity(configs, outerContext)
+        alt = self.getAltThatFinishedDecisionEntryRule(semValidConfigs)
+        if alt!=ATN.INVALID_ALT_NUMBER: # semantically/syntactically viable path exists
+            return alt
+        # Is there a syntactically valid path with a failed pred?
+        if len(semInvalidConfigs)>0:
+            alt = self.getAltThatFinishedDecisionEntryRule(semInvalidConfigs)
+            if alt!=ATN.INVALID_ALT_NUMBER: # syntactically viable path exists
+                return alt
+        return ATN.INVALID_ALT_NUMBER
+
+    def getAltThatFinishedDecisionEntryRule(self, configs:ATNConfigSet):
+        alts = set()
+        for c in configs:
+            if c.reachesIntoOuterContext>0 or (isinstance(c.state, RuleStopState) and c.context.hasEmptyPath() ):
+                alts.add(c.alt)
+        if len(alts)==0:
+            return ATN.INVALID_ALT_NUMBER
+        else:
+            return min(alts)
+
+    # Walk the list of configurations and split them according to
+    #  those that have preds evaluating to true/false.  If no pred, assume
+    #  true pred and include in succeeded set.  Returns Pair of sets.
+    #
+    #  Create a new set so as not to alter the incoming parameter.
+    #
+    #  Assumption: the input stream has been restored to the starting point
+    #  prediction, which is where predicates need to evaluate.
+    #
+    def splitAccordingToSemanticValidity(self, configs:ATNConfigSet, outerContext:ParserRuleContext):
+        succeeded = ATNConfigSet(configs.fullCtx)
+        failed = ATNConfigSet(configs.fullCtx)
+        for c in configs:
+            if c.semanticContext is not SemanticContext.NONE:
+                predicateEvaluationResult = c.semanticContext.eval(self.parser, outerContext)
+                if predicateEvaluationResult:
+                    succeeded.add(c)
+                else:
+                    failed.add(c)
+            else:
+                succeeded.add(c)
+        return (succeeded,failed)
+
+    # Look through a list of predicate/alt pairs, returning alts for the
+    #  pairs that win. A {@code NONE} predicate indicates an alt containing an
+    #  unpredicated config which behaves as "always true." If !complete
+    #  then we stop at the first predicate that evaluates to true. This
+    #  includes pairs with null predicates.
+    #
+    def evalSemanticContext(self, predPredictions:list, outerContext:ParserRuleContext, complete:bool):
+        predictions = set()
+        for pair in predPredictions:
+            if pair.pred is SemanticContext.NONE:
+                predictions.add(pair.alt)
+                if not complete:
+                    break
+                continue
+            predicateEvaluationResult = pair.pred.eval(self.parser, outerContext)
+            if ParserATNSimulator.debug or ParserATNSimulator.dfa_debug:
+                print("eval pred " + str(pair) + "=" + str(predicateEvaluationResult))
+
+            if predicateEvaluationResult:
+                if ParserATNSimulator.debug or ParserATNSimulator.dfa_debug:
+                    print("PREDICT " + str(pair.alt))
+                predictions.add(pair.alt)
+                if not complete:
+                    break
+        return predictions
+
+
+    # TODO: If we are doing predicates, there is no point in pursuing
+    #     closure operations if we reach a DFA state that uniquely predicts
+    #     alternative. We will not be caching that DFA state and it is a
+    #     waste to pursue the closure. Might have to advance when we do
+    #     ambig detection thought :(
+    #
+
+    def closure(self, config:ATNConfig, configs:ATNConfigSet, closureBusy:set, collectPredicates:bool, fullCtx:bool, treatEofAsEpsilon:bool):
+        initialDepth = 0
+        self.closureCheckingStopState(config, configs, closureBusy, collectPredicates,
+                                 fullCtx, initialDepth, treatEofAsEpsilon)
+
+
+    def closureCheckingStopState(self, config:ATNConfig, configs:ATNConfigSet, closureBusy:set, collectPredicates:bool, fullCtx:bool, depth:int, treatEofAsEpsilon:bool):
+        if ParserATNSimulator.debug:
+            print("closure(" + str(config) + ")")
+
+        if isinstance(config.state, RuleStopState):
+            # We hit rule end. If we have context info, use it
+            # run thru all possible stack tops in ctx
+            if not config.context.isEmpty():
+                for i in range(0, len(config.context)):
+                    state = config.context.getReturnState(i)
+                    if state is PredictionContext.EMPTY_RETURN_STATE:
+                        if fullCtx:
+                            configs.add(ATNConfig(state=config.state, context=PredictionContext.EMPTY, config=config), self.mergeCache)
+                            continue
+                        else:
+                            # we have no context info, just chase follow links (if greedy)
+                            if ParserATNSimulator.debug:
+                                print("FALLING off rule " + self.getRuleName(config.state.ruleIndex))
+                            self.closure_(config, configs, closureBusy, collectPredicates,
+                                     fullCtx, depth, treatEofAsEpsilon)
+                        continue
+                    returnState = self.atn.states[state]
+                    newContext = config.context.getParent(i) # "pop" return state
+                    c = ATNConfig(state=returnState, alt=config.alt, context=newContext, semantic=config.semanticContext)
+                    # While we have context to pop back from, we may have
+                    # gotten that context AFTER having falling off a rule.
+                    # Make sure we track that we are now out of context.
+                    c.reachesIntoOuterContext = config.reachesIntoOuterContext
+                    self.closureCheckingStopState(c, configs, closureBusy, collectPredicates, fullCtx, depth - 1, treatEofAsEpsilon)
+                return
+            elif fullCtx:
+                # reached end of start rule
+                configs.add(config, self.mergeCache)
+                return
+            else:
+                # else if we have no context info, just chase follow links (if greedy)
+                if ParserATNSimulator.debug:
+                    print("FALLING off rule " + self.getRuleName(config.state.ruleIndex))
+
+        self.closure_(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEofAsEpsilon)
+
+    # Do the actual work of walking epsilon edges#
+    def closure_(self, config:ATNConfig, configs:ATNConfigSet, closureBusy:set, collectPredicates:bool, fullCtx:bool, depth:int, treatEofAsEpsilon:bool):
+        p = config.state
+        # optimization
+        if not p.epsilonOnlyTransitions:
+            configs.add(config, self.mergeCache)
+            # make sure to not return here, because EOF transitions can act as
+            # both epsilon transitions and non-epsilon transitions.
+
+        first = True
+        for t in p.transitions:
+            if first:
+                first = False
+                if self.canDropLoopEntryEdgeInLeftRecursiveRule(config):
+                    continue
+
+            continueCollecting = collectPredicates and not isinstance(t, ActionTransition)
+            c = self.getEpsilonTarget(config, t, continueCollecting, depth == 0, fullCtx, treatEofAsEpsilon)
+            if c is not None:
+                newDepth = depth
+                if isinstance( config.state, RuleStopState):
+                    # target fell off end of rule; mark resulting c as having dipped into outer context
+                    # We can't get here if incoming config was rule stop and we had context
+                    # track how far we dip into outer context.  Might
+                    # come in handy and we avoid evaluating context dependent
+                    # preds if this is > 0.
+                    if self._dfa is not None and self._dfa.precedenceDfa:
+                        if t.outermostPrecedenceReturn == self._dfa.atnStartState.ruleIndex:
+                            c.precedenceFilterSuppressed = True
+                    c.reachesIntoOuterContext += 1
+                    if c in closureBusy:
+                        # avoid infinite recursion for right-recursive rules
+                        continue
+                    closureBusy.add(c)
+                    configs.dipsIntoOuterContext = True # TODO: can remove? only care when we add to set per middle of this method
+                    newDepth -= 1
+                    if ParserATNSimulator.debug:
+                        print("dips into outer ctx: " + str(c))
+                else:
+                    if not t.isEpsilon:
+                        if c in closureBusy:
+                            # avoid infinite recursion for EOF* and EOF+
+                            continue
+                        closureBusy.add(c)
+                    if isinstance(t, RuleTransition):
+                        # latch when newDepth goes negative - once we step out of the entry context we can't return
+                        if newDepth >= 0:
+                            newDepth += 1
+
+                self.closureCheckingStopState(c, configs, closureBusy, continueCollecting, fullCtx, newDepth, treatEofAsEpsilon)
+
+
+
+    # Implements first-edge (loop entry) elimination as an optimization
+    #  during closure operations.  See antlr/antlr4#1398.
+    #
+    # The optimization is to avoid adding the loop entry config when
+    # the exit path can only lead back to the same
+    # StarLoopEntryState after popping context at the rule end state
+    # (traversing only epsilon edges, so we're still in closure, in
+    # this same rule).
+    #
+    # We need to detect any state that can reach loop entry on
+    # epsilon w/o exiting rule. We don't have to look at FOLLOW
+    # links, just ensure that all stack tops for config refer to key
+    # states in LR rule.
+    #
+    # To verify we are in the right situation we must first check
+    # closure is at a StarLoopEntryState generated during LR removal.
+    # Then we check that each stack top of context is a return state
+    # from one of these cases:
+    #
+    #   1. 'not' expr, '(' type ')' expr. The return state points at loop entry state
+    #   2. expr op expr. The return state is the block end of internal block of (...)*
+    #   3. 'between' expr 'and' expr. The return state of 2nd expr reference.
+    #      That state points at block end of internal block of (...)*.
+    #   4. expr '?' expr ':' expr. The return state points at block end,
+    #      which points at loop entry state.
+    #
+    # If any is true for each stack top, then closure does not add a
+    # config to the current config set for edge[0], the loop entry branch.
+    #
+    #  Conditions fail if any context for the current config is:
+    #
+    #   a. empty (we'd fall out of expr to do a global FOLLOW which could
+    #      even be to some weird spot in expr) or,
+    #   b. lies outside of expr or,
+    #   c. lies within expr but at a state not the BlockEndState
+    #   generated during LR removal
+    #
+    # Do we need to evaluate predicates ever in closure for this case?
+    #
+    # No. Predicates, including precedence predicates, are only
+    # evaluated when computing a DFA start state. I.e., only before
+    # the lookahead (but not parser) consumes a token.
+    #
+    # There are no epsilon edges allowed in LR rule alt blocks or in
+    # the "primary" part (ID here). If closure is in
+    # StarLoopEntryState any lookahead operation will have consumed a
+    # token as there are no epsilon-paths that lead to
+    # StarLoopEntryState. We do not have to evaluate predicates
+    # therefore if we are in the generated StarLoopEntryState of a LR
+    # rule. Note that when making a prediction starting at that
+    # decision point, decision d=2, compute-start-state performs
+    # closure starting at edges[0], edges[1] emanating from
+    # StarLoopEntryState. That means it is not performing closure on
+    # StarLoopEntryState during compute-start-state.
+    #
+    # How do we know this always gives same prediction answer?
+    #
+    # Without predicates, loop entry and exit paths are ambiguous
+    # upon remaining input +b (in, say, a+b). Either paths lead to
+    # valid parses. Closure can lead to consuming + immediately or by
+    # falling out of this call to expr back into expr and loop back
+    # again to StarLoopEntryState to match +b. In this special case,
+    # we choose the more efficient path, which is to take the bypass
+    # path.
+    #
+    # The lookahead language has not changed because closure chooses
+    # one path over the other. Both paths lead to consuming the same
+    # remaining input during a lookahead operation. If the next token
+    # is an operator, lookahead will enter the choice block with
+    # operators. If it is not, lookahead will exit expr. Same as if
+    # closure had chosen to enter the choice block immediately.
+    #
+    # Closure is examining one config (some loopentrystate, some alt,
+    # context) which means it is considering exactly one alt. Closure
+    # always copies the same alt to any derived configs.
+    #
+    # How do we know this optimization doesn't mess up precedence in
+    # our parse trees?
+    #
+    # Looking through expr from left edge of stat only has to confirm
+    # that an input, say, a+b+c; begins with any valid interpretation
+    # of an expression. The precedence actually doesn't matter when
+    # making a decision in stat seeing through expr. It is only when
+    # parsing rule expr that we must use the precedence to get the
+    # right interpretation and, hence, parse tree.
+    #
+    # @since 4.6
+    #
+    def canDropLoopEntryEdgeInLeftRecursiveRule(self, config):
+        # return False
+        p = config.state
+        # First check to see if we are in StarLoopEntryState generated during
+        # left-recursion elimination. For efficiency, also check if
+        # the context has an empty stack case. If so, it would mean
+        # global FOLLOW so we can't perform optimization
+        # Are we the special loop entry/exit state? or SLL wildcard
+        if p.stateType != ATNState.STAR_LOOP_ENTRY  \
+                or not p.isPrecedenceDecision       \
+                or config.context.isEmpty()         \
+                or config.context.hasEmptyPath():
+            return False
+
+        # Require all return states to return back to the same rule
+        # that p is in.
+        numCtxs = len(config.context)
+        for i in range(0, numCtxs):  # for each stack context
+            returnState = self.atn.states[config.context.getReturnState(i)]
+            if returnState.ruleIndex != p.ruleIndex:
+                return False
+
+        decisionStartState = p.transitions[0].target
+        blockEndStateNum = decisionStartState.endState.stateNumber
+        blockEndState = self.atn.states[blockEndStateNum]
+
+        # Verify that the top of each stack context leads to loop entry/exit
+        # state through epsilon edges and w/o leaving rule.
+        for i in range(0, numCtxs):  # for each stack context
+            returnStateNumber = config.context.getReturnState(i)
+            returnState = self.atn.states[returnStateNumber]
+            # all states must have single outgoing epsilon edge
+            if len(returnState.transitions) != 1 or not returnState.transitions[0].isEpsilon:
+                return False
+
+            # Look for prefix op case like 'not expr', (' type ')' expr
+            returnStateTarget = returnState.transitions[0].target
+            if returnState.stateType == ATNState.BLOCK_END and returnStateTarget is p:
+                continue
+
+            # Look for 'expr op expr' or case where expr's return state is block end
+            # of (...)* internal block; the block end points to loop back
+            # which points to p but we don't need to check that
+            if returnState is blockEndState:
+                continue
+
+            # Look for ternary expr ? expr : expr. The return state points at block end,
+            # which points at loop entry state
+            if returnStateTarget is blockEndState:
+                continue
+
+            # Look for complex prefix 'between expr and expr' case where 2nd expr's
+            # return state points at block end state of (...)* internal block
+            if returnStateTarget.stateType == ATNState.BLOCK_END \
+                and len(returnStateTarget.transitions) == 1 \
+                and returnStateTarget.transitions[0].isEpsilon \
+                and returnStateTarget.transitions[0].target is p:
+                    continue
+
+            # anything else ain't conforming
+            return False
+
+        return True
+
+
+    def getRuleName(self, index:int):
+        if self.parser is not None and index>=0:
+            return self.parser.ruleNames[index]
+        else:
+            return "<rule " + str(index) + ">"
+
+    epsilonTargetMethods = dict()
+    epsilonTargetMethods[Transition.RULE] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        sim.ruleTransition(config, t)
+    epsilonTargetMethods[Transition.PRECEDENCE] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        sim.precedenceTransition(config, t, collectPredicates, inContext, fullCtx)
+    epsilonTargetMethods[Transition.PREDICATE] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        sim.predTransition(config, t, collectPredicates, inContext, fullCtx)
+    epsilonTargetMethods[Transition.ACTION] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        sim.actionTransition(config, t)
+    epsilonTargetMethods[Transition.EPSILON] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        ATNConfig(state=t.target, config=config)
+    epsilonTargetMethods[Transition.ATOM] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        ATNConfig(state=t.target, config=config) if treatEofAsEpsilon and t.matches(Token.EOF, 0, 1) else None
+    epsilonTargetMethods[Transition.RANGE] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        ATNConfig(state=t.target, config=config) if treatEofAsEpsilon and t.matches(Token.EOF, 0, 1) else None
+    epsilonTargetMethods[Transition.SET] = lambda sim, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon: \
+        ATNConfig(state=t.target, config=config) if treatEofAsEpsilon and t.matches(Token.EOF, 0, 1) else None
+
+    def getEpsilonTarget(self, config:ATNConfig, t:Transition, collectPredicates:bool, inContext:bool, fullCtx:bool, treatEofAsEpsilon:bool):
+        m = self.epsilonTargetMethods.get(t.serializationType, None)
+        if m is None:
+            return None
+        else:
+            return m(self, config, t, collectPredicates, inContext, fullCtx, treatEofAsEpsilon)
+
+    def actionTransition(self, config:ATNConfig, t:ActionTransition):
+        if ParserATNSimulator.debug:
+            print("ACTION edge " + str(t.ruleIndex) + ":" + str(t.actionIndex))
+        return ATNConfig(state=t.target, config=config)
+
+    def precedenceTransition(self, config:ATNConfig, pt:PrecedencePredicateTransition,  collectPredicates:bool, inContext:bool, fullCtx:bool):
+        if ParserATNSimulator.debug:
+            print("PRED (collectPredicates=" + str(collectPredicates) + ") " +
+                    str(pt.precedence) + ">=_p, ctx dependent=true")
+            if self.parser is not None:
+                print("context surrounding pred is " + str(self.parser.getRuleInvocationStack()))
+
+        c = None
+        if collectPredicates and inContext:
+            if fullCtx:
+                # In full context mode, we can evaluate predicates on-the-fly
+                # during closure, which dramatically reduces the size of
+                # the config sets. It also obviates the need to test predicates
+                # later during conflict resolution.
+                currentPosition = self._input.index
+                self._input.seek(self._startIndex)
+                predSucceeds = pt.getPredicate().eval(self.parser, self._outerContext)
+                self._input.seek(currentPosition)
+                if predSucceeds:
+                    c = ATNConfig(state=pt.target, config=config) # no pred context
+            else:
+                newSemCtx = andContext(config.semanticContext, pt.getPredicate())
+                c = ATNConfig(state=pt.target, semantic=newSemCtx, config=config)
+        else:
+            c = ATNConfig(state=pt.target, config=config)
+
+        if ParserATNSimulator.debug:
+            print("config from pred transition=" + str(c))
+        return c
+
+    def predTransition(self, config:ATNConfig, pt:PredicateTransition, collectPredicates:bool, inContext:bool, fullCtx:bool):
+        if ParserATNSimulator.debug:
+            print("PRED (collectPredicates=" + str(collectPredicates) + ") " + str(pt.ruleIndex) +
+                    ":" + str(pt.predIndex) + ", ctx dependent=" + str(pt.isCtxDependent))
+            if self.parser is not None:
+                print("context surrounding pred is " + str(self.parser.getRuleInvocationStack()))
+
+        c = None
+        if collectPredicates and (not pt.isCtxDependent or (pt.isCtxDependent and inContext)):
+            if fullCtx:
+                # In full context mode, we can evaluate predicates on-the-fly
+                # during closure, which dramatically reduces the size of
+                # the config sets. It also obviates the need to test predicates
+                # later during conflict resolution.
+                currentPosition = self._input.index
+                self._input.seek(self._startIndex)
+                predSucceeds = pt.getPredicate().eval(self.parser, self._outerContext)
+                self._input.seek(currentPosition)
+                if predSucceeds:
+                    c = ATNConfig(state=pt.target, config=config) # no pred context
+            else:
+                newSemCtx = andContext(config.semanticContext, pt.getPredicate())
+                c = ATNConfig(state=pt.target, semantic=newSemCtx, config=config)
+        else:
+            c = ATNConfig(state=pt.target, config=config)
+
+        if ParserATNSimulator.debug:
+            print("config from pred transition=" + str(c))
+        return c
+
+    def ruleTransition(self, config:ATNConfig, t:RuleTransition):
+        if ParserATNSimulator.debug:
+            print("CALL rule " + self.getRuleName(t.target.ruleIndex) + ", ctx=" + str(config.context))
+        returnState = t.followState
+        newContext = SingletonPredictionContext.create(config.context, returnState.stateNumber)
+        return ATNConfig(state=t.target, context=newContext, config=config )
+
+    def getConflictingAlts(self, configs:ATNConfigSet):
+        altsets = PredictionMode.getConflictingAltSubsets(configs)
+        return PredictionMode.getAlts(altsets)
+
+     # Sam pointed out a problem with the previous definition, v3, of
+     # ambiguous states. If we have another state associated with conflicting
+     # alternatives, we should keep going. For example, the following grammar
+     #
+     # s : (ID | ID ID?) ';' ;
+     #
+     # When the ATN simulation reaches the state before ';', it has a DFA
+     # state that looks like: [12|1|[], 6|2|[], 12|2|[]]. Naturally
+     # 12|1|[] and 12|2|[] conflict, but we cannot stop processing this node
+     # because alternative to has another way to continue, via [6|2|[]].
+     # The key is that we have a single state that has config's only associated
+     # with a single alternative, 2, and crucially the state transitions
+     # among the configurations are all non-epsilon transitions. That means
+     # we don't consider any conflicts that include alternative 2. So, we
+     # ignore the conflict between alts 1 and 2. We ignore a set of
+     # conflicting alts when there is an intersection with an alternative
+     # associated with a single alt state in the state&rarr;config-list map.
+     #
+     # It's also the case that we might have two conflicting configurations but
+     # also a 3rd nonconflicting configuration for a different alternative:
+     # [1|1|[], 1|2|[], 8|3|[]]. This can come about from grammar:
+     #
+     # a : A | A | A B ;
+     #
+     # After matching input A, we reach the stop state for rule A, state 1.
+     # State 8 is the state right before B. Clearly alternatives 1 and 2
+     # conflict and no amount of further lookahead will separate the two.
+     # However, alternative 3 will be able to continue and so we do not
+     # stop working on this state. In the previous example, we're concerned
+     # with states associated with the conflicting alternatives. Here alt
+     # 3 is not associated with the conflicting configs, but since we can continue
+     # looking for input reasonably, I don't declare the state done. We
+     # ignore a set of conflicting alts when we have an alternative
+     # that we still need to pursue.
+    #
+
+    def getConflictingAltsOrUniqueAlt(self, configs:ATNConfigSet):
+        conflictingAlts = None
+        if configs.uniqueAlt!= ATN.INVALID_ALT_NUMBER:
+            conflictingAlts = set()
+            conflictingAlts.add(configs.uniqueAlt)
+        else:
+            conflictingAlts = configs.conflictingAlts
+        return conflictingAlts
+
+    def getTokenName(self, t:int):
+        if t==Token.EOF:
+            return "EOF"
+        if self.parser is not None and \
+            self.parser.literalNames is not None and \
+            t < len(self.parser.literalNames):
+                 return self.parser.literalNames[t] + "<" + str(t) + ">"
+        else:
+            return str(t)
+
+    def getLookaheadName(self, input:TokenStream):
+        return self.getTokenName(input.LA(1))
+
+    # Used for debugging in adaptivePredict around execATN but I cut
+    #  it out for clarity now that alg. works well. We can leave this
+    #  "dead" code for a bit.
+    #
+    def dumpDeadEndConfigs(self, nvae:NoViableAltException):
+        print("dead end configs: ")
+        for c in nvae.getDeadEndConfigs():
+            trans = "no edges"
+            if len(c.state.transitions)>0:
+                t = c.state.transitions[0]
+                if isinstance(t, AtomTransition):
+                    trans = "Atom "+ self.getTokenName(t.label)
+                elif isinstance(t, SetTransition):
+                    neg = isinstance(t, NotSetTransition)
+                    trans = ("~" if neg else "")+"Set "+ str(t.set)
+            print(c.toString(self.parser, True) + ":" + trans, file=sys.stderr)
+
+    def noViableAlt(self, input:TokenStream, outerContext:ParserRuleContext, configs:ATNConfigSet, startIndex:int):
+        return NoViableAltException(self.parser, input, input.get(startIndex), input.LT(1), configs, outerContext)
+
+    def getUniqueAlt(self, configs:ATNConfigSet):
+        alt = ATN.INVALID_ALT_NUMBER
+        for c in configs:
+            if alt == ATN.INVALID_ALT_NUMBER:
+                alt = c.alt # found first alt
+            elif c.alt!=alt:
+                return ATN.INVALID_ALT_NUMBER
+        return alt
+
+    #
+    # Add an edge to the DFA, if possible. This method calls
+    # {@link #addDFAState} to ensure the {@code to} state is present in the
+    # DFA. If {@code from} is {@code null}, or if {@code t} is outside the
+    # range of edges that can be represented in the DFA tables, this method
+    # returns without adding the edge to the DFA.
+    #
+    # <p>If {@code to} is {@code null}, this method returns {@code null}.
+    # Otherwise, this method returns the {@link DFAState} returned by calling
+    # {@link #addDFAState} for the {@code to} state.</p>
+    #
+    # @param dfa The DFA
+    # @param from The source state for the edge
+    # @param t The input symbol
+    # @param to The target state for the edge
+    #
+    # @return If {@code to} is {@code null}, this method returns {@code null};
+    # otherwise this method returns the result of calling {@link #addDFAState}
+    # on {@code to}
+    #
+    def addDFAEdge(self, dfa:DFA, from_:DFAState, t:int, to:DFAState):
+        if ParserATNSimulator.debug:
+            print("EDGE " + str(from_) + " -> " + str(to) + " upon " + self.getTokenName(t))
+
+        if to is None:
+            return None
+
+        to = self.addDFAState(dfa, to) # used existing if possible not incoming
+        if from_ is None or t < -1 or t > self.atn.maxTokenType:
+            return to
+
+        if from_.edges is None:
+            from_.edges = [None] * (self.atn.maxTokenType + 2)
+        from_.edges[t+1] = to # connect
+
+        if ParserATNSimulator.debug:
+            names = None if self.parser is None else self.parser.literalNames
+            print("DFA=\n" + dfa.toString(names))
+
+        return to
+
+    #
+    # Add state {@code D} to the DFA if it is not already present, and return
+    # the actual instance stored in the DFA. If a state equivalent to {@code D}
+    # is already in the DFA, the existing state is returned. Otherwise this
+    # method returns {@code D} after adding it to the DFA.
+    #
+    # <p>If {@code D} is {@link #ERROR}, this method returns {@link #ERROR} and
+    # does not change the DFA.</p>
+    #
+    # @param dfa The dfa
+    # @param D The DFA state to add
+    # @return The state stored in the DFA. This will be either the existing
+    # state if {@code D} is already in the DFA, or {@code D} itself if the
+    # state was not already present.
+    #
+    def addDFAState(self, dfa:DFA, D:DFAState):
+        if D is self.ERROR:
+            return D
+
+
+        existing = dfa.states.get(D, None)
+        if existing is not None:
+            return existing
+
+        D.stateNumber = len(dfa.states)
+        if not D.configs.readonly:
+            D.configs.optimizeConfigs(self)
+            D.configs.setReadonly(True)
+        dfa.states[D] = D
+        if ParserATNSimulator.debug:
+            print("adding new DFA state: " + str(D))
+        return D
+
+    def reportAttemptingFullContext(self, dfa:DFA, conflictingAlts:set, configs:ATNConfigSet, startIndex:int, stopIndex:int):
+        if ParserATNSimulator.debug or ParserATNSimulator.retry_debug:
+            print("reportAttemptingFullContext decision=" + str(dfa.decision) + ":" + str(configs) +
+                               ", input=" + self.parser.getTokenStream().getText(startIndex, stopIndex))
+        if self.parser is not None:
+            self.parser.getErrorListenerDispatch().reportAttemptingFullContext(self.parser, dfa, startIndex, stopIndex, conflictingAlts, configs)
+
+    def reportContextSensitivity(self, dfa:DFA, prediction:int, configs:ATNConfigSet, startIndex:int, stopIndex:int):
+        if ParserATNSimulator.debug or ParserATNSimulator.retry_debug:
+            print("reportContextSensitivity decision=" + str(dfa.decision) + ":" + str(configs) +
+                               ", input=" + self.parser.getTokenStream().getText(startIndex, stopIndex))
+        if self.parser is not None:
+            self.parser.getErrorListenerDispatch().reportContextSensitivity(self.parser, dfa, startIndex, stopIndex, prediction, configs)
+
+    # If context sensitive parsing, we know it's ambiguity not conflict#
+    def reportAmbiguity(self, dfa:DFA, D:DFAState, startIndex:int, stopIndex:int,
+                                   exact:bool, ambigAlts:set, configs:ATNConfigSet ):
+        if ParserATNSimulator.debug or ParserATNSimulator.retry_debug:
+#			ParserATNPathFinder finder = new ParserATNPathFinder(parser, atn);
+#			int i = 1;
+#			for (Transition t : dfa.atnStartState.transitions) {
+#				print("ALT "+i+"=");
+#				print(startIndex+".."+stopIndex+", len(input)="+parser.getInputStream().size());
+#				TraceTree path = finder.trace(t.target, parser.getContext(), (TokenStream)parser.getInputStream(),
+#											  startIndex, stopIndex);
+#				if ( path!=null ) {
+#					print("path = "+path.toStringTree());
+#					for (TraceTree leaf : path.leaves) {
+#						List<ATNState> states = path.getPathToNode(leaf);
+#						print("states="+states);
+#					}
+#				}
+#				i++;
+#			}
+            print("reportAmbiguity " + str(ambigAlts) + ":" + str(configs) +
+                               ", input=" + self.parser.getTokenStream().getText(startIndex, stopIndex))
+        if self.parser is not None:
+            self.parser.getErrorListenerDispatch().reportAmbiguity(self.parser, dfa, startIndex, stopIndex, exact, ambigAlts, configs)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/atn/PredictionMode.py

@@ -0,0 +1,499 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+#
+# This enumeration defines the prediction modes available in ANTLR 4 along with
+# utility methods for analyzing configuration sets for conflicts and/or
+# ambiguities.
+
+
+from enum import Enum
+from antlr4.atn.ATN import ATN
+from antlr4.atn.ATNConfig import ATNConfig
+from antlr4.atn.ATNConfigSet import ATNConfigSet
+from antlr4.atn.ATNState import RuleStopState
+from antlr4.atn.SemanticContext import SemanticContext
+
+PredictionMode = None
+
+class PredictionMode(Enum):
+    #
+    # The SLL(*) prediction mode. This prediction mode ignores the current
+    # parser context when making predictions. This is the fastest prediction
+    # mode, and provides correct results for many grammars. This prediction
+    # mode is more powerful than the prediction mode provided by ANTLR 3, but
+    # may result in syntax errors for grammar and input combinations which are
+    # not SLL.
+    #
+    # <p>
+    # When using this prediction mode, the parser will either return a correct
+    # parse tree (i.e. the same parse tree that would be returned with the
+    # {@link #LL} prediction mode), or it will report a syntax error. If a
+    # syntax error is encountered when using the {@link #SLL} prediction mode,
+    # it may be due to either an actual syntax error in the input or indicate
+    # that the particular combination of grammar and input requires the more
+    # powerful {@link #LL} prediction abilities to complete successfully.</p>
+    #
+    # <p>
+    # This prediction mode does not provide any guarantees for prediction
+    # behavior for syntactically-incorrect inputs.</p>
+    #
+    SLL = 0
+    #
+    # The LL(*) prediction mode. This prediction mode allows the current parser
+    # context to be used for resolving SLL conflicts that occur during
+    # prediction. This is the fastest prediction mode that guarantees correct
+    # parse results for all combinations of grammars with syntactically correct
+    # inputs.
+    #
+    # <p>
+    # When using this prediction mode, the parser will make correct decisions
+    # for all syntactically-correct grammar and input combinations. However, in
+    # cases where the grammar is truly ambiguous this prediction mode might not
+    # report a precise answer for <em>exactly which</em> alternatives are
+    # ambiguous.</p>
+    #
+    # <p>
+    # This prediction mode does not provide any guarantees for prediction
+    # behavior for syntactically-incorrect inputs.</p>
+    #
+    LL = 1
+    #
+    # The LL(*) prediction mode with exact ambiguity detection. In addition to
+    # the correctness guarantees provided by the {@link #LL} prediction mode,
+    # this prediction mode instructs the prediction algorithm to determine the
+    # complete and exact set of ambiguous alternatives for every ambiguous
+    # decision encountered while parsing.
+    #
+    # <p>
+    # This prediction mode may be used for diagnosing ambiguities during
+    # grammar development. Due to the performance overhead of calculating sets
+    # of ambiguous alternatives, this prediction mode should be avoided when
+    # the exact results are not necessary.</p>
+    #
+    # <p>
+    # This prediction mode does not provide any guarantees for prediction
+    # behavior for syntactically-incorrect inputs.</p>
+    #
+    LL_EXACT_AMBIG_DETECTION = 2
+
+
+    #
+    # Computes the SLL prediction termination condition.
+    #
+    # <p>
+    # This method computes the SLL prediction termination condition for both of
+    # the following cases.</p>
+    #
+    # <ul>
+    # <li>The usual SLL+LL fallback upon SLL conflict</li>
+    # <li>Pure SLL without LL fallback</li>
+    # </ul>
+    #
+    # <p><strong>COMBINED SLL+LL PARSING</strong></p>
+    #
+    # <p>When LL-fallback is enabled upon SLL conflict, correct predictions are
+    # ensured regardless of how the termination condition is computed by this
+    # method. Due to the substantially higher cost of LL prediction, the
+    # prediction should only fall back to LL when the additional lookahead
+    # cannot lead to a unique SLL prediction.</p>
+    #
+    # <p>Assuming combined SLL+LL parsing, an SLL configuration set with only
+    # conflicting subsets should fall back to full LL, even if the
+    # configuration sets don't resolve to the same alternative (e.g.
+    # {@code {1,2}} and {@code {3,4}}. If there is at least one non-conflicting
+    # configuration, SLL could continue with the hopes that more lookahead will
+    # resolve via one of those non-conflicting configurations.</p>
+    #
+    # <p>Here's the prediction termination rule them: SLL (for SLL+LL parsing)
+    # stops when it sees only conflicting configuration subsets. In contrast,
+    # full LL keeps going when there is uncertainty.</p>
+    #
+    # <p><strong>HEURISTIC</strong></p>
+    #
+    # <p>As a heuristic, we stop prediction when we see any conflicting subset
+    # unless we see a state that only has one alternative associated with it.
+    # The single-alt-state thing lets prediction continue upon rules like
+    # (otherwise, it would admit defeat too soon):</p>
+    #
+    # <p>{@code [12|1|[], 6|2|[], 12|2|[]]. s : (ID | ID ID?) ';' ;}</p>
+    #
+    # <p>When the ATN simulation reaches the state before {@code ';'}, it has a
+    # DFA state that looks like: {@code [12|1|[], 6|2|[], 12|2|[]]}. Naturally
+    # {@code 12|1|[]} and {@code 12|2|[]} conflict, but we cannot stop
+    # processing this node because alternative to has another way to continue,
+    # via {@code [6|2|[]]}.</p>
+    #
+    # <p>It also let's us continue for this rule:</p>
+    #
+    # <p>{@code [1|1|[], 1|2|[], 8|3|[]] a : A | A | A B ;}</p>
+    #
+    # <p>After matching input A, we reach the stop state for rule A, state 1.
+    # State 8 is the state right before B. Clearly alternatives 1 and 2
+    # conflict and no amount of further lookahead will separate the two.
+    # However, alternative 3 will be able to continue and so we do not stop
+    # working on this state. In the previous example, we're concerned with
+    # states associated with the conflicting alternatives. Here alt 3 is not
+    # associated with the conflicting configs, but since we can continue
+    # looking for input reasonably, don't declare the state done.</p>
+    #
+    # <p><strong>PURE SLL PARSING</strong></p>
+    #
+    # <p>To handle pure SLL parsing, all we have to do is make sure that we
+    # combine stack contexts for configurations that differ only by semantic
+    # predicate. From there, we can do the usual SLL termination heuristic.</p>
+    #
+    # <p><strong>PREDICATES IN SLL+LL PARSING</strong></p>
+    #
+    # <p>SLL decisions don't evaluate predicates until after they reach DFA stop
+    # states because they need to create the DFA cache that works in all
+    # semantic situations. In contrast, full LL evaluates predicates collected
+    # during start state computation so it can ignore predicates thereafter.
+    # This means that SLL termination detection can totally ignore semantic
+    # predicates.</p>
+    #
+    # <p>Implementation-wise, {@link ATNConfigSet} combines stack contexts but not
+    # semantic predicate contexts so we might see two configurations like the
+    # following.</p>
+    #
+    # <p>{@code (s, 1, x, {}), (s, 1, x', {p})}</p>
+    #
+    # <p>Before testing these configurations against others, we have to merge
+    # {@code x} and {@code x'} (without modifying the existing configurations).
+    # For example, we test {@code (x+x')==x''} when looking for conflicts in
+    # the following configurations.</p>
+    #
+    # <p>{@code (s, 1, x, {}), (s, 1, x', {p}), (s, 2, x'', {})}</p>
+    #
+    # <p>If the configuration set has predicates (as indicated by
+    # {@link ATNConfigSet#hasSemanticContext}), this algorithm makes a copy of
+    # the configurations to strip out all of the predicates so that a standard
+    # {@link ATNConfigSet} will merge everything ignoring predicates.</p>
+    #
+    @classmethod
+    def hasSLLConflictTerminatingPrediction(cls, mode:PredictionMode, configs:ATNConfigSet):
+        # Configs in rule stop states indicate reaching the end of the decision
+        # rule (local context) or end of start rule (full context). If all
+        # configs meet this condition, then none of the configurations is able
+        # to match additional input so we terminate prediction.
+        #
+        if cls.allConfigsInRuleStopStates(configs):
+            return True
+
+        # pure SLL mode parsing
+        if mode == PredictionMode.SLL:
+            # Don't bother with combining configs from different semantic
+            # contexts if we can fail over to full LL; costs more time
+            # since we'll often fail over anyway.
+            if configs.hasSemanticContext:
+                # dup configs, tossing out semantic predicates
+                dup = ATNConfigSet()
+                for c in configs:
+                    c = ATNConfig(config=c, semantic=SemanticContext.NONE)
+                    dup.add(c)
+                configs = dup
+            # now we have combined contexts for configs with dissimilar preds
+
+        # pure SLL or combined SLL+LL mode parsing
+        altsets = cls.getConflictingAltSubsets(configs)
+        return cls.hasConflictingAltSet(altsets) and not cls.hasStateAssociatedWithOneAlt(configs)
+
+    # Checks if any configuration in {@code configs} is in a
+    # {@link RuleStopState}. Configurations meeting this condition have reached
+    # the end of the decision rule (local context) or end of start rule (full
+    # context).
+    #
+    # @param configs the configuration set to test
+    # @return {@code true} if any configuration in {@code configs} is in a
+    # {@link RuleStopState}, otherwise {@code false}
+    @classmethod
+    def hasConfigInRuleStopState(cls, configs:ATNConfigSet):
+        return any(isinstance(cfg.state, RuleStopState) for cfg in configs)
+
+    # Checks if all configurations in {@code configs} are in a
+    # {@link RuleStopState}. Configurations meeting this condition have reached
+    # the end of the decision rule (local context) or end of start rule (full
+    # context).
+    #
+    # @param configs the configuration set to test
+    # @return {@code true} if all configurations in {@code configs} are in a
+    # {@link RuleStopState}, otherwise {@code false}
+    @classmethod
+    def allConfigsInRuleStopStates(cls, configs:ATNConfigSet):
+        return all(isinstance(cfg.state, RuleStopState) for cfg in configs)
+
+    #
+    # Full LL prediction termination.
+    #
+    # <p>Can we stop looking ahead during ATN simulation or is there some
+    # uncertainty as to which alternative we will ultimately pick, after
+    # consuming more input? Even if there are partial conflicts, we might know
+    # that everything is going to resolve to the same minimum alternative. That
+    # means we can stop since no more lookahead will change that fact. On the
+    # other hand, there might be multiple conflicts that resolve to different
+    # minimums. That means we need more look ahead to decide which of those
+    # alternatives we should predict.</p>
+    #
+    # <p>The basic idea is to split the set of configurations {@code C}, into
+    # conflicting subsets {@code (s, _, ctx, _)} and singleton subsets with
+    # non-conflicting configurations. Two configurations conflict if they have
+    # identical {@link ATNConfig#state} and {@link ATNConfig#context} values
+    # but different {@link ATNConfig#alt} value, e.g. {@code (s, i, ctx, _)}
+    # and {@code (s, j, ctx, _)} for {@code i!=j}.</p>
+    #
+    # <p>Reduce these configuration subsets to the set of possible alternatives.
+    # You can compute the alternative subsets in one pass as follows:</p>
+    #
+    # <p>{@code A_s,ctx = {i | (s, i, ctx, _)}} for each configuration in
+    # {@code C} holding {@code s} and {@code ctx} fixed.</p>
+    #
+    # <p>Or in pseudo-code, for each configuration {@code c} in {@code C}:</p>
+    #
+    # <pre>
+    # map[c] U= c.{@link ATNConfig#alt alt} # map hash/equals uses s and x, not
+    # alt and not pred
+    # </pre>
+    #
+    # <p>The values in {@code map} are the set of {@code A_s,ctx} sets.</p>
+    #
+    # <p>If {@code |A_s,ctx|=1} then there is no conflict associated with
+    # {@code s} and {@code ctx}.</p>
+    #
+    # <p>Reduce the subsets to singletons by choosing a minimum of each subset. If
+    # the union of these alternative subsets is a singleton, then no amount of
+    # more lookahead will help us. We will always pick that alternative. If,
+    # however, there is more than one alternative, then we are uncertain which
+    # alternative to predict and must continue looking for resolution. We may
+    # or may not discover an ambiguity in the future, even if there are no
+    # conflicting subsets this round.</p>
+    #
+    # <p>The biggest sin is to terminate early because it means we've made a
+    # decision but were uncertain as to the eventual outcome. We haven't used
+    # enough lookahead. On the other hand, announcing a conflict too late is no
+    # big deal; you will still have the conflict. It's just inefficient. It
+    # might even look until the end of file.</p>
+    #
+    # <p>No special consideration for semantic predicates is required because
+    # predicates are evaluated on-the-fly for full LL prediction, ensuring that
+    # no configuration contains a semantic context during the termination
+    # check.</p>
+    #
+    # <p><strong>CONFLICTING CONFIGS</strong></p>
+    #
+    # <p>Two configurations {@code (s, i, x)} and {@code (s, j, x')}, conflict
+    # when {@code i!=j} but {@code x=x'}. Because we merge all
+    # {@code (s, i, _)} configurations together, that means that there are at
+    # most {@code n} configurations associated with state {@code s} for
+    # {@code n} possible alternatives in the decision. The merged stacks
+    # complicate the comparison of configuration contexts {@code x} and
+    # {@code x'}. Sam checks to see if one is a subset of the other by calling
+    # merge and checking to see if the merged result is either {@code x} or
+    # {@code x'}. If the {@code x} associated with lowest alternative {@code i}
+    # is the superset, then {@code i} is the only possible prediction since the
+    # others resolve to {@code min(i)} as well. However, if {@code x} is
+    # associated with {@code j>i} then at least one stack configuration for
+    # {@code j} is not in conflict with alternative {@code i}. The algorithm
+    # should keep going, looking for more lookahead due to the uncertainty.</p>
+    #
+    # <p>For simplicity, I'm doing a equality check between {@code x} and
+    # {@code x'} that lets the algorithm continue to consume lookahead longer
+    # than necessary. The reason I like the equality is of course the
+    # simplicity but also because that is the test you need to detect the
+    # alternatives that are actually in conflict.</p>
+    #
+    # <p><strong>CONTINUE/STOP RULE</strong></p>
+    #
+    # <p>Continue if union of resolved alternative sets from non-conflicting and
+    # conflicting alternative subsets has more than one alternative. We are
+    # uncertain about which alternative to predict.</p>
+    #
+    # <p>The complete set of alternatives, {@code [i for (_,i,_)]}, tells us which
+    # alternatives are still in the running for the amount of input we've
+    # consumed at this point. The conflicting sets let us to strip away
+    # configurations that won't lead to more states because we resolve
+    # conflicts to the configuration with a minimum alternate for the
+    # conflicting set.</p>
+    #
+    # <p><strong>CASES</strong></p>
+    #
+    # <ul>
+    #
+    # <li>no conflicts and more than 1 alternative in set =&gt; continue</li>
+    #
+    # <li> {@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s, 3, z)},
+    # {@code (s', 1, y)}, {@code (s', 2, y)} yields non-conflicting set
+    # {@code {3}} U conflicting sets {@code min({1,2})} U {@code min({1,2})} =
+    # {@code {1,3}} =&gt; continue
+    # </li>
+    #
+    # <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 1, y)},
+    # {@code (s', 2, y)}, {@code (s'', 1, z)} yields non-conflicting set
+    # {@code {1}} U conflicting sets {@code min({1,2})} U {@code min({1,2})} =
+    # {@code {1}} =&gt; stop and predict 1</li>
+    #
+    # <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 1, y)},
+    # {@code (s', 2, y)} yields conflicting, reduced sets {@code {1}} U
+    # {@code {1}} = {@code {1}} =&gt; stop and predict 1, can announce
+    # ambiguity {@code {1,2}}</li>
+    #
+    # <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 2, y)},
+    # {@code (s', 3, y)} yields conflicting, reduced sets {@code {1}} U
+    # {@code {2}} = {@code {1,2}} =&gt; continue</li>
+    #
+    # <li>{@code (s, 1, x)}, {@code (s, 2, x)}, {@code (s', 3, y)},
+    # {@code (s', 4, y)} yields conflicting, reduced sets {@code {1}} U
+    # {@code {3}} = {@code {1,3}} =&gt; continue</li>
+    #
+    # </ul>
+    #
+    # <p><strong>EXACT AMBIGUITY DETECTION</strong></p>
+    #
+    # <p>If all states report the same conflicting set of alternatives, then we
+    # know we have the exact ambiguity set.</p>
+    #
+    # <p><code>|A_<em>i</em>|&gt;1</code> and
+    # <code>A_<em>i</em> = A_<em>j</em></code> for all <em>i</em>, <em>j</em>.</p>
+    #
+    # <p>In other words, we continue examining lookahead until all {@code A_i}
+    # have more than one alternative and all {@code A_i} are the same. If
+    # {@code A={{1,2}, {1,3}}}, then regular LL prediction would terminate
+    # because the resolved set is {@code {1}}. To determine what the real
+    # ambiguity is, we have to know whether the ambiguity is between one and
+    # two or one and three so we keep going. We can only stop prediction when
+    # we need exact ambiguity detection when the sets look like
+    # {@code A={{1,2}}} or {@code {{1,2},{1,2}}}, etc...</p>
+    #
+    @classmethod
+    def resolvesToJustOneViableAlt(cls, altsets:list):
+        return cls.getSingleViableAlt(altsets)
+
+    #
+    # Determines if every alternative subset in {@code altsets} contains more
+    # than one alternative.
+    #
+    # @param altsets a collection of alternative subsets
+    # @return {@code true} if every {@link BitSet} in {@code altsets} has
+    # {@link BitSet#cardinality cardinality} &gt; 1, otherwise {@code false}
+    #
+    @classmethod
+    def allSubsetsConflict(cls, altsets:list):
+        return not cls.hasNonConflictingAltSet(altsets)
+
+    #
+    # Determines if any single alternative subset in {@code altsets} contains
+    # exactly one alternative.
+    #
+    # @param altsets a collection of alternative subsets
+    # @return {@code true} if {@code altsets} contains a {@link BitSet} with
+    # {@link BitSet#cardinality cardinality} 1, otherwise {@code false}
+    #
+    @classmethod
+    def hasNonConflictingAltSet(cls, altsets:list):
+        return any(len(alts) == 1 for alts in altsets)
+
+    #
+    # Determines if any single alternative subset in {@code altsets} contains
+    # more than one alternative.
+    #
+    # @param altsets a collection of alternative subsets
+    # @return {@code true} if {@code altsets} contains a {@link BitSet} with
+    # {@link BitSet#cardinality cardinality} &gt; 1, otherwise {@code false}
+    #
+    @classmethod
+    def hasConflictingAltSet(cls, altsets:list):
+        return any(len(alts) > 1 for alts in altsets)
+
+    #
+    # Determines if every alternative subset in {@code altsets} is equivalent.
+    #
+    # @param altsets a collection of alternative subsets
+    # @return {@code true} if every member of {@code altsets} is equal to the
+    # others, otherwise {@code false}
+    #
+    @classmethod
+    def allSubsetsEqual(cls, altsets:list):
+        if not altsets:
+            return True
+        first = next(iter(altsets))
+        return all(alts == first for alts in iter(altsets))
+
+    #
+    # Returns the unique alternative predicted by all alternative subsets in
+    # {@code altsets}. If no such alternative exists, this method returns
+    # {@link ATN#INVALID_ALT_NUMBER}.
+    #
+    # @param altsets a collection of alternative subsets
+    #
+    @classmethod
+    def getUniqueAlt(cls, altsets:list):
+        all = cls.getAlts(altsets)
+        if len(all)==1:
+            return next(iter(all))
+        return ATN.INVALID_ALT_NUMBER
+
+    # Gets the complete set of represented alternatives for a collection of
+    # alternative subsets. This method returns the union of each {@link BitSet}
+    # in {@code altsets}.
+    #
+    # @param altsets a collection of alternative subsets
+    # @return the set of represented alternatives in {@code altsets}
+    #
+    @classmethod
+    def getAlts(cls, altsets:list):
+        return set.union(*altsets)
+
+    #
+    # This function gets the conflicting alt subsets from a configuration set.
+    # For each configuration {@code c} in {@code configs}:
+    #
+    # <pre>
+    # map[c] U= c.{@link ATNConfig#alt alt} # map hash/equals uses s and x, not
+    # alt and not pred
+    # </pre>
+    #
+    @classmethod
+    def getConflictingAltSubsets(cls, configs:ATNConfigSet):
+        configToAlts = dict()
+        for c in configs:
+            h = hash((c.state.stateNumber, c.context))
+            alts = configToAlts.get(h, None)
+            if alts is None:
+                alts = set()
+                configToAlts[h] = alts
+            alts.add(c.alt)
+        return configToAlts.values()
+
+    #
+    # Get a map from state to alt subset from a configuration set. For each
+    # configuration {@code c} in {@code configs}:
+    #
+    # <pre>
+    # map[c.{@link ATNConfig#state state}] U= c.{@link ATNConfig#alt alt}
+    # </pre>
+    #
+    @classmethod
+    def getStateToAltMap(cls, configs:ATNConfigSet):
+        m = dict()
+        for c in configs:
+            alts = m.get(c.state, None)
+            if alts is None:
+                alts = set()
+                m[c.state] = alts
+            alts.add(c.alt)
+        return m
+
+    @classmethod
+    def hasStateAssociatedWithOneAlt(cls, configs:ATNConfigSet):
+        return any(len(alts) == 1 for alts in cls.getStateToAltMap(configs).values())
+
+    @classmethod
+    def getSingleViableAlt(cls, altsets:list):
+        viableAlts = set()
+        for alts in altsets:
+            minAlt = min(alts)
+            viableAlts.add(minAlt)
+            if len(viableAlts)>1 : # more than 1 viable alt
+                return ATN.INVALID_ALT_NUMBER
+        return min(viableAlts)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/atn/SemanticContext.py

@@ -0,0 +1,323 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+# A tree structure used to record the semantic context in which
+#  an ATN configuration is valid.  It's either a single predicate,
+#  a conjunction {@code p1&&p2}, or a sum of products {@code p1||p2}.
+#
+#  <p>I have scoped the {@link AND}, {@link OR}, and {@link Predicate} subclasses of
+#  {@link SemanticContext} within the scope of this outer class.</p>
+#
+from antlr4.Recognizer import Recognizer
+from antlr4.RuleContext import RuleContext
+from io import StringIO
+
+
+class SemanticContext(object):
+    #
+    # The default {@link SemanticContext}, which is semantically equivalent to
+    # a predicate of the form {@code {true}?}.
+    #
+    NONE = None
+
+    #
+    # For context independent predicates, we evaluate them without a local
+    # context (i.e., null context). That way, we can evaluate them without
+    # having to create proper rule-specific context during prediction (as
+    # opposed to the parser, which creates them naturally). In a practical
+    # sense, this avoids a cast exception from RuleContext to myruleContext.
+    #
+    # <p>For context dependent predicates, we must pass in a local context so that
+    # references such as $arg evaluate properly as _localctx.arg. We only
+    # capture context dependent predicates in the context in which we begin
+    # prediction, so we passed in the outer context here in case of context
+    # dependent predicate evaluation.</p>
+    #
+    def eval(self, parser:Recognizer , outerContext:RuleContext ):
+        pass
+
+    #
+    # Evaluate the precedence predicates for the context and reduce the result.
+    #
+    # @param parser The parser instance.
+    # @param outerContext The current parser context object.
+    # @return The simplified semantic context after precedence predicates are
+    # evaluated, which will be one of the following values.
+    # <ul>
+    # <li>{@link #NONE}: if the predicate simplifies to {@code true} after
+    # precedence predicates are evaluated.</li>
+    # <li>{@code null}: if the predicate simplifies to {@code false} after
+    # precedence predicates are evaluated.</li>
+    # <li>{@code this}: if the semantic context is not changed as a result of
+    # precedence predicate evaluation.</li>
+    # <li>A non-{@code null} {@link SemanticContext}: the new simplified
+    # semantic context after precedence predicates are evaluated.</li>
+    # </ul>
+    #
+    def evalPrecedence(self, parser:Recognizer, outerContext:RuleContext):
+        return self
+
+# need forward declaration
+AND = None
+
+def andContext(a:SemanticContext, b:SemanticContext):
+    if a is None or a is SemanticContext.NONE:
+        return b
+    if b is None or b is SemanticContext.NONE:
+        return a
+    result = AND(a, b)
+    if len(result.opnds) == 1:
+        return result.opnds[0]
+    else:
+        return result
+
+# need forward declaration
+OR = None
+
+def orContext(a:SemanticContext, b:SemanticContext):
+    if a is None:
+        return b
+    if b is None:
+        return a
+    if a is SemanticContext.NONE or b is SemanticContext.NONE:
+        return SemanticContext.NONE
+    result = OR(a, b)
+    if len(result.opnds) == 1:
+        return result.opnds[0]
+    else:
+        return result
+
+def filterPrecedencePredicates(collection:set):
+    return [context for context in collection if isinstance(context, PrecedencePredicate)]
+
+
+class Predicate(SemanticContext):
+    __slots__ = ('ruleIndex', 'predIndex', 'isCtxDependent')
+
+    def __init__(self, ruleIndex:int=-1, predIndex:int=-1, isCtxDependent:bool=False):
+        self.ruleIndex = ruleIndex
+        self.predIndex = predIndex
+        self.isCtxDependent = isCtxDependent # e.g., $i ref in pred
+
+    def eval(self, parser:Recognizer , outerContext:RuleContext ):
+        localctx = outerContext if self.isCtxDependent else None
+        return parser.sempred(localctx, self.ruleIndex, self.predIndex)
+
+    def __hash__(self):
+        return hash((self.ruleIndex, self.predIndex, self.isCtxDependent))
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, Predicate):
+            return False
+        return self.ruleIndex == other.ruleIndex and \
+               self.predIndex == other.predIndex and \
+               self.isCtxDependent == other.isCtxDependent
+
+    def __str__(self):
+        return "{" + str(self.ruleIndex) + ":" + str(self.predIndex) + "}?"
+
+
+class PrecedencePredicate(SemanticContext):
+
+    def __init__(self, precedence:int=0):
+        self.precedence = precedence
+
+    def eval(self, parser:Recognizer , outerContext:RuleContext ):
+        return parser.precpred(outerContext, self.precedence)
+
+    def evalPrecedence(self, parser:Recognizer, outerContext:RuleContext):
+        if parser.precpred(outerContext, self.precedence):
+            return SemanticContext.NONE
+        else:
+            return None
+
+    def __lt__(self, other):
+        return self.precedence < other.precedence
+
+    def __hash__(self):
+        return 31
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, PrecedencePredicate):
+            return False
+        else:
+            return self.precedence == other.precedence
+
+# A semantic context which is true whenever none of the contained contexts
+# is false.
+del AND
+class AND(SemanticContext):
+    __slots__ = 'opnds'
+
+    def __init__(self, a:SemanticContext, b:SemanticContext):
+        operands = set()
+        if isinstance( a, AND ):
+            operands.update(a.opnds)
+        else:
+            operands.add(a)
+        if isinstance( b, AND ):
+            operands.update(b.opnds)
+        else:
+            operands.add(b)
+
+        precedencePredicates = filterPrecedencePredicates(operands)
+        if len(precedencePredicates)>0:
+            # interested in the transition with the lowest precedence
+            reduced = min(precedencePredicates)
+            operands.add(reduced)
+
+        self.opnds = list(operands)
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, AND):
+            return False
+        else:
+            return self.opnds == other.opnds
+
+    def __hash__(self):
+        h = 0
+        for o in self.opnds:
+            h = hash((h, o))
+        return hash((h, "AND"))
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>
+    # The evaluation of predicates by this context is short-circuiting, but
+    # unordered.</p>
+    #
+    def eval(self, parser:Recognizer, outerContext:RuleContext):
+        return all(opnd.eval(parser, outerContext) for opnd in self.opnds)
+
+    def evalPrecedence(self, parser:Recognizer, outerContext:RuleContext):
+        differs = False
+        operands = []
+        for context in self.opnds:
+            evaluated = context.evalPrecedence(parser, outerContext)
+            differs |= evaluated is not context
+            if evaluated is None:
+                # The AND context is false if any element is false
+                return None
+            elif evaluated is not SemanticContext.NONE:
+                # Reduce the result by skipping true elements
+                operands.append(evaluated)
+
+        if not differs:
+            return self
+
+        if len(operands)==0:
+            # all elements were true, so the AND context is true
+            return SemanticContext.NONE
+
+        result = None
+        for o in operands:
+            result = o if result is None else andContext(result, o)
+
+        return result
+
+    def __str__(self):
+        with StringIO() as buf:
+            first = True
+            for o in self.opnds:
+                if not first:
+                    buf.write("&&")
+                buf.write(str(o))
+                first = False
+            return buf.getvalue()
+
+#
+# A semantic context which is true whenever at least one of the contained
+# contexts is true.
+del OR
+class OR (SemanticContext):
+    __slots__ = 'opnds'
+
+    def __init__(self, a:SemanticContext, b:SemanticContext):
+        operands = set()
+        if isinstance( a, OR ):
+            operands.update(a.opnds)
+        else:
+            operands.add(a)
+        if isinstance( b, OR ):
+            operands.update(b.opnds)
+        else:
+            operands.add(b)
+
+        precedencePredicates = filterPrecedencePredicates(operands)
+        if len(precedencePredicates)>0:
+            # interested in the transition with the highest precedence
+            s = sorted(precedencePredicates)
+            reduced = s[-1]
+            operands.add(reduced)
+
+        self.opnds = list(operands)
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        elif not isinstance(other, OR):
+            return False
+        else:
+            return self.opnds == other.opnds
+
+    def __hash__(self):
+        h = 0
+        for o in self.opnds:
+            h = hash((h, o))
+        return hash((h, "OR"))
+
+    # <p>
+    # The evaluation of predicates by this context is short-circuiting, but
+    # unordered.</p>
+    #
+    def eval(self, parser:Recognizer, outerContext:RuleContext):
+        return any(opnd.eval(parser, outerContext) for opnd in self.opnds)
+
+    def evalPrecedence(self, parser:Recognizer, outerContext:RuleContext):
+        differs = False
+        operands = []
+        for context in self.opnds:
+            evaluated = context.evalPrecedence(parser, outerContext)
+            differs |= evaluated is not context
+            if evaluated is SemanticContext.NONE:
+                # The OR context is true if any element is true
+                return SemanticContext.NONE
+            elif evaluated is not None:
+                # Reduce the result by skipping false elements
+                operands.append(evaluated)
+
+        if not differs:
+            return self
+
+        if len(operands)==0:
+            # all elements were false, so the OR context is false
+            return None
+
+        result = None
+        for o in operands:
+            result = o if result is None else orContext(result, o)
+
+        return result
+
+    def __str__(self):
+        with StringIO() as buf:
+            first = True
+            for o in self.opnds:
+                if not first:
+                    buf.write("||")
+                buf.write(str(o))
+                first = False
+            return buf.getvalue()
+
+
+SemanticContext.NONE = Predicate()

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/atn/Transition.py

@@ -0,0 +1,268 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+#  An ATN transition between any two ATN states.  Subclasses define
+#  atom, set, epsilon, action, predicate, rule transitions.
+#
+#  <p>This is a one way link.  It emanates from a state (usually via a list of
+#  transitions) and has a target state.</p>
+#
+#  <p>Since we never have to change the ATN transitions once we construct it,
+#  we can fix these transitions as specific classes. The DFA transitions
+#  on the other hand need to update the labels as it adds transitions to
+#  the states. We'll use the term Edge for the DFA to distinguish them from
+#  ATN transitions.</p>
+#
+from antlr4.IntervalSet import IntervalSet
+from antlr4.Token import Token
+
+# need forward declarations
+from antlr4.atn.SemanticContext import Predicate, PrecedencePredicate
+
+ATNState = None
+RuleStartState = None
+
+class Transition (object):
+    __slots__ = ('target','isEpsilon','label')
+
+    # constants for serialization
+    EPSILON			= 1
+    RANGE			= 2
+    RULE			= 3
+    PREDICATE		= 4 # e.g., {isType(input.LT(1))}?
+    ATOM			= 5
+    ACTION			= 6
+    SET				= 7 # ~(A|B) or ~atom, wildcard, which convert to next 2
+    NOT_SET			= 8
+    WILDCARD		= 9
+    PRECEDENCE		= 10
+
+    serializationNames = [
+            "INVALID",
+            "EPSILON",
+            "RANGE",
+            "RULE",
+            "PREDICATE",
+            "ATOM",
+            "ACTION",
+            "SET",
+            "NOT_SET",
+            "WILDCARD",
+            "PRECEDENCE"
+        ]
+
+    serializationTypes = dict()
+
+    def __init__(self, target:ATNState):
+        # The target of this transition.
+        if target is None:
+            raise Exception("target cannot be null.")
+        self.target = target
+        # Are we epsilon, action, sempred?
+        self.isEpsilon = False
+        self.label = None
+
+
+# TODO: make all transitions sets? no, should remove set edges
+class AtomTransition(Transition):
+    __slots__ = ('label_', 'serializationType')
+
+    def __init__(self, target:ATNState, label:int):
+        super().__init__(target)
+        self.label_ = label # The token type or character value; or, signifies special label.
+        self.label = self.makeLabel()
+        self.serializationType = self.ATOM
+
+    def makeLabel(self):
+        s = IntervalSet()
+        s.addOne(self.label_)
+        return s
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return self.label_ == symbol
+
+    def __str__(self):
+        return str(self.label_)
+
+class RuleTransition(Transition):
+    __slots__ = ('ruleIndex', 'precedence', 'followState', 'serializationType')
+
+    def __init__(self, ruleStart:RuleStartState, ruleIndex:int, precedence:int, followState:ATNState):
+        super().__init__(ruleStart)
+        self.ruleIndex = ruleIndex # ptr to the rule definition object for this rule ref
+        self.precedence = precedence
+        self.followState = followState # what node to begin computations following ref to rule
+        self.serializationType = self.RULE
+        self.isEpsilon = True
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return False
+
+
+class EpsilonTransition(Transition):
+    __slots__ = ('serializationType', 'outermostPrecedenceReturn')
+
+    def __init__(self, target, outermostPrecedenceReturn=-1):
+        super(EpsilonTransition, self).__init__(target)
+        self.serializationType = self.EPSILON
+        self.isEpsilon = True
+        self.outermostPrecedenceReturn = outermostPrecedenceReturn
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return False
+
+    def __str__(self):
+        return "epsilon"
+
+class RangeTransition(Transition):
+    __slots__ = ('serializationType', 'start', 'stop')
+
+    def __init__(self, target:ATNState, start:int, stop:int):
+        super().__init__(target)
+        self.serializationType = self.RANGE
+        self.start = start
+        self.stop = stop
+        self.label = self.makeLabel()
+
+    def makeLabel(self):
+        s = IntervalSet()
+        s.addRange(range(self.start, self.stop + 1))
+        return s
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return symbol >= self.start and symbol <= self.stop
+
+    def __str__(self):
+        return "'" + chr(self.start) + "'..'" + chr(self.stop) + "'"
+
+class AbstractPredicateTransition(Transition):
+
+    def __init__(self, target:ATNState):
+        super().__init__(target)
+
+
+class PredicateTransition(AbstractPredicateTransition):
+    __slots__ = ('serializationType', 'ruleIndex', 'predIndex', 'isCtxDependent')
+
+    def __init__(self, target:ATNState, ruleIndex:int, predIndex:int, isCtxDependent:bool):
+        super().__init__(target)
+        self.serializationType = self.PREDICATE
+        self.ruleIndex = ruleIndex
+        self.predIndex = predIndex
+        self.isCtxDependent = isCtxDependent # e.g., $i ref in pred
+        self.isEpsilon = True
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return False
+
+    def getPredicate(self):
+        return Predicate(self.ruleIndex, self.predIndex, self.isCtxDependent)
+
+    def __str__(self):
+        return "pred_" + str(self.ruleIndex) + ":" + str(self.predIndex)
+
+class ActionTransition(Transition):
+    __slots__ = ('serializationType', 'ruleIndex', 'actionIndex', 'isCtxDependent')
+
+    def __init__(self, target:ATNState, ruleIndex:int, actionIndex:int=-1, isCtxDependent:bool=False):
+        super().__init__(target)
+        self.serializationType = self.ACTION
+        self.ruleIndex = ruleIndex
+        self.actionIndex = actionIndex
+        self.isCtxDependent = isCtxDependent # e.g., $i ref in pred
+        self.isEpsilon = True
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return False
+
+    def __str__(self):
+        return "action_"+self.ruleIndex+":"+self.actionIndex
+
+# A transition containing a set of values.
+class SetTransition(Transition):
+    __slots__ = 'serializationType'
+
+    def __init__(self, target:ATNState, set:IntervalSet):
+        super().__init__(target)
+        self.serializationType = self.SET
+        if set is not None:
+            self.label = set
+        else:
+            self.label = IntervalSet()
+            self.label.addRange(range(Token.INVALID_TYPE, Token.INVALID_TYPE + 1))
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return symbol in self.label
+
+    def __str__(self):
+        return str(self.label)
+
+class NotSetTransition(SetTransition):
+
+    def __init__(self, target:ATNState, set:IntervalSet):
+        super().__init__(target, set)
+        self.serializationType = self.NOT_SET
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return symbol >= minVocabSymbol \
+            and symbol <= maxVocabSymbol \
+            and not super(type(self), self).matches(symbol, minVocabSymbol, maxVocabSymbol)
+
+    def __str__(self):
+        return '~' + super(type(self), self).__str__()
+
+
+class WildcardTransition(Transition):
+    __slots__ = 'serializationType'
+
+    def __init__(self, target:ATNState):
+        super().__init__(target)
+        self.serializationType = self.WILDCARD
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return symbol >= minVocabSymbol and symbol <= maxVocabSymbol
+
+    def __str__(self):
+        return "."
+
+
+class PrecedencePredicateTransition(AbstractPredicateTransition):
+    __slots__ = ('serializationType', 'precedence')
+
+    def __init__(self, target:ATNState, precedence:int):
+        super().__init__(target)
+        self.serializationType = self.PRECEDENCE
+        self.precedence = precedence
+        self.isEpsilon = True
+
+    def matches( self, symbol:int, minVocabSymbol:int,  maxVocabSymbol:int):
+        return False
+
+
+    def getPredicate(self):
+        return PrecedencePredicate(self.precedence)
+
+    def __str__(self):
+        return self.precedence + " >= _p"
+
+
+Transition.serializationTypes = {
+             EpsilonTransition: Transition.EPSILON,
+             RangeTransition: Transition.RANGE,
+             RuleTransition: Transition.RULE,
+             PredicateTransition: Transition.PREDICATE,
+             AtomTransition: Transition.ATOM,
+             ActionTransition: Transition.ACTION,
+             SetTransition: Transition.SET,
+             NotSetTransition: Transition.NOT_SET,
+             WildcardTransition: Transition.WILDCARD,
+             PrecedencePredicateTransition: Transition.PRECEDENCE
+         }
+
+del ATNState
+del RuleStartState
+
+from antlr4.atn.ATNState import *

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/atn/__init__.py

@@ -0,0 +1 @@
+__author__ = 'ericvergnaud'

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/dfa/DFA.py

@@ -0,0 +1,133 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+from antlr4.atn.ATNState import StarLoopEntryState
+
+from antlr4.atn.ATNConfigSet import ATNConfigSet
+from antlr4.atn.ATNState import DecisionState
+from antlr4.dfa.DFAState import DFAState
+from antlr4.error.Errors import IllegalStateException
+
+
+class DFA(object):
+    __slots__ = ('atnStartState', 'decision', '_states', 's0', 'precedenceDfa')
+
+    def __init__(self, atnStartState:DecisionState, decision:int=0):
+        # From which ATN state did we create this DFA?
+        self.atnStartState = atnStartState
+        self.decision = decision
+        # A set of all DFA states. Use {@link Map} so we can get old state back
+        #  ({@link Set} only allows you to see if it's there).
+        self._states = dict()
+        self.s0 = None
+        # {@code true} if this DFA is for a precedence decision; otherwise,
+        # {@code false}. This is the backing field for {@link #isPrecedenceDfa},
+        # {@link #setPrecedenceDfa}.
+        self.precedenceDfa = False
+
+        if isinstance(atnStartState, StarLoopEntryState):
+            if atnStartState.isPrecedenceDecision:
+                self.precedenceDfa = True
+                precedenceState = DFAState(configs=ATNConfigSet())
+                precedenceState.edges = []
+                precedenceState.isAcceptState = False
+                precedenceState.requiresFullContext = False
+                self.s0 = precedenceState
+
+
+    # Get the start state for a specific precedence value.
+    #
+    # @param precedence The current precedence.
+    # @return The start state corresponding to the specified precedence, or
+    # {@code null} if no start state exists for the specified precedence.
+    #
+    # @throws IllegalStateException if this is not a precedence DFA.
+    # @see #isPrecedenceDfa()
+
+    def getPrecedenceStartState(self, precedence:int):
+        if not self.precedenceDfa:
+            raise IllegalStateException("Only precedence DFAs may contain a precedence start state.")
+
+        # s0.edges is never null for a precedence DFA
+        if precedence < 0 or precedence >= len(self.s0.edges):
+            return None
+        return self.s0.edges[precedence]
+
+    # Set the start state for a specific precedence value.
+    #
+    # @param precedence The current precedence.
+    # @param startState The start state corresponding to the specified
+    # precedence.
+    #
+    # @throws IllegalStateException if this is not a precedence DFA.
+    # @see #isPrecedenceDfa()
+    #
+    def setPrecedenceStartState(self, precedence:int, startState:DFAState):
+        if not self.precedenceDfa:
+            raise IllegalStateException("Only precedence DFAs may contain a precedence start state.")
+
+        if precedence < 0:
+            return
+
+        # synchronization on s0 here is ok. when the DFA is turned into a
+        # precedence DFA, s0 will be initialized once and not updated again
+        # s0.edges is never null for a precedence DFA
+        if precedence >= len(self.s0.edges):
+            ext = [None] * (precedence + 1 - len(self.s0.edges))
+            self.s0.edges.extend(ext)
+        self.s0.edges[precedence] = startState
+    #
+    # Sets whether this is a precedence DFA. If the specified value differs
+    # from the current DFA configuration, the following actions are taken;
+    # otherwise no changes are made to the current DFA.
+    #
+    # <ul>
+    # <li>The {@link #states} map is cleared</li>
+    # <li>If {@code precedenceDfa} is {@code false}, the initial state
+    # {@link #s0} is set to {@code null}; otherwise, it is initialized to a new
+    # {@link DFAState} with an empty outgoing {@link DFAState#edges} array to
+    # store the start states for individual precedence values.</li>
+    # <li>The {@link #precedenceDfa} field is updated</li>
+    # </ul>
+    #
+    # @param precedenceDfa {@code true} if this is a precedence DFA; otherwise,
+    # {@code false}
+
+    def setPrecedenceDfa(self, precedenceDfa:bool):
+        if self.precedenceDfa != precedenceDfa:
+            self._states = dict()
+            if precedenceDfa:
+                precedenceState = DFAState(configs=ATNConfigSet())
+                precedenceState.edges = []
+                precedenceState.isAcceptState = False
+                precedenceState.requiresFullContext = False
+                self.s0 = precedenceState
+            else:
+                self.s0 = None
+            self.precedenceDfa = precedenceDfa
+
+    @property
+    def states(self):
+        return self._states
+
+    # Return a list of all states in this DFA, ordered by state number.
+    def sortedStates(self):
+        return sorted(self._states.keys(), key=lambda state: state.stateNumber)
+
+    def __str__(self):
+        return self.toString(None)
+
+    def toString(self, literalNames:list=None, symbolicNames:list=None):
+        if self.s0 is None:
+            return ""
+        from antlr4.dfa.DFASerializer import DFASerializer
+        serializer = DFASerializer(self,literalNames,symbolicNames)
+        return str(serializer)
+
+    def toLexerString(self):
+        if self.s0 is None:
+            return ""
+        from antlr4.dfa.DFASerializer import LexerDFASerializer
+        serializer = LexerDFASerializer(self)
+        return str(serializer)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/dfa/DFASerializer.py

@@ -0,0 +1,73 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#/
+
+# A DFA walker that knows how to dump them to serialized strings.#/
+from io import StringIO
+from antlr4 import DFA
+from antlr4.Utils import str_list
+from antlr4.dfa.DFAState import DFAState
+
+
+class DFASerializer(object):
+    __slots__ = ('dfa', 'literalNames', 'symbolicNames')
+
+    def __init__(self, dfa:DFA, literalNames:list=None, symbolicNames:list=None):
+        self.dfa = dfa
+        self.literalNames = literalNames
+        self.symbolicNames = symbolicNames
+
+    def __str__(self):
+        if self.dfa.s0 is None:
+            return None
+        with StringIO() as buf:
+            for s in self.dfa.sortedStates():
+                n = 0
+                if s.edges is not None:
+                    n = len(s.edges)
+                for i in range(0, n):
+                    t = s.edges[i]
+                    if t is not None and t.stateNumber != 0x7FFFFFFF:
+                        buf.write(self.getStateString(s))
+                        label = self.getEdgeLabel(i)
+                        buf.write("-")
+                        buf.write(label)
+                        buf.write("->")
+                        buf.write(self.getStateString(t))
+                        buf.write('\n')
+            output = buf.getvalue()
+            if len(output)==0:
+                return None
+            else:
+                return output
+
+    def getEdgeLabel(self, i:int):
+        if i==0:
+            return "EOF"
+        if self.literalNames is not None and i<=len(self.literalNames):
+            return self.literalNames[i-1]
+        elif self.symbolicNames is not None and i<=len(self.symbolicNames):
+            return self.symbolicNames[i-1]
+        else:
+            return str(i-1)
+
+    def getStateString(self, s:DFAState):
+        n = s.stateNumber
+        baseStateStr = ( ":" if s.isAcceptState else "") + "s" + str(n) + ( "^" if s.requiresFullContext else "")
+        if s.isAcceptState:
+            if s.predicates is not None:
+                return baseStateStr + "=>" + str_list(s.predicates)
+            else:
+                return baseStateStr + "=>" + str(s.prediction)
+        else:
+            return baseStateStr
+
+class LexerDFASerializer(DFASerializer):
+
+    def __init__(self, dfa:DFA):
+        super().__init__(dfa, None)
+
+    def getEdgeLabel(self, i:int):
+        return "'" + chr(i) + "'"

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/dfa/DFAState.py

@@ -0,0 +1,126 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#/
+
+# Map a predicate to a predicted alternative.#/
+from io import StringIO
+from antlr4.atn.ATNConfigSet import ATNConfigSet
+from antlr4.atn.SemanticContext import SemanticContext
+
+
+class PredPrediction(object):
+    __slots__ = ('alt', 'pred')
+
+    def __init__(self, pred:SemanticContext, alt:int):
+        self.alt = alt
+        self.pred = pred
+
+    def __str__(self):
+        return "(" + str(self.pred) + ", " + str(self.alt) +  ")"
+
+# A DFA state represents a set of possible ATN configurations.
+#  As Aho, Sethi, Ullman p. 117 says "The DFA uses its state
+#  to keep track of all possible states the ATN can be in after
+#  reading each input symbol.  That is to say, after reading
+#  input a1a2..an, the DFA is in a state that represents the
+#  subset T of the states of the ATN that are reachable from the
+#  ATN's start state along some path labeled a1a2..an."
+#  In conventional NFA→DFA conversion, therefore, the subset T
+#  would be a bitset representing the set of states the
+#  ATN could be in.  We need to track the alt predicted by each
+#  state as well, however.  More importantly, we need to maintain
+#  a stack of states, tracking the closure operations as they
+#  jump from rule to rule, emulating rule invocations (method calls).
+#  I have to add a stack to simulate the proper lookahead sequences for
+#  the underlying LL grammar from which the ATN was derived.
+#
+#  <p>I use a set of ATNConfig objects not simple states.  An ATNConfig
+#  is both a state (ala normal conversion) and a RuleContext describing
+#  the chain of rules (if any) followed to arrive at that state.</p>
+#
+#  <p>A DFA state may have multiple references to a particular state,
+#  but with different ATN contexts (with same or different alts)
+#  meaning that state was reached via a different set of rule invocations.</p>
+#/
+class DFAState(object):
+    __slots__ = (
+        'stateNumber', 'configs', 'edges', 'isAcceptState', 'prediction',
+        'lexerActionExecutor', 'requiresFullContext', 'predicates'
+    )
+
+    def __init__(self, stateNumber:int=-1, configs:ATNConfigSet=ATNConfigSet()):
+        self.stateNumber = stateNumber
+        self.configs = configs
+        # {@code edges[symbol]} points to target of symbol. Shift up by 1 so (-1)
+        #  {@link Token#EOF} maps to {@code edges[0]}.
+        self.edges = None
+        self.isAcceptState = False
+        # if accept state, what ttype do we match or alt do we predict?
+        #  This is set to {@link ATN#INVALID_ALT_NUMBER} when {@link #predicates}{@code !=null} or
+        #  {@link #requiresFullContext}.
+        self.prediction = 0
+        self.lexerActionExecutor = None
+        # Indicates that this state was created during SLL prediction that
+        # discovered a conflict between the configurations in the state. Future
+        # {@link ParserATNSimulator#execATN} invocations immediately jumped doing
+        # full context prediction if this field is true.
+        self.requiresFullContext = False
+        # During SLL parsing, this is a list of predicates associated with the
+        #  ATN configurations of the DFA state. When we have predicates,
+        #  {@link #requiresFullContext} is {@code false} since full context prediction evaluates predicates
+        #  on-the-fly. If this is not null, then {@link #prediction} is
+        #  {@link ATN#INVALID_ALT_NUMBER}.
+        #
+        #  <p>We only use these for non-{@link #requiresFullContext} but conflicting states. That
+        #  means we know from the context (it's $ or we don't dip into outer
+        #  context) that it's an ambiguity not a conflict.</p>
+        #
+        #  <p>This list is computed by {@link ParserATNSimulator#predicateDFAState}.</p>
+        self.predicates = None
+
+
+
+    # Get the set of all alts mentioned by all ATN configurations in this
+    #  DFA state.
+    def getAltSet(self):
+        if self.configs is not None:
+            return set(cfg.alt for cfg in self.configs) or None
+        return None
+
+    def __hash__(self):
+        return hash(self.configs)
+
+    # Two {@link DFAState} instances are equal if their ATN configuration sets
+    # are the same. This method is used to see if a state already exists.
+    #
+    # <p>Because the number of alternatives and number of ATN configurations are
+    # finite, there is a finite number of DFA states that can be processed.
+    # This is necessary to show that the algorithm terminates.</p>
+    #
+    # <p>Cannot test the DFA state numbers here because in
+    # {@link ParserATNSimulator#addDFAState} we need to know if any other state
+    # exists that has this exact set of ATN configurations. The
+    # {@link #stateNumber} is irrelevant.</p>
+    def __eq__(self, other):
+        # compare set of ATN configurations in this set with other
+        if self is other:
+            return True
+        elif not isinstance(other, DFAState):
+            return False
+        else:
+            return self.configs==other.configs
+
+    def __str__(self):
+        with StringIO() as buf:
+            buf.write(str(self.stateNumber))
+            buf.write(":")
+            buf.write(str(self.configs))
+            if self.isAcceptState:
+                buf.write("=>")
+                if self.predicates is not None:
+                    buf.write(str(self.predicates))
+                else:
+                    buf.write(str(self.prediction))
+            return buf.getvalue()

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/dfa/__init__.py

@@ -0,0 +1 @@
+__author__ = 'ericvergnaud'

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/error/DiagnosticErrorListener.py

@@ -0,0 +1,107 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+
+#
+# This implementation of {@link ANTLRErrorListener} can be used to identify
+# certain potential correctness and performance problems in grammars. "Reports"
+# are made by calling {@link Parser#notifyErrorListeners} with the appropriate
+# message.
+#
+# <ul>
+# <li><b>Ambiguities</b>: These are cases where more than one path through the
+# grammar can match the input.</li>
+# <li><b>Weak context sensitivity</b>: These are cases where full-context
+# prediction resolved an SLL conflict to a unique alternative which equaled the
+# minimum alternative of the SLL conflict.</li>
+# <li><b>Strong (forced) context sensitivity</b>: These are cases where the
+# full-context prediction resolved an SLL conflict to a unique alternative,
+# <em>and</em> the minimum alternative of the SLL conflict was found to not be
+# a truly viable alternative. Two-stage parsing cannot be used for inputs where
+# this situation occurs.</li>
+# </ul>
+
+from io import StringIO
+from antlr4 import Parser, DFA
+from antlr4.atn.ATNConfigSet import ATNConfigSet
+from antlr4.error.ErrorListener import ErrorListener
+
+class DiagnosticErrorListener(ErrorListener):
+
+    def __init__(self, exactOnly:bool=True):
+        # whether all ambiguities or only exact ambiguities are reported.
+        self.exactOnly = exactOnly
+
+    def reportAmbiguity(self, recognizer:Parser, dfa:DFA, startIndex:int,
+                       stopIndex:int, exact:bool, ambigAlts:set, configs:ATNConfigSet):
+        if self.exactOnly and not exact:
+            return
+
+        with StringIO() as buf:
+            buf.write("reportAmbiguity d=")
+            buf.write(self.getDecisionDescription(recognizer, dfa))
+            buf.write(": ambigAlts=")
+            buf.write(str(self.getConflictingAlts(ambigAlts, configs)))
+            buf.write(", input='")
+            buf.write(recognizer.getTokenStream().getText(startIndex, stopIndex))
+            buf.write("'")
+            recognizer.notifyErrorListeners(buf.getvalue())
+
+
+    def reportAttemptingFullContext(self, recognizer:Parser, dfa:DFA, startIndex:int,
+                       stopIndex:int, conflictingAlts:set, configs:ATNConfigSet):
+        with StringIO() as buf:
+            buf.write("reportAttemptingFullContext d=")
+            buf.write(self.getDecisionDescription(recognizer, dfa))
+            buf.write(", input='")
+            buf.write(recognizer.getTokenStream().getText(startIndex, stopIndex))
+            buf.write("'")
+            recognizer.notifyErrorListeners(buf.getvalue())
+
+    def reportContextSensitivity(self, recognizer:Parser, dfa:DFA, startIndex:int,
+                       stopIndex:int, prediction:int, configs:ATNConfigSet):
+        with StringIO() as buf:
+            buf.write("reportContextSensitivity d=")
+            buf.write(self.getDecisionDescription(recognizer, dfa))
+            buf.write(", input='")
+            buf.write(recognizer.getTokenStream().getText(startIndex, stopIndex))
+            buf.write("'")
+            recognizer.notifyErrorListeners(buf.getvalue())
+
+    def getDecisionDescription(self, recognizer:Parser, dfa:DFA):
+        decision = dfa.decision
+        ruleIndex = dfa.atnStartState.ruleIndex
+
+        ruleNames = recognizer.ruleNames
+        if ruleIndex < 0 or ruleIndex >= len(ruleNames):
+            return str(decision)
+
+        ruleName = ruleNames[ruleIndex]
+        if ruleName is None or len(ruleName)==0:
+            return str(decision)
+
+        return str(decision) + " (" + ruleName + ")"
+
+    #
+    # Computes the set of conflicting or ambiguous alternatives from a
+    # configuration set, if that information was not already provided by the
+    # parser.
+    #
+    # @param reportedAlts The set of conflicting or ambiguous alternatives, as
+    # reported by the parser.
+    # @param configs The conflicting or ambiguous configuration set.
+    # @return Returns {@code reportedAlts} if it is not {@code null}, otherwise
+    # returns the set of alternatives represented in {@code configs}.
+    #
+    def getConflictingAlts(self, reportedAlts:set, configs:ATNConfigSet):
+        if reportedAlts is not None:
+            return reportedAlts
+
+        result = set()
+        for config in configs:
+            result.add(config.alt)
+
+        return result

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/error/ErrorListener.py

@@ -0,0 +1,72 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+
+# Provides an empty default implementation of {@link ANTLRErrorListener}. The
+# default implementation of each method does nothing, but can be overridden as
+# necessary.
+
+
+import sys
+
+class ErrorListener(object):
+
+    def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
+        pass
+
+    def reportAmbiguity(self, recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs):
+        pass
+
+    def reportAttemptingFullContext(self, recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs):
+        pass
+
+    def reportContextSensitivity(self, recognizer, dfa, startIndex, stopIndex, prediction, configs):
+        pass
+
+class ConsoleErrorListener(ErrorListener):
+    #
+    # Provides a default instance of {@link ConsoleErrorListener}.
+    #
+    INSTANCE = None
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>
+    # This implementation prints messages to {@link System#err} containing the
+    # values of {@code line}, {@code charPositionInLine}, and {@code msg} using
+    # the following format.</p>
+    #
+    # <pre>
+    # line <em>line</em>:<em>charPositionInLine</em> <em>msg</em>
+    # </pre>
+    #
+    def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
+        print("line " + str(line) + ":" + str(column) + " " + msg, file=sys.stderr)
+
+ConsoleErrorListener.INSTANCE = ConsoleErrorListener()
+
+class ProxyErrorListener(ErrorListener):
+
+    def __init__(self, delegates):
+        super().__init__()
+        if delegates is None:
+            raise ReferenceError("delegates")
+        self.delegates = delegates
+
+    def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
+        for delegate in self.delegates:
+            delegate.syntaxError(recognizer, offendingSymbol, line, column, msg, e)
+
+    def reportAmbiguity(self, recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs):
+        for delegate in self.delegates:
+            delegate.reportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs)
+
+    def reportAttemptingFullContext(self, recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs):
+        for delegate in self.delegates:
+            delegate.reportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs)
+
+    def reportContextSensitivity(self, recognizer, dfa, startIndex, stopIndex, prediction, configs):
+        for delegate in self.delegates:
+            delegate.reportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/error/ErrorStrategy.py

@@ -0,0 +1,709 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+import sys
+from antlr4.IntervalSet import IntervalSet
+
+from antlr4.Token import Token
+from antlr4.atn.ATNState import ATNState
+from antlr4.error.Errors import RecognitionException, NoViableAltException, InputMismatchException, \
+    FailedPredicateException, ParseCancellationException
+
+# need forward declaration
+Parser = None
+
+class ErrorStrategy(object):
+
+    def reset(self, recognizer:Parser):
+        pass
+
+    def recoverInline(self, recognizer:Parser):
+        pass
+
+    def recover(self, recognizer:Parser, e:RecognitionException):
+        pass
+
+    def sync(self, recognizer:Parser):
+        pass
+
+    def inErrorRecoveryMode(self, recognizer:Parser):
+        pass
+
+    def reportError(self, recognizer:Parser, e:RecognitionException):
+        pass
+
+
+# This is the default implementation of {@link ANTLRErrorStrategy} used for
+# error reporting and recovery in ANTLR parsers.
+#
+class DefaultErrorStrategy(ErrorStrategy):
+
+    def __init__(self):
+        super().__init__()
+        # Indicates whether the error strategy is currently "recovering from an
+        # error". This is used to suppress reporting multiple error messages while
+        # attempting to recover from a detected syntax error.
+        #
+        # @see #inErrorRecoveryMode
+        #
+        self.errorRecoveryMode = False
+
+        # The index into the input stream where the last error occurred.
+        # 	This is used to prevent infinite loops where an error is found
+        #  but no token is consumed during recovery...another error is found,
+        #  ad nauseum.  This is a failsafe mechanism to guarantee that at least
+        #  one token/tree node is consumed for two errors.
+        #
+        self.lastErrorIndex = -1
+        self.lastErrorStates = None
+        self.nextTokensContext = None
+        self.nextTokenState = 0
+
+    # <p>The default implementation simply calls {@link #endErrorCondition} to
+    # ensure that the handler is not in error recovery mode.</p>
+    def reset(self, recognizer:Parser):
+        self.endErrorCondition(recognizer)
+
+    #
+    # This method is called to enter error recovery mode when a recognition
+    # exception is reported.
+    #
+    # @param recognizer the parser instance
+    #
+    def beginErrorCondition(self, recognizer:Parser):
+        self.errorRecoveryMode = True
+
+    def inErrorRecoveryMode(self, recognizer:Parser):
+        return self.errorRecoveryMode
+
+    #
+    # This method is called to leave error recovery mode after recovering from
+    # a recognition exception.
+    #
+    # @param recognizer
+    #
+    def endErrorCondition(self, recognizer:Parser):
+        self.errorRecoveryMode = False
+        self.lastErrorStates = None
+        self.lastErrorIndex = -1
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>The default implementation simply calls {@link #endErrorCondition}.</p>
+    #
+    def reportMatch(self, recognizer:Parser):
+        self.endErrorCondition(recognizer)
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>The default implementation returns immediately if the handler is already
+    # in error recovery mode. Otherwise, it calls {@link #beginErrorCondition}
+    # and dispatches the reporting task based on the runtime type of {@code e}
+    # according to the following table.</p>
+    #
+    # <ul>
+    # <li>{@link NoViableAltException}: Dispatches the call to
+    # {@link #reportNoViableAlternative}</li>
+    # <li>{@link InputMismatchException}: Dispatches the call to
+    # {@link #reportInputMismatch}</li>
+    # <li>{@link FailedPredicateException}: Dispatches the call to
+    # {@link #reportFailedPredicate}</li>
+    # <li>All other types: calls {@link Parser#notifyErrorListeners} to report
+    # the exception</li>
+    # </ul>
+    #
+    def reportError(self, recognizer:Parser, e:RecognitionException):
+       # if we've already reported an error and have not matched a token
+       # yet successfully, don't report any errors.
+        if self.inErrorRecoveryMode(recognizer):
+            return # don't report spurious errors
+        self.beginErrorCondition(recognizer)
+        if isinstance( e, NoViableAltException ):
+            self.reportNoViableAlternative(recognizer, e)
+        elif isinstance( e, InputMismatchException ):
+            self.reportInputMismatch(recognizer, e)
+        elif isinstance( e, FailedPredicateException ):
+            self.reportFailedPredicate(recognizer, e)
+        else:
+            print("unknown recognition error type: " + type(e).__name__)
+            recognizer.notifyErrorListeners(e.message, e.offendingToken, e)
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>The default implementation resynchronizes the parser by consuming tokens
+    # until we find one in the resynchronization set--loosely the set of tokens
+    # that can follow the current rule.</p>
+    #
+    def recover(self, recognizer:Parser, e:RecognitionException):
+        if self.lastErrorIndex==recognizer.getInputStream().index \
+            and self.lastErrorStates is not None \
+            and recognizer.state in self.lastErrorStates:
+           # uh oh, another error at same token index and previously-visited
+           # state in ATN; must be a case where LT(1) is in the recovery
+           # token set so nothing got consumed. Consume a single token
+           # at least to prevent an infinite loop; this is a failsafe.
+            recognizer.consume()
+
+        self.lastErrorIndex = recognizer._input.index
+        if self.lastErrorStates is None:
+            self.lastErrorStates = []
+        self.lastErrorStates.append(recognizer.state)
+        followSet = self.getErrorRecoverySet(recognizer)
+        self.consumeUntil(recognizer, followSet)
+
+    # The default implementation of {@link ANTLRErrorStrategy#sync} makes sure
+    # that the current lookahead symbol is consistent with what were expecting
+    # at this point in the ATN. You can call this anytime but ANTLR only
+    # generates code to check before subrules/loops and each iteration.
+    #
+    # <p>Implements Jim Idle's magic sync mechanism in closures and optional
+    # subrules. E.g.,</p>
+    #
+    # <pre>
+    # a : sync ( stuff sync )* ;
+    # sync : {consume to what can follow sync} ;
+    # </pre>
+    #
+    # At the start of a sub rule upon error, {@link #sync} performs single
+    # token deletion, if possible. If it can't do that, it bails on the current
+    # rule and uses the default error recovery, which consumes until the
+    # resynchronization set of the current rule.
+    #
+    # <p>If the sub rule is optional ({@code (...)?}, {@code (...)*}, or block
+    # with an empty alternative), then the expected set includes what follows
+    # the subrule.</p>
+    #
+    # <p>During loop iteration, it consumes until it sees a token that can start a
+    # sub rule or what follows loop. Yes, that is pretty aggressive. We opt to
+    # stay in the loop as long as possible.</p>
+    #
+    # <p><strong>ORIGINS</strong></p>
+    #
+    # <p>Previous versions of ANTLR did a poor job of their recovery within loops.
+    # A single mismatch token or missing token would force the parser to bail
+    # out of the entire rules surrounding the loop. So, for rule</p>
+    #
+    # <pre>
+    # classDef : 'class' ID '{' member* '}'
+    # </pre>
+    #
+    # input with an extra token between members would force the parser to
+    # consume until it found the next class definition rather than the next
+    # member definition of the current class.
+    #
+    # <p>This functionality cost a little bit of effort because the parser has to
+    # compare token set at the start of the loop and at each iteration. If for
+    # some reason speed is suffering for you, you can turn off this
+    # functionality by simply overriding this method as a blank { }.</p>
+    #
+    def sync(self, recognizer:Parser):
+        # If already recovering, don't try to sync
+        if self.inErrorRecoveryMode(recognizer):
+            return
+
+        s = recognizer._interp.atn.states[recognizer.state]
+        la = recognizer.getTokenStream().LA(1)
+        # try cheaper subset first; might get lucky. seems to shave a wee bit off
+        nextTokens = recognizer.atn.nextTokens(s)
+        if la in nextTokens:
+            self.nextTokensContext = None
+            self.nextTokenState = ATNState.INVALID_STATE_NUMBER
+            return
+        elif Token.EPSILON in nextTokens:
+            if self.nextTokensContext is None:
+                # It's possible the next token won't match information tracked
+                # by sync is restricted for performance.
+                self.nextTokensContext = recognizer._ctx
+                self.nextTokensState = recognizer._stateNumber
+            return
+
+        if s.stateType in [ATNState.BLOCK_START, ATNState.STAR_BLOCK_START,
+                                ATNState.PLUS_BLOCK_START, ATNState.STAR_LOOP_ENTRY]:
+           # report error and recover if possible
+            if self.singleTokenDeletion(recognizer)is not None:
+                return
+            else:
+                raise InputMismatchException(recognizer)
+
+        elif s.stateType in [ATNState.PLUS_LOOP_BACK, ATNState.STAR_LOOP_BACK]:
+            self.reportUnwantedToken(recognizer)
+            expecting = recognizer.getExpectedTokens()
+            whatFollowsLoopIterationOrRule = expecting.addSet(self.getErrorRecoverySet(recognizer))
+            self.consumeUntil(recognizer, whatFollowsLoopIterationOrRule)
+
+        else:
+           # do nothing if we can't identify the exact kind of ATN state
+           pass
+
+    # This is called by {@link #reportError} when the exception is a
+    # {@link NoViableAltException}.
+    #
+    # @see #reportError
+    #
+    # @param recognizer the parser instance
+    # @param e the recognition exception
+    #
+    def reportNoViableAlternative(self, recognizer:Parser, e:NoViableAltException):
+        tokens = recognizer.getTokenStream()
+        if tokens is not None:
+            if e.startToken.type==Token.EOF:
+                input = "<EOF>"
+            else:
+                input = tokens.getText(e.startToken, e.offendingToken)
+        else:
+            input = "<unknown input>"
+        msg = "no viable alternative at input " + self.escapeWSAndQuote(input)
+        recognizer.notifyErrorListeners(msg, e.offendingToken, e)
+
+    #
+    # This is called by {@link #reportError} when the exception is an
+    # {@link InputMismatchException}.
+    #
+    # @see #reportError
+    #
+    # @param recognizer the parser instance
+    # @param e the recognition exception
+    #
+    def reportInputMismatch(self, recognizer:Parser, e:InputMismatchException):
+        msg = "mismatched input " + self.getTokenErrorDisplay(e.offendingToken) \
+              + " expecting " + e.getExpectedTokens().toString(recognizer.literalNames, recognizer.symbolicNames)
+        recognizer.notifyErrorListeners(msg, e.offendingToken, e)
+
+    #
+    # This is called by {@link #reportError} when the exception is a
+    # {@link FailedPredicateException}.
+    #
+    # @see #reportError
+    #
+    # @param recognizer the parser instance
+    # @param e the recognition exception
+    #
+    def reportFailedPredicate(self, recognizer, e):
+        ruleName = recognizer.ruleNames[recognizer._ctx.getRuleIndex()]
+        msg = "rule " + ruleName + " " + e.message
+        recognizer.notifyErrorListeners(msg, e.offendingToken, e)
+
+    # This method is called to report a syntax error which requires the removal
+    # of a token from the input stream. At the time this method is called, the
+    # erroneous symbol is current {@code LT(1)} symbol and has not yet been
+    # removed from the input stream. When this method returns,
+    # {@code recognizer} is in error recovery mode.
+    #
+    # <p>This method is called when {@link #singleTokenDeletion} identifies
+    # single-token deletion as a viable recovery strategy for a mismatched
+    # input error.</p>
+    #
+    # <p>The default implementation simply returns if the handler is already in
+    # error recovery mode. Otherwise, it calls {@link #beginErrorCondition} to
+    # enter error recovery mode, followed by calling
+    # {@link Parser#notifyErrorListeners}.</p>
+    #
+    # @param recognizer the parser instance
+    #
+    def reportUnwantedToken(self, recognizer:Parser):
+        if self.inErrorRecoveryMode(recognizer):
+            return
+
+        self.beginErrorCondition(recognizer)
+        t = recognizer.getCurrentToken()
+        tokenName = self.getTokenErrorDisplay(t)
+        expecting = self.getExpectedTokens(recognizer)
+        msg = "extraneous input " + tokenName + " expecting " \
+            + expecting.toString(recognizer.literalNames, recognizer.symbolicNames)
+        recognizer.notifyErrorListeners(msg, t, None)
+
+    # This method is called to report a syntax error which requires the
+    # insertion of a missing token into the input stream. At the time this
+    # method is called, the missing token has not yet been inserted. When this
+    # method returns, {@code recognizer} is in error recovery mode.
+    #
+    # <p>This method is called when {@link #singleTokenInsertion} identifies
+    # single-token insertion as a viable recovery strategy for a mismatched
+    # input error.</p>
+    #
+    # <p>The default implementation simply returns if the handler is already in
+    # error recovery mode. Otherwise, it calls {@link #beginErrorCondition} to
+    # enter error recovery mode, followed by calling
+    # {@link Parser#notifyErrorListeners}.</p>
+    #
+    # @param recognizer the parser instance
+    #
+    def reportMissingToken(self, recognizer:Parser):
+        if self.inErrorRecoveryMode(recognizer):
+            return
+        self.beginErrorCondition(recognizer)
+        t = recognizer.getCurrentToken()
+        expecting = self.getExpectedTokens(recognizer)
+        msg = "missing " + expecting.toString(recognizer.literalNames, recognizer.symbolicNames) \
+              + " at " + self.getTokenErrorDisplay(t)
+        recognizer.notifyErrorListeners(msg, t, None)
+
+    # <p>The default implementation attempts to recover from the mismatched input
+    # by using single token insertion and deletion as described below. If the
+    # recovery attempt fails, this method throws an
+    # {@link InputMismatchException}.</p>
+    #
+    # <p><strong>EXTRA TOKEN</strong> (single token deletion)</p>
+    #
+    # <p>{@code LA(1)} is not what we are looking for. If {@code LA(2)} has the
+    # right token, however, then assume {@code LA(1)} is some extra spurious
+    # token and delete it. Then consume and return the next token (which was
+    # the {@code LA(2)} token) as the successful result of the match operation.</p>
+    #
+    # <p>This recovery strategy is implemented by {@link #singleTokenDeletion}.</p>
+    #
+    # <p><strong>MISSING TOKEN</strong> (single token insertion)</p>
+    #
+    # <p>If current token (at {@code LA(1)}) is consistent with what could come
+    # after the expected {@code LA(1)} token, then assume the token is missing
+    # and use the parser's {@link TokenFactory} to create it on the fly. The
+    # "insertion" is performed by returning the created token as the successful
+    # result of the match operation.</p>
+    #
+    # <p>This recovery strategy is implemented by {@link #singleTokenInsertion}.</p>
+    #
+    # <p><strong>EXAMPLE</strong></p>
+    #
+    # <p>For example, Input {@code i=(3;} is clearly missing the {@code ')'}. When
+    # the parser returns from the nested call to {@code expr}, it will have
+    # call chain:</p>
+    #
+    # <pre>
+    # stat &rarr; expr &rarr; atom
+    # </pre>
+    #
+    # and it will be trying to match the {@code ')'} at this point in the
+    # derivation:
+    #
+    # <pre>
+    # =&gt; ID '=' '(' INT ')' ('+' atom)* ';'
+    #                    ^
+    # </pre>
+    #
+    # The attempt to match {@code ')'} will fail when it sees {@code ';'} and
+    # call {@link #recoverInline}. To recover, it sees that {@code LA(1)==';'}
+    # is in the set of tokens that can follow the {@code ')'} token reference
+    # in rule {@code atom}. It can assume that you forgot the {@code ')'}.
+    #
+    def recoverInline(self, recognizer:Parser):
+        # SINGLE TOKEN DELETION
+        matchedSymbol = self.singleTokenDeletion(recognizer)
+        if matchedSymbol is not None:
+            # we have deleted the extra token.
+            # now, move past ttype token as if all were ok
+            recognizer.consume()
+            return matchedSymbol
+
+        # SINGLE TOKEN INSERTION
+        if self.singleTokenInsertion(recognizer):
+            return self.getMissingSymbol(recognizer)
+
+        # even that didn't work; must throw the exception
+        raise InputMismatchException(recognizer)
+
+    #
+    # This method implements the single-token insertion inline error recovery
+    # strategy. It is called by {@link #recoverInline} if the single-token
+    # deletion strategy fails to recover from the mismatched input. If this
+    # method returns {@code true}, {@code recognizer} will be in error recovery
+    # mode.
+    #
+    # <p>This method determines whether or not single-token insertion is viable by
+    # checking if the {@code LA(1)} input symbol could be successfully matched
+    # if it were instead the {@code LA(2)} symbol. If this method returns
+    # {@code true}, the caller is responsible for creating and inserting a
+    # token with the correct type to produce this behavior.</p>
+    #
+    # @param recognizer the parser instance
+    # @return {@code true} if single-token insertion is a viable recovery
+    # strategy for the current mismatched input, otherwise {@code false}
+    #
+    def singleTokenInsertion(self, recognizer:Parser):
+        currentSymbolType = recognizer.getTokenStream().LA(1)
+        # if current token is consistent with what could come after current
+        # ATN state, then we know we're missing a token; error recovery
+        # is free to conjure up and insert the missing token
+        atn = recognizer._interp.atn
+        currentState = atn.states[recognizer.state]
+        next = currentState.transitions[0].target
+        expectingAtLL2 = atn.nextTokens(next, recognizer._ctx)
+        if currentSymbolType in expectingAtLL2:
+            self.reportMissingToken(recognizer)
+            return True
+        else:
+            return False
+
+    # This method implements the single-token deletion inline error recovery
+    # strategy. It is called by {@link #recoverInline} to attempt to recover
+    # from mismatched input. If this method returns null, the parser and error
+    # handler state will not have changed. If this method returns non-null,
+    # {@code recognizer} will <em>not</em> be in error recovery mode since the
+    # returned token was a successful match.
+    #
+    # <p>If the single-token deletion is successful, this method calls
+    # {@link #reportUnwantedToken} to report the error, followed by
+    # {@link Parser#consume} to actually "delete" the extraneous token. Then,
+    # before returning {@link #reportMatch} is called to signal a successful
+    # match.</p>
+    #
+    # @param recognizer the parser instance
+    # @return the successfully matched {@link Token} instance if single-token
+    # deletion successfully recovers from the mismatched input, otherwise
+    # {@code null}
+    #
+    def singleTokenDeletion(self, recognizer:Parser):
+        nextTokenType = recognizer.getTokenStream().LA(2)
+        expecting = self.getExpectedTokens(recognizer)
+        if nextTokenType in expecting:
+            self.reportUnwantedToken(recognizer)
+            # print("recoverFromMismatchedToken deleting " \
+            #     + str(recognizer.getTokenStream().LT(1)) \
+            #     + " since " + str(recognizer.getTokenStream().LT(2)) \
+            #     + " is what we want", file=sys.stderr)
+            recognizer.consume() # simply delete extra token
+            # we want to return the token we're actually matching
+            matchedSymbol = recognizer.getCurrentToken()
+            self.reportMatch(recognizer) # we know current token is correct
+            return matchedSymbol
+        else:
+            return None
+
+    # Conjure up a missing token during error recovery.
+    #
+    #  The recognizer attempts to recover from single missing
+    #  symbols. But, actions might refer to that missing symbol.
+    #  For example, x=ID {f($x);}. The action clearly assumes
+    #  that there has been an identifier matched previously and that
+    #  $x points at that token. If that token is missing, but
+    #  the next token in the stream is what we want we assume that
+    #  this token is missing and we keep going. Because we
+    #  have to return some token to replace the missing token,
+    #  we have to conjure one up. This method gives the user control
+    #  over the tokens returned for missing tokens. Mostly,
+    #  you will want to create something special for identifier
+    #  tokens. For literals such as '{' and ',', the default
+    #  action in the parser or tree parser works. It simply creates
+    #  a CommonToken of the appropriate type. The text will be the token.
+    #  If you change what tokens must be created by the lexer,
+    #  override this method to create the appropriate tokens.
+    #
+    def getMissingSymbol(self, recognizer:Parser):
+        currentSymbol = recognizer.getCurrentToken()
+        expecting = self.getExpectedTokens(recognizer)
+        expectedTokenType = expecting[0] # get any element
+        if expectedTokenType==Token.EOF:
+            tokenText = "<missing EOF>"
+        else:
+            name = None
+            if expectedTokenType < len(recognizer.literalNames):
+                name = recognizer.literalNames[expectedTokenType]
+            if name is None and expectedTokenType < len(recognizer.symbolicNames):
+                name = recognizer.symbolicNames[expectedTokenType]
+            tokenText = "<missing " + str(name) + ">"
+        current = currentSymbol
+        lookback = recognizer.getTokenStream().LT(-1)
+        if current.type==Token.EOF and lookback is not None:
+            current = lookback
+        return recognizer.getTokenFactory().create(current.source,
+            expectedTokenType, tokenText, Token.DEFAULT_CHANNEL,
+            -1, -1, current.line, current.column)
+
+    def getExpectedTokens(self, recognizer:Parser):
+        return recognizer.getExpectedTokens()
+
+    # How should a token be displayed in an error message? The default
+    #  is to display just the text, but during development you might
+    #  want to have a lot of information spit out.  Override in that case
+    #  to use t.toString() (which, for CommonToken, dumps everything about
+    #  the token). This is better than forcing you to override a method in
+    #  your token objects because you don't have to go modify your lexer
+    #  so that it creates a new Java type.
+    #
+    def getTokenErrorDisplay(self, t:Token):
+        if t is None:
+            return "<no token>"
+        s = t.text
+        if s is None:
+            if t.type==Token.EOF:
+                s = "<EOF>"
+            else:
+                s = "<" + str(t.type) + ">"
+        return self.escapeWSAndQuote(s)
+
+    def escapeWSAndQuote(self, s:str):
+        s = s.replace("\n","\\n")
+        s = s.replace("\r","\\r")
+        s = s.replace("\t","\\t")
+        return "'" + s + "'"
+
+    #  Compute the error recovery set for the current rule.  During
+    #  rule invocation, the parser pushes the set of tokens that can
+    #  follow that rule reference on the stack; this amounts to
+    #  computing FIRST of what follows the rule reference in the
+    #  enclosing rule. See LinearApproximator.FIRST().
+    #  This local follow set only includes tokens
+    #  from within the rule; i.e., the FIRST computation done by
+    #  ANTLR stops at the end of a rule.
+    #
+    #  EXAMPLE
+    #
+    #  When you find a "no viable alt exception", the input is not
+    #  consistent with any of the alternatives for rule r.  The best
+    #  thing to do is to consume tokens until you see something that
+    #  can legally follow a call to r#or* any rule that called r.
+    #  You don't want the exact set of viable next tokens because the
+    #  input might just be missing a token--you might consume the
+    #  rest of the input looking for one of the missing tokens.
+    #
+    #  Consider grammar:
+    #
+    #  a : '[' b ']'
+    #    | '(' b ')'
+    #    ;
+    #  b : c '^' INT ;
+    #  c : ID
+    #    | INT
+    #    ;
+    #
+    #  At each rule invocation, the set of tokens that could follow
+    #  that rule is pushed on a stack.  Here are the various
+    #  context-sensitive follow sets:
+    #
+    #  FOLLOW(b1_in_a) = FIRST(']') = ']'
+    #  FOLLOW(b2_in_a) = FIRST(')') = ')'
+    #  FOLLOW(c_in_b) = FIRST('^') = '^'
+    #
+    #  Upon erroneous input "[]", the call chain is
+    #
+    #  a -> b -> c
+    #
+    #  and, hence, the follow context stack is:
+    #
+    #  depth     follow set       start of rule execution
+    #    0         <EOF>                    a (from main())
+    #    1          ']'                     b
+    #    2          '^'                     c
+    #
+    #  Notice that ')' is not included, because b would have to have
+    #  been called from a different context in rule a for ')' to be
+    #  included.
+    #
+    #  For error recovery, we cannot consider FOLLOW(c)
+    #  (context-sensitive or otherwise).  We need the combined set of
+    #  all context-sensitive FOLLOW sets--the set of all tokens that
+    #  could follow any reference in the call chain.  We need to
+    #  resync to one of those tokens.  Note that FOLLOW(c)='^' and if
+    #  we resync'd to that token, we'd consume until EOF.  We need to
+    #  sync to context-sensitive FOLLOWs for a, b, and c: {']','^'}.
+    #  In this case, for input "[]", LA(1) is ']' and in the set, so we would
+    #  not consume anything. After printing an error, rule c would
+    #  return normally.  Rule b would not find the required '^' though.
+    #  At this point, it gets a mismatched token error and throws an
+    #  exception (since LA(1) is not in the viable following token
+    #  set).  The rule exception handler tries to recover, but finds
+    #  the same recovery set and doesn't consume anything.  Rule b
+    #  exits normally returning to rule a.  Now it finds the ']' (and
+    #  with the successful match exits errorRecovery mode).
+    #
+    #  So, you can see that the parser walks up the call chain looking
+    #  for the token that was a member of the recovery set.
+    #
+    #  Errors are not generated in errorRecovery mode.
+    #
+    #  ANTLR's error recovery mechanism is based upon original ideas:
+    #
+    #  "Algorithms + Data Structures = Programs" by Niklaus Wirth
+    #
+    #  and
+    #
+    #  "A note on error recovery in recursive descent parsers":
+    #  http:#portal.acm.org/citation.cfm?id=947902.947905
+    #
+    #  Later, Josef Grosch had some good ideas:
+    #
+    #  "Efficient and Comfortable Error Recovery in Recursive Descent
+    #  Parsers":
+    #  ftp:#www.cocolab.com/products/cocktail/doca4.ps/ell.ps.zip
+    #
+    #  Like Grosch I implement context-sensitive FOLLOW sets that are combined
+    #  at run-time upon error to avoid overhead during parsing.
+    #
+    def getErrorRecoverySet(self, recognizer:Parser):
+        atn = recognizer._interp.atn
+        ctx = recognizer._ctx
+        recoverSet = IntervalSet()
+        while ctx is not None and ctx.invokingState>=0:
+            # compute what follows who invoked us
+            invokingState = atn.states[ctx.invokingState]
+            rt = invokingState.transitions[0]
+            follow = atn.nextTokens(rt.followState)
+            recoverSet.addSet(follow)
+            ctx = ctx.parentCtx
+        recoverSet.removeOne(Token.EPSILON)
+        return recoverSet
+
+    # Consume tokens until one matches the given token set.#
+    def consumeUntil(self, recognizer:Parser, set_:set):
+        ttype = recognizer.getTokenStream().LA(1)
+        while ttype != Token.EOF and not ttype in set_:
+            recognizer.consume()
+            ttype = recognizer.getTokenStream().LA(1)
+
+
+#
+# This implementation of {@link ANTLRErrorStrategy} responds to syntax errors
+# by immediately canceling the parse operation with a
+# {@link ParseCancellationException}. The implementation ensures that the
+# {@link ParserRuleContext#exception} field is set for all parse tree nodes
+# that were not completed prior to encountering the error.
+#
+# <p>
+# This error strategy is useful in the following scenarios.</p>
+#
+# <ul>
+# <li><strong>Two-stage parsing:</strong> This error strategy allows the first
+# stage of two-stage parsing to immediately terminate if an error is
+# encountered, and immediately fall back to the second stage. In addition to
+# avoiding wasted work by attempting to recover from errors here, the empty
+# implementation of {@link BailErrorStrategy#sync} improves the performance of
+# the first stage.</li>
+# <li><strong>Silent validation:</strong> When syntax errors are not being
+# reported or logged, and the parse result is simply ignored if errors occur,
+# the {@link BailErrorStrategy} avoids wasting work on recovering from errors
+# when the result will be ignored either way.</li>
+# </ul>
+#
+# <p>
+# {@code myparser.setErrorHandler(new BailErrorStrategy());}</p>
+#
+# @see Parser#setErrorHandler(ANTLRErrorStrategy)
+#
+class BailErrorStrategy(DefaultErrorStrategy):
+    # Instead of recovering from exception {@code e}, re-throw it wrapped
+    #  in a {@link ParseCancellationException} so it is not caught by the
+    #  rule function catches.  Use {@link Exception#getCause()} to get the
+    #  original {@link RecognitionException}.
+    #
+    def recover(self, recognizer:Parser, e:RecognitionException):
+        context = recognizer._ctx
+        while context is not None:
+            context.exception = e
+            context = context.parentCtx
+        raise ParseCancellationException(e)
+
+    # Make sure we don't attempt to recover inline; if the parser
+    #  successfully recovers, it won't throw an exception.
+    #
+    def recoverInline(self, recognizer:Parser):
+        self.recover(recognizer, InputMismatchException(recognizer))
+
+    # Make sure we don't attempt to recover from problems in subrules.#
+    def sync(self, recognizer:Parser):
+        pass
+
+del Parser

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/error/Errors.py

@@ -0,0 +1,172 @@
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+# need forward declaration
+Token = None
+Lexer = None
+Parser = None
+TokenStream = None
+ATNConfigSet = None
+ParserRulecontext = None
+PredicateTransition = None
+BufferedTokenStream = None
+
+class UnsupportedOperationException(Exception):
+
+    def __init__(self, msg:str):
+        super().__init__(msg)
+
+class IllegalStateException(Exception):
+
+    def __init__(self, msg:str):
+        super().__init__(msg)
+
+class CancellationException(IllegalStateException):
+
+    def __init__(self, msg:str):
+        super().__init__(msg)
+
+# The root of the ANTLR exception hierarchy. In general, ANTLR tracks just
+#  3 kinds of errors: prediction errors, failed predicate errors, and
+#  mismatched input errors. In each case, the parser knows where it is
+#  in the input, where it is in the ATN, the rule invocation stack,
+#  and what kind of problem occurred.
+
+from antlr4.InputStream import InputStream
+from antlr4.ParserRuleContext import ParserRuleContext
+from antlr4.Recognizer import Recognizer
+
+class RecognitionException(Exception):
+
+
+    def __init__(self, message:str=None, recognizer:Recognizer=None, input:InputStream=None, ctx:ParserRulecontext=None):
+        super().__init__(message)
+        self.message = message
+        self.recognizer = recognizer
+        self.input = input
+        self.ctx = ctx
+        # The current {@link Token} when an error occurred. Since not all streams
+        # support accessing symbols by index, we have to track the {@link Token}
+        # instance itself.
+        self.offendingToken = None
+        # Get the ATN state number the parser was in at the time the error
+        # occurred. For {@link NoViableAltException} and
+        # {@link LexerNoViableAltException} exceptions, this is the
+        # {@link DecisionState} number. For others, it is the state whose outgoing
+        # edge we couldn't match.
+        self.offendingState = -1
+        if recognizer is not None:
+            self.offendingState = recognizer.state
+
+    # <p>If the state number is not known, this method returns -1.</p>
+
+    #
+    # Gets the set of input symbols which could potentially follow the
+    # previously matched symbol at the time this exception was thrown.
+    #
+    # <p>If the set of expected tokens is not known and could not be computed,
+    # this method returns {@code null}.</p>
+    #
+    # @return The set of token types that could potentially follow the current
+    # state in the ATN, or {@code null} if the information is not available.
+    #/
+    def getExpectedTokens(self):
+        if self.recognizer is not None:
+            return self.recognizer.atn.getExpectedTokens(self.offendingState, self.ctx)
+        else:
+            return None
+
+
+class LexerNoViableAltException(RecognitionException):
+
+    def __init__(self, lexer:Lexer, input:InputStream, startIndex:int, deadEndConfigs:ATNConfigSet):
+        super().__init__(message=None, recognizer=lexer, input=input, ctx=None)
+        self.startIndex = startIndex
+        self.deadEndConfigs = deadEndConfigs
+
+    def __str__(self):
+        symbol = ""
+        if self.startIndex >= 0 and self.startIndex < self.input.size:
+            symbol = self.input.getText(self.startIndex, self.startIndex)
+            # TODO symbol = Utils.escapeWhitespace(symbol, false);
+        return "LexerNoViableAltException('" + symbol + "')"
+
+# Indicates that the parser could not decide which of two or more paths
+#  to take based upon the remaining input. It tracks the starting token
+#  of the offending input and also knows where the parser was
+#  in the various paths when the error. Reported by reportNoViableAlternative()
+#
+class NoViableAltException(RecognitionException):
+
+    def __init__(self, recognizer:Parser, input:TokenStream=None, startToken:Token=None,
+                    offendingToken:Token=None, deadEndConfigs:ATNConfigSet=None, ctx:ParserRuleContext=None):
+        if ctx is None:
+            ctx = recognizer._ctx
+        if offendingToken is None:
+            offendingToken = recognizer.getCurrentToken()
+        if startToken is None:
+            startToken = recognizer.getCurrentToken()
+        if input is None:
+            input = recognizer.getInputStream()
+        super().__init__(recognizer=recognizer, input=input, ctx=ctx)
+        # Which configurations did we try at input.index() that couldn't match input.LT(1)?#
+        self.deadEndConfigs = deadEndConfigs
+        # The token object at the start index; the input stream might
+        # 	not be buffering tokens so get a reference to it. (At the
+        #  time the error occurred, of course the stream needs to keep a
+        #  buffer all of the tokens but later we might not have access to those.)
+        self.startToken = startToken
+        self.offendingToken = offendingToken
+
+# This signifies any kind of mismatched input exceptions such as
+#  when the current input does not match the expected token.
+#
+class InputMismatchException(RecognitionException):
+
+    def __init__(self, recognizer:Parser):
+        super().__init__(recognizer=recognizer, input=recognizer.getInputStream(), ctx=recognizer._ctx)
+        self.offendingToken = recognizer.getCurrentToken()
+
+
+# A semantic predicate failed during validation.  Validation of predicates
+#  occurs when normally parsing the alternative just like matching a token.
+#  Disambiguating predicate evaluation occurs when we test a predicate during
+#  prediction.
+
+class FailedPredicateException(RecognitionException):
+
+    def __init__(self, recognizer:Parser, predicate:str=None, message:str=None):
+        super().__init__(message=self.formatMessage(predicate,message), recognizer=recognizer,
+                         input=recognizer.getInputStream(), ctx=recognizer._ctx)
+        s = recognizer._interp.atn.states[recognizer.state]
+        trans = s.transitions[0]
+        from antlr4.atn.Transition import PredicateTransition
+        if isinstance(trans, PredicateTransition):
+            self.ruleIndex = trans.ruleIndex
+            self.predicateIndex = trans.predIndex
+        else:
+            self.ruleIndex = 0
+            self.predicateIndex = 0
+        self.predicate = predicate
+        self.offendingToken = recognizer.getCurrentToken()
+
+    def formatMessage(self, predicate:str, message:str):
+        if message is not None:
+            return message
+        else:
+            return "failed predicate: {" + predicate + "}?"
+
+class ParseCancellationException(CancellationException):
+
+    pass
+
+del Token
+del Lexer
+del Parser
+del TokenStream
+del ATNConfigSet
+del ParserRulecontext
+del PredicateTransition
+del BufferedTokenStream

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/error/__init__.py

@@ -0,0 +1 @@
+__author__ = 'ericvergnaud'

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/tree/Chunk.py

@@ -0,0 +1,30 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+class Chunk(object):
+    pass
+
+class TagChunk(Chunk):
+    __slots__ = ('tag', 'label')
+
+    def __init__(self, tag:str, label:str=None):
+        self.tag = tag
+        self.label = label
+
+    def __str__(self):
+        if self.label is None:
+            return self.tag
+        else:
+            return self.label + ":" + self.tag
+
+class TextChunk(Chunk):
+    __slots__ = 'text'
+
+    def __init__(self, text:str):
+        self.text = text
+
+    def __str__(self):
+        return "'" + self.text + "'"

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/tree/ParseTreeMatch.py

@@ -0,0 +1,118 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+
+#
+# Represents the result of matching a {@link ParseTree} against a tree pattern.
+#
+from io import StringIO
+from antlr4.tree.ParseTreePattern import ParseTreePattern
+from antlr4.tree.Tree import ParseTree
+
+
+class ParseTreeMatch(object):
+    __slots__ = ('tree', 'pattern', 'labels', 'mismatchedNode')
+    #
+    # Constructs a new instance of {@link ParseTreeMatch} from the specified
+    # parse tree and pattern.
+    #
+    # @param tree The parse tree to match against the pattern.
+    # @param pattern The parse tree pattern.
+    # @param labels A mapping from label names to collections of
+    # {@link ParseTree} objects located by the tree pattern matching process.
+    # @param mismatchedNode The first node which failed to match the tree
+    # pattern during the matching process.
+    #
+    # @exception IllegalArgumentException if {@code tree} is {@code null}
+    # @exception IllegalArgumentException if {@code pattern} is {@code null}
+    # @exception IllegalArgumentException if {@code labels} is {@code null}
+    #
+    def __init__(self, tree:ParseTree, pattern:ParseTreePattern, labels:dict, mismatchedNode:ParseTree):
+        if tree is None:
+            raise Exception("tree cannot be null")
+        if pattern is None:
+            raise Exception("pattern cannot be null")
+        if labels is None:
+            raise Exception("labels cannot be null")
+        self.tree = tree
+        self.pattern = pattern
+        self.labels = labels
+        self.mismatchedNode = mismatchedNode
+
+    #
+    # Get the last node associated with a specific {@code label}.
+    #
+    # <p>For example, for pattern {@code <id:ID>}, {@code get("id")} returns the
+    # node matched for that {@code ID}. If more than one node
+    # matched the specified label, only the last is returned. If there is
+    # no node associated with the label, this returns {@code null}.</p>
+    #
+    # <p>Pattern tags like {@code <ID>} and {@code <expr>} without labels are
+    # considered to be labeled with {@code ID} and {@code expr}, respectively.</p>
+    #
+    # @param label The label to check.
+    #
+    # @return The last {@link ParseTree} to match a tag with the specified
+    # label, or {@code null} if no parse tree matched a tag with the label.
+    #
+    def get(self, label:str):
+        parseTrees = self.labels.get(label, None)
+        if parseTrees is None or len(parseTrees)==0:
+            return None
+        else:
+            return parseTrees[len(parseTrees)-1]
+
+    #
+    # Return all nodes matching a rule or token tag with the specified label.
+    #
+    # <p>If the {@code label} is the name of a parser rule or token in the
+    # grammar, the resulting list will contain both the parse trees matching
+    # rule or tags explicitly labeled with the label and the complete set of
+    # parse trees matching the labeled and unlabeled tags in the pattern for
+    # the parser rule or token. For example, if {@code label} is {@code "foo"},
+    # the result will contain <em>all</em> of the following.</p>
+    #
+    # <ul>
+    # <li>Parse tree nodes matching tags of the form {@code <foo:anyRuleName>} and
+    # {@code <foo:AnyTokenName>}.</li>
+    # <li>Parse tree nodes matching tags of the form {@code <anyLabel:foo>}.</li>
+    # <li>Parse tree nodes matching tags of the form {@code <foo>}.</li>
+    # </ul>
+    #
+    # @param label The label.
+    #
+    # @return A collection of all {@link ParseTree} nodes matching tags with
+    # the specified {@code label}. If no nodes matched the label, an empty list
+    # is returned.
+    #
+    def getAll(self, label:str):
+        nodes = self.labels.get(label, None)
+        if nodes is None:
+            return list()
+        else:
+            return nodes
+
+
+    #
+    # Gets a value indicating whether the match operation succeeded.
+    #
+    # @return {@code true} if the match operation succeeded; otherwise,
+    # {@code false}.
+    #
+    def succeeded(self):
+        return self.mismatchedNode is None
+
+    #
+    # {@inheritDoc}
+    #
+    def __str__(self):
+        with StringIO() as buf:
+            buf.write("Match ")
+            buf.write("succeeded" if self.succeeded() else "failed")
+            buf.write("; found ")
+            buf.write(str(len(self.labels)))
+            buf.write(" labels")
+            return buf.getvalue()

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/tree/ParseTreePattern.py

@@ -0,0 +1,72 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+#
+# A pattern like {@code <ID> = <expr>;} converted to a {@link ParseTree} by
+# {@link ParseTreePatternMatcher#compile(String, int)}.
+#
+from antlr4.tree.ParseTreePatternMatcher import ParseTreePatternMatcher
+from antlr4.tree.Tree import ParseTree
+from antlr4.xpath.XPath import XPath
+
+
+class ParseTreePattern(object):
+    __slots__ = ('matcher', 'patternRuleIndex', 'pattern', 'patternTree')
+
+    # Construct a new instance of the {@link ParseTreePattern} class.
+    #
+    # @param matcher The {@link ParseTreePatternMatcher} which created this
+    # tree pattern.
+    # @param pattern The tree pattern in concrete syntax form.
+    # @param patternRuleIndex The parser rule which serves as the root of the
+    # tree pattern.
+    # @param patternTree The tree pattern in {@link ParseTree} form.
+    #
+    def __init__(self, matcher:ParseTreePatternMatcher, pattern:str, patternRuleIndex:int , patternTree:ParseTree):
+        self.matcher = matcher
+        self.patternRuleIndex = patternRuleIndex
+        self.pattern = pattern
+        self.patternTree = patternTree
+
+    #
+    # Match a specific parse tree against this tree pattern.
+    #
+    # @param tree The parse tree to match against this tree pattern.
+    # @return A {@link ParseTreeMatch} object describing the result of the
+    # match operation. The {@link ParseTreeMatch#succeeded()} method can be
+    # used to determine whether or not the match was successful.
+    #
+    def match(self, tree:ParseTree):
+        return self.matcher.match(tree, self)
+
+    #
+    # Determine whether or not a parse tree matches this tree pattern.
+    #
+    # @param tree The parse tree to match against this tree pattern.
+    # @return {@code true} if {@code tree} is a match for the current tree
+    # pattern; otherwise, {@code false}.
+    #
+    def matches(self, tree:ParseTree):
+        return self.matcher.match(tree, self).succeeded()
+
+    # Find all nodes using XPath and then try to match those subtrees against
+    # this tree pattern.
+    #
+    # @param tree The {@link ParseTree} to match against this pattern.
+    # @param xpath An expression matching the nodes
+    #
+    # @return A collection of {@link ParseTreeMatch} objects describing the
+    # successful matches. Unsuccessful matches are omitted from the result,
+    # regardless of the reason for the failure.
+    #
+    def findAll(self, tree:ParseTree, xpath:str):
+        subtrees = XPath.findAll(tree, xpath, self.matcher.parser)
+        matches = list()
+        for t in subtrees:
+            match = self.match(t)
+            if match.succeeded():
+                matches.append(match)
+        return matches

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/tree/ParseTreePatternMatcher.py

@@ -0,0 +1,374 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+#
+# A tree pattern matching mechanism for ANTLR {@link ParseTree}s.
+#
+# <p>Patterns are strings of source input text with special tags representing
+# token or rule references such as:</p>
+#
+# <p>{@code <ID> = <expr>;}</p>
+#
+# <p>Given a pattern start rule such as {@code statement}, this object constructs
+# a {@link ParseTree} with placeholders for the {@code ID} and {@code expr}
+# subtree. Then the {@link #match} routines can compare an actual
+# {@link ParseTree} from a parse with this pattern. Tag {@code <ID>} matches
+# any {@code ID} token and tag {@code <expr>} references the result of the
+# {@code expr} rule (generally an instance of {@code ExprContext}.</p>
+#
+# <p>Pattern {@code x = 0;} is a similar pattern that matches the same pattern
+# except that it requires the identifier to be {@code x} and the expression to
+# be {@code 0}.</p>
+#
+# <p>The {@link #matches} routines return {@code true} or {@code false} based
+# upon a match for the tree rooted at the parameter sent in. The
+# {@link #match} routines return a {@link ParseTreeMatch} object that
+# contains the parse tree, the parse tree pattern, and a map from tag name to
+# matched nodes (more below). A subtree that fails to match, returns with
+# {@link ParseTreeMatch#mismatchedNode} set to the first tree node that did not
+# match.</p>
+#
+# <p>For efficiency, you can compile a tree pattern in string form to a
+# {@link ParseTreePattern} object.</p>
+#
+# <p>See {@code TestParseTreeMatcher} for lots of examples.
+# {@link ParseTreePattern} has two static helper methods:
+# {@link ParseTreePattern#findAll} and {@link ParseTreePattern#match} that
+# are easy to use but not super efficient because they create new
+# {@link ParseTreePatternMatcher} objects each time and have to compile the
+# pattern in string form before using it.</p>
+#
+# <p>The lexer and parser that you pass into the {@link ParseTreePatternMatcher}
+# constructor are used to parse the pattern in string form. The lexer converts
+# the {@code <ID> = <expr>;} into a sequence of four tokens (assuming lexer
+# throws out whitespace or puts it on a hidden channel). Be aware that the
+# input stream is reset for the lexer (but not the parser; a
+# {@link ParserInterpreter} is created to parse the input.). Any user-defined
+# fields you have put into the lexer might get changed when this mechanism asks
+# it to scan the pattern string.</p>
+#
+# <p>Normally a parser does not accept token {@code <expr>} as a valid
+# {@code expr} but, from the parser passed in, we create a special version of
+# the underlying grammar representation (an {@link ATN}) that allows imaginary
+# tokens representing rules ({@code <expr>}) to match entire rules. We call
+# these <em>bypass alternatives</em>.</p>
+#
+# <p>Delimiters are {@code <} and {@code >}, with {@code \} as the escape string
+# by default, but you can set them to whatever you want using
+# {@link #setDelimiters}. You must escape both start and stop strings
+# {@code \<} and {@code \>}.</p>
+#
+from antlr4.CommonTokenStream import CommonTokenStream
+from antlr4.InputStream import InputStream
+from antlr4.ParserRuleContext import ParserRuleContext
+from antlr4.Lexer import Lexer
+from antlr4.ListTokenSource import ListTokenSource
+from antlr4.Token import Token
+from antlr4.error.ErrorStrategy import BailErrorStrategy
+from antlr4.error.Errors import RecognitionException, ParseCancellationException
+from antlr4.tree.Chunk import TagChunk, TextChunk
+from antlr4.tree.RuleTagToken import RuleTagToken
+from antlr4.tree.TokenTagToken import TokenTagToken
+from antlr4.tree.Tree import ParseTree, TerminalNode, RuleNode
+
+# need forward declaration
+Parser = None
+ParseTreePattern = None
+
+class CannotInvokeStartRule(Exception):
+
+    def __init__(self, e:Exception):
+        super().__init__(e)
+
+class StartRuleDoesNotConsumeFullPattern(Exception):
+
+    pass
+
+
+class ParseTreePatternMatcher(object):
+    __slots__ = ('lexer', 'parser', 'start', 'stop', 'escape')
+
+    # Constructs a {@link ParseTreePatternMatcher} or from a {@link Lexer} and
+    # {@link Parser} object. The lexer input stream is altered for tokenizing
+    # the tree patterns. The parser is used as a convenient mechanism to get
+    # the grammar name, plus token, rule names.
+    def __init__(self, lexer:Lexer, parser:Parser):
+        self.lexer = lexer
+        self.parser = parser
+        self.start = "<"
+        self.stop = ">"
+        self.escape = "\\"  # e.g., \< and \> must escape BOTH!
+
+    # Set the delimiters used for marking rule and token tags within concrete
+    # syntax used by the tree pattern parser.
+    #
+    # @param start The start delimiter.
+    # @param stop The stop delimiter.
+    # @param escapeLeft The escape sequence to use for escaping a start or stop delimiter.
+    #
+    # @exception IllegalArgumentException if {@code start} is {@code null} or empty.
+    # @exception IllegalArgumentException if {@code stop} is {@code null} or empty.
+    #
+    def setDelimiters(self, start:str, stop:str, escapeLeft:str):
+        if start is None or len(start)==0:
+            raise Exception("start cannot be null or empty")
+        if stop is None or len(stop)==0:
+            raise Exception("stop cannot be null or empty")
+        self.start = start
+        self.stop = stop
+        self.escape = escapeLeft
+
+    # Does {@code pattern} matched as rule {@code patternRuleIndex} match {@code tree}?#
+    def matchesRuleIndex(self, tree:ParseTree, pattern:str, patternRuleIndex:int):
+        p = self.compileTreePattern(pattern, patternRuleIndex)
+        return self.matches(tree, p)
+
+    # Does {@code pattern} matched as rule patternRuleIndex match tree? Pass in a
+    #  compiled pattern instead of a string representation of a tree pattern.
+    #
+    def matchesPattern(self, tree:ParseTree, pattern:ParseTreePattern):
+        mismatchedNode = self.matchImpl(tree, pattern.patternTree, dict())
+        return mismatchedNode is None
+
+    #
+    # Compare {@code pattern} matched as rule {@code patternRuleIndex} against
+    # {@code tree} and return a {@link ParseTreeMatch} object that contains the
+    # matched elements, or the node at which the match failed.
+    #
+    def matchRuleIndex(self, tree:ParseTree, pattern:str, patternRuleIndex:int):
+        p = self.compileTreePattern(pattern, patternRuleIndex)
+        return self.matchPattern(tree, p)
+
+    #
+    # Compare {@code pattern} matched against {@code tree} and return a
+    # {@link ParseTreeMatch} object that contains the matched elements, or the
+    # node at which the match failed. Pass in a compiled pattern instead of a
+    # string representation of a tree pattern.
+    #
+    def matchPattern(self, tree:ParseTree, pattern:ParseTreePattern):
+        labels = dict()
+        mismatchedNode = self.matchImpl(tree, pattern.patternTree, labels)
+        from antlr4.tree.ParseTreeMatch import ParseTreeMatch
+        return ParseTreeMatch(tree, pattern, labels, mismatchedNode)
+
+    #
+    # For repeated use of a tree pattern, compile it to a
+    # {@link ParseTreePattern} using this method.
+    #
+    def compileTreePattern(self, pattern:str, patternRuleIndex:int):
+        tokenList = self.tokenize(pattern)
+        tokenSrc = ListTokenSource(tokenList)
+        tokens = CommonTokenStream(tokenSrc)
+        from antlr4.ParserInterpreter import ParserInterpreter
+        parserInterp = ParserInterpreter(self.parser.grammarFileName, self.parser.tokenNames,
+                                self.parser.ruleNames, self.parser.getATNWithBypassAlts(),tokens)
+        tree = None
+        try:
+            parserInterp.setErrorHandler(BailErrorStrategy())
+            tree = parserInterp.parse(patternRuleIndex)
+        except ParseCancellationException as e:
+            raise e.cause
+        except RecognitionException as e:
+            raise e
+        except Exception as e:
+            raise CannotInvokeStartRule(e)
+
+        # Make sure tree pattern compilation checks for a complete parse
+        if tokens.LA(1)!=Token.EOF:
+            raise StartRuleDoesNotConsumeFullPattern()
+
+        from antlr4.tree.ParseTreePattern import ParseTreePattern
+        return ParseTreePattern(self, pattern, patternRuleIndex, tree)
+
+    #
+    # Recursively walk {@code tree} against {@code patternTree}, filling
+    # {@code match.}{@link ParseTreeMatch#labels labels}.
+    #
+    # @return the first node encountered in {@code tree} which does not match
+    # a corresponding node in {@code patternTree}, or {@code null} if the match
+    # was successful. The specific node returned depends on the matching
+    # algorithm used by the implementation, and may be overridden.
+    #
+    def matchImpl(self, tree:ParseTree, patternTree:ParseTree, labels:dict):
+        if tree is None:
+            raise Exception("tree cannot be null")
+        if patternTree is None:
+            raise Exception("patternTree cannot be null")
+
+        # x and <ID>, x and y, or x and x; or could be mismatched types
+        if isinstance(tree, TerminalNode) and isinstance(patternTree, TerminalNode ):
+            mismatchedNode = None
+            # both are tokens and they have same type
+            if tree.symbol.type == patternTree.symbol.type:
+                if isinstance( patternTree.symbol, TokenTagToken ): # x and <ID>
+                    tokenTagToken = patternTree.symbol
+                    # track label->list-of-nodes for both token name and label (if any)
+                    self.map(labels, tokenTagToken.tokenName, tree)
+                    if tokenTagToken.label is not None:
+                        self.map(labels, tokenTagToken.label, tree)
+                elif tree.getText()==patternTree.getText():
+                    # x and x
+                    pass
+                else:
+                    # x and y
+                    if mismatchedNode is None:
+                        mismatchedNode = tree
+            else:
+                if mismatchedNode is None:
+                    mismatchedNode = tree
+
+            return mismatchedNode
+
+        if isinstance(tree, ParserRuleContext) and isinstance(patternTree, ParserRuleContext):
+            mismatchedNode = None
+            # (expr ...) and <expr>
+            ruleTagToken = self.getRuleTagToken(patternTree)
+            if ruleTagToken is not None:
+                m = None
+                if tree.ruleContext.ruleIndex == patternTree.ruleContext.ruleIndex:
+                    # track label->list-of-nodes for both rule name and label (if any)
+                    self.map(labels, ruleTagToken.ruleName, tree)
+                    if ruleTagToken.label is not None:
+                        self.map(labels, ruleTagToken.label, tree)
+                else:
+                    if mismatchedNode is None:
+                        mismatchedNode = tree
+
+                return mismatchedNode
+
+            # (expr ...) and (expr ...)
+            if tree.getChildCount()!=patternTree.getChildCount():
+                if mismatchedNode is None:
+                    mismatchedNode = tree
+                return mismatchedNode
+
+            n = tree.getChildCount()
+            for i in range(0, n):
+                childMatch = self.matchImpl(tree.getChild(i), patternTree.getChild(i), labels)
+                if childMatch is not None:
+                    return childMatch
+
+            return mismatchedNode
+
+        # if nodes aren't both tokens or both rule nodes, can't match
+        return tree
+
+    def map(self, labels, label, tree):
+        v = labels.get(label, None)
+        if v is None:
+            v = list()
+            labels[label] = v
+        v.append(tree)
+
+    # Is {@code t} {@code (expr <expr>)} subtree?#
+    def getRuleTagToken(self, tree:ParseTree):
+        if isinstance( tree, RuleNode ):
+            if tree.getChildCount()==1 and isinstance(tree.getChild(0), TerminalNode ):
+                c = tree.getChild(0)
+                if isinstance( c.symbol, RuleTagToken ):
+                    return c.symbol
+        return None
+
+    def tokenize(self, pattern:str):
+        # split pattern into chunks: sea (raw input) and islands (<ID>, <expr>)
+        chunks = self.split(pattern)
+
+        # create token stream from text and tags
+        tokens = list()
+        for chunk in chunks:
+            if isinstance( chunk, TagChunk ):
+                # add special rule token or conjure up new token from name
+                if chunk.tag[0].isupper():
+                    ttype = self.parser.getTokenType(chunk.tag)
+                    if ttype==Token.INVALID_TYPE:
+                        raise Exception("Unknown token " + str(chunk.tag) + " in pattern: " + pattern)
+                    tokens.append(TokenTagToken(chunk.tag, ttype, chunk.label))
+                elif chunk.tag[0].islower():
+                    ruleIndex = self.parser.getRuleIndex(chunk.tag)
+                    if ruleIndex==-1:
+                        raise Exception("Unknown rule " + str(chunk.tag) + " in pattern: " + pattern)
+                    ruleImaginaryTokenType = self.parser.getATNWithBypassAlts().ruleToTokenType[ruleIndex]
+                    tokens.append(RuleTagToken(chunk.tag, ruleImaginaryTokenType, chunk.label))
+                else:
+                    raise Exception("invalid tag: " + str(chunk.tag) + " in pattern: " + pattern)
+            else:
+                self.lexer.setInputStream(InputStream(chunk.text))
+                t = self.lexer.nextToken()
+                while t.type!=Token.EOF:
+                    tokens.append(t)
+                    t = self.lexer.nextToken()
+        return tokens
+
+    # Split {@code <ID> = <e:expr> ;} into 4 chunks for tokenizing by {@link #tokenize}.#
+    def split(self, pattern:str):
+        p = 0
+        n = len(pattern)
+        chunks = list()
+        # find all start and stop indexes first, then collect
+        starts = list()
+        stops = list()
+        while p < n :
+            if p == pattern.find(self.escape + self.start, p):
+                p += len(self.escape) + len(self.start)
+            elif p == pattern.find(self.escape + self.stop, p):
+                p += len(self.escape) + len(self.stop)
+            elif p == pattern.find(self.start, p):
+                starts.append(p)
+                p += len(self.start)
+            elif p == pattern.find(self.stop, p):
+                stops.append(p)
+                p += len(self.stop)
+            else:
+                p += 1
+
+        nt = len(starts)
+
+        if nt > len(stops):
+            raise Exception("unterminated tag in pattern: " + pattern)
+        if nt < len(stops):
+            raise Exception("missing start tag in pattern: " + pattern)
+
+        for i in range(0, nt):
+            if starts[i] >= stops[i]:
+                raise Exception("tag delimiters out of order in pattern: " + pattern)
+
+        # collect into chunks now
+        if nt==0:
+            chunks.append(TextChunk(pattern))
+
+        if nt>0 and starts[0]>0: # copy text up to first tag into chunks
+            text = pattern[0:starts[0]]
+            chunks.add(TextChunk(text))
+
+        for i in range(0, nt):
+            # copy inside of <tag>
+            tag = pattern[starts[i] + len(self.start) : stops[i]]
+            ruleOrToken = tag
+            label = None
+            colon = tag.find(':')
+            if colon >= 0:
+                label = tag[0:colon]
+                ruleOrToken = tag[colon+1 : len(tag)]
+            chunks.append(TagChunk(label, ruleOrToken))
+            if i+1 < len(starts):
+                # copy from end of <tag> to start of next
+                text = pattern[stops[i] + len(self.stop) : starts[i + 1]]
+                chunks.append(TextChunk(text))
+
+        if nt > 0 :
+            afterLastTag = stops[nt - 1] + len(self.stop)
+            if afterLastTag < n : # copy text from end of last tag to end
+                text = pattern[afterLastTag : n]
+                chunks.append(TextChunk(text))
+
+        # strip out the escape sequences from text chunks but not tags
+        for i in range(0, len(chunks)):
+            c = chunks[i]
+            if isinstance( c, TextChunk ):
+                unescaped = c.text.replace(self.escape, "")
+                if len(unescaped) < len(c.text):
+                    chunks[i] = TextChunk(unescaped)
+        return chunks

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/tree/RuleTagToken.py

@@ -0,0 +1,50 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+#
+# A {@link Token} object representing an entire subtree matched by a parser
+# rule; e.g., {@code <expr>}. These tokens are created for {@link TagChunk}
+# chunks where the tag corresponds to a parser rule.
+#
+from antlr4.Token import Token
+
+
+class RuleTagToken(Token):
+    __slots__ = ('label', 'ruleName')
+    #
+    # Constructs a new instance of {@link RuleTagToken} with the specified rule
+    # name, bypass token type, and label.
+    #
+    # @param ruleName The name of the parser rule this rule tag matches.
+    # @param bypassTokenType The bypass token type assigned to the parser rule.
+    # @param label The label associated with the rule tag, or {@code null} if
+    # the rule tag is unlabeled.
+    #
+    # @exception IllegalArgumentException if {@code ruleName} is {@code null}
+    # or empty.
+
+    def __init__(self, ruleName:str, bypassTokenType:int, label:str=None):
+        if ruleName is None or len(ruleName)==0:
+            raise Exception("ruleName cannot be null or empty.")
+        self.source = None
+        self.type = bypassTokenType # token type of the token
+        self.channel = Token.DEFAULT_CHANNEL # The parser ignores everything not on DEFAULT_CHANNEL
+        self.start = -1 # optional; return -1 if not implemented.
+        self.stop = -1  # optional; return -1 if not implemented.
+        self.tokenIndex = -1 # from 0..n-1 of the token object in the input stream
+        self.line = 0 # line=1..n of the 1st character
+        self.column = -1 # beginning of the line at which it occurs, 0..n-1
+        self.label = label
+        self._text = self.getText() # text of the token.
+
+        self.ruleName = ruleName
+
+
+    def getText(self):
+        if self.label is None:
+            return "<" + self.ruleName + ">"
+        else:
+            return "<" + self.label + ":" + self.ruleName + ">"

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/tree/TokenTagToken.py

@@ -0,0 +1,47 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+#
+# A {@link Token} object representing a token of a particular type; e.g.,
+# {@code <ID>}. These tokens are created for {@link TagChunk} chunks where the
+# tag corresponds to a lexer rule or token type.
+#
+from antlr4.Token import CommonToken
+
+
+class TokenTagToken(CommonToken):
+    __slots__ = ('tokenName', 'label')
+    # Constructs a new instance of {@link TokenTagToken} with the specified
+    # token name, type, and label.
+    #
+    # @param tokenName The token name.
+    # @param type The token type.
+    # @param label The label associated with the token tag, or {@code null} if
+    # the token tag is unlabeled.
+    #
+    def __init__(self, tokenName:str, type:int, label:str=None):
+        super().__init__(type=type)
+        self.tokenName = tokenName
+        self.label = label
+        self._text = self.getText()
+
+    #
+    # {@inheritDoc}
+    #
+    # <p>The implementation for {@link TokenTagToken} returns the token tag
+    # formatted with {@code <} and {@code >} delimiters.</p>
+    #
+    def getText(self):
+        if self.label is None:
+            return "<" + self.tokenName + ">"
+        else:
+            return "<" + self.label + ":" + self.tokenName + ">"
+
+    # <p>The implementation for {@link TokenTagToken} returns a string of the form
+    # {@code tokenName:type}.</p>
+    #
+    def __str__(self):
+        return self.tokenName + ":" + str(self.type)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/tree/Tree.py

@@ -0,0 +1,191 @@
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#/
+
+
+# The basic notion of a tree has a parent, a payload, and a list of children.
+#  It is the most abstract interface for all the trees used by ANTLR.
+#/
+from antlr4.Token import Token
+
+INVALID_INTERVAL = (-1, -2)
+
+class Tree(object):
+    pass
+
+class SyntaxTree(Tree):
+    pass
+
+class ParseTree(SyntaxTree):
+    pass
+
+class RuleNode(ParseTree):
+    pass
+
+class TerminalNode(ParseTree):
+    pass
+
+class ErrorNode(TerminalNode):
+    pass
+
+class ParseTreeVisitor(object):
+    def visit(self, tree):
+        return tree.accept(self)
+
+    def visitChildren(self, node):
+        result = self.defaultResult()
+        n = node.getChildCount()
+        for i in range(n):
+            if not self.shouldVisitNextChild(node, result):
+                return result
+
+            c = node.getChild(i)
+            childResult = c.accept(self)
+            result = self.aggregateResult(result, childResult)
+
+        return result
+
+    def visitTerminal(self, node):
+        return self.defaultResult()
+
+    def visitErrorNode(self, node):
+        return self.defaultResult()
+
+    def defaultResult(self):
+        return None
+
+    def aggregateResult(self, aggregate, nextResult):
+        return nextResult
+
+    def shouldVisitNextChild(self, node, currentResult):
+        return True
+
+ParserRuleContext = None
+
+class ParseTreeListener(object):
+
+    def visitTerminal(self, node:TerminalNode):
+        pass
+
+    def visitErrorNode(self, node:ErrorNode):
+        pass
+
+    def enterEveryRule(self, ctx:ParserRuleContext):
+        pass
+
+    def exitEveryRule(self, ctx:ParserRuleContext):
+        pass
+
+del ParserRuleContext
+
+class TerminalNodeImpl(TerminalNode):
+    __slots__ = ('parentCtx', 'symbol')
+
+    def __init__(self, symbol:Token):
+        self.parentCtx = None
+        self.symbol = symbol
+    def __setattr__(self, key, value):
+        super().__setattr__(key, value)
+
+    def getChild(self, i:int):
+        return None
+
+    def getSymbol(self):
+        return self.symbol
+
+    def getParent(self):
+        return self.parentCtx
+
+    def getPayload(self):
+        return self.symbol
+
+    def getSourceInterval(self):
+        if self.symbol is None:
+            return INVALID_INTERVAL
+        tokenIndex = self.symbol.tokenIndex
+        return (tokenIndex, tokenIndex)
+
+    def getChildCount(self):
+        return 0
+
+    def accept(self, visitor:ParseTreeVisitor):
+        return visitor.visitTerminal(self)
+
+    def getText(self):
+        return self.symbol.text
+
+    def __str__(self):
+        if self.symbol.type == Token.EOF:
+            return "<EOF>"
+        else:
+            return self.symbol.text
+
+# Represents a token that was consumed during resynchronization
+#  rather than during a valid match operation. For example,
+#  we will create this kind of a node during single token insertion
+#  and deletion as well as during "consume until error recovery set"
+#  upon no viable alternative exceptions.
+
+class ErrorNodeImpl(TerminalNodeImpl,ErrorNode):
+
+    def __init__(self, token:Token):
+        super().__init__(token)
+
+    def accept(self, visitor:ParseTreeVisitor):
+        return visitor.visitErrorNode(self)
+
+
+class ParseTreeWalker(object):
+
+    DEFAULT = None
+
+    def walk(self, listener:ParseTreeListener, t:ParseTree):
+        """
+	    Performs a walk on the given parse tree starting at the root and going down recursively
+	    with depth-first search. On each node, {@link ParseTreeWalker#enterRule} is called before
+	    recursively walking down into child nodes, then
+	    {@link ParseTreeWalker#exitRule} is called after the recursive call to wind up.
+	    @param listener The listener used by the walker to process grammar rules
+	    @param t The parse tree to be walked on
+        """
+        if isinstance(t, ErrorNode):
+            listener.visitErrorNode(t)
+            return
+        elif isinstance(t, TerminalNode):
+            listener.visitTerminal(t)
+            return
+        self.enterRule(listener, t)
+        for child in t.getChildren():
+            self.walk(listener, child)
+        self.exitRule(listener, t)
+
+    #
+    # The discovery of a rule node, involves sending two events: the generic
+    # {@link ParseTreeListener#enterEveryRule} and a
+    # {@link RuleContext}-specific event. First we trigger the generic and then
+    # the rule specific. We to them in reverse order upon finishing the node.
+    #
+    def enterRule(self, listener:ParseTreeListener, r:RuleNode):
+        """
+	    Enters a grammar rule by first triggering the generic event {@link ParseTreeListener#enterEveryRule}
+	    then by triggering the event specific to the given parse tree node
+	    @param listener The listener responding to the trigger events
+	    @param r The grammar rule containing the rule context
+        """
+        ctx = r.getRuleContext()
+        listener.enterEveryRule(ctx)
+        ctx.enterRule(listener)
+
+    def exitRule(self, listener:ParseTreeListener, r:RuleNode):
+        """
+	    Exits a grammar rule by first triggering the event specific to the given parse tree node
+	    then by triggering the generic event {@link ParseTreeListener#exitEveryRule}
+	    @param listener The listener responding to the trigger events
+	    @param r The grammar rule containing the rule context
+        """
+        ctx = r.getRuleContext()
+        ctx.exitRule(listener)
+        listener.exitEveryRule(ctx)
+
+ParseTreeWalker.DEFAULT = ParseTreeWalker()

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/tree/Trees.py

@@ -0,0 +1,111 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+
+# A set of utility routines useful for all kinds of ANTLR trees.#
+from io import StringIO
+from antlr4.Token import Token
+from antlr4.Utils import escapeWhitespace
+from antlr4.tree.Tree import RuleNode, ErrorNode, TerminalNode, Tree, ParseTree
+
+# need forward declaration
+Parser  = None
+
+class Trees(object):
+
+     # Print out a whole tree in LISP form. {@link #getNodeText} is used on the
+    #  node payloads to get the text for the nodes.  Detect
+    #  parse trees and extract data appropriately.
+    @classmethod
+    def toStringTree(cls, t:Tree, ruleNames:list=None, recog:Parser=None):
+        if recog is not None:
+            ruleNames = recog.ruleNames
+        s = escapeWhitespace(cls.getNodeText(t, ruleNames), False)
+        if t.getChildCount()==0:
+            return s
+        with StringIO() as buf:
+            buf.write("(")
+            buf.write(s)
+            buf.write(' ')
+            for i in range(0, t.getChildCount()):
+                if i > 0:
+                    buf.write(' ')
+                buf.write(cls.toStringTree(t.getChild(i), ruleNames))
+            buf.write(")")
+            return buf.getvalue()
+
+    @classmethod
+    def getNodeText(cls, t:Tree, ruleNames:list=None, recog:Parser=None):
+        if recog is not None:
+            ruleNames = recog.ruleNames
+        if ruleNames is not None:
+            if isinstance(t, RuleNode):
+                if t.getAltNumber()!=0: # should use ATN.INVALID_ALT_NUMBER but won't compile
+                    return ruleNames[t.getRuleIndex()]+":"+str(t.getAltNumber())
+                return ruleNames[t.getRuleIndex()]
+            elif isinstance( t, ErrorNode):
+                return str(t)
+            elif isinstance(t, TerminalNode):
+                if t.symbol is not None:
+                    return t.symbol.text
+        # no recog for rule names
+        payload = t.getPayload()
+        if isinstance(payload, Token ):
+            return payload.text
+        return str(t.getPayload())
+
+
+    # Return ordered list of all children of this node
+    @classmethod
+    def getChildren(cls, t:Tree):
+        return [ t.getChild(i) for i in range(0, t.getChildCount()) ]
+
+    # Return a list of all ancestors of this node.  The first node of
+    #  list is the root and the last is the parent of this node.
+    #
+    @classmethod
+    def getAncestors(cls, t:Tree):
+        ancestors = []
+        t = t.getParent()
+        while t is not None:
+            ancestors.insert(0, t) # insert at start
+            t = t.getParent()
+        return ancestors
+
+    @classmethod
+    def findAllTokenNodes(cls, t:ParseTree, ttype:int):
+        return cls.findAllNodes(t, ttype, True)
+
+    @classmethod
+    def findAllRuleNodes(cls, t:ParseTree, ruleIndex:int):
+        return cls.findAllNodes(t, ruleIndex, False)
+
+    @classmethod
+    def findAllNodes(cls, t:ParseTree, index:int, findTokens:bool):
+        nodes = []
+        cls._findAllNodes(t, index, findTokens, nodes)
+        return nodes
+
+    @classmethod
+    def _findAllNodes(cls, t:ParseTree, index:int, findTokens:bool, nodes:list):
+        from antlr4.ParserRuleContext import ParserRuleContext
+        # check this node (the root) first
+        if findTokens and isinstance(t, TerminalNode):
+            if t.symbol.type==index:
+                nodes.append(t)
+        elif not findTokens and isinstance(t, ParserRuleContext):
+            if t.ruleIndex == index:
+                nodes.append(t)
+        # check children
+        for i in range(0, t.getChildCount()):
+            cls._findAllNodes(t.getChild(i), index, findTokens, nodes)
+
+    @classmethod
+    def descendants(cls, t:ParseTree):
+        nodes = [t]
+        for i in range(0, t.getChildCount()):
+            nodes.extend(cls.descendants(t.getChild(i)))
+        return nodes

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/xpath/XPath.py

@@ -0,0 +1,352 @@
+#
+# Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+# Use of this file is governed by the BSD 3-clause license that
+# can be found in the LICENSE.txt file in the project root.
+#
+
+#
+# Represent a subset of XPath XML path syntax for use in identifying nodes in
+# parse trees.
+#
+# <p>
+# Split path into words and separators {@code /} and {@code //} via ANTLR
+# itself then walk path elements from left to right. At each separator-word
+# pair, find set of nodes. Next stage uses those as work list.</p>
+#
+# <p>
+# The basic interface is
+# {@link XPath#findAll ParseTree.findAll}{@code (tree, pathString, parser)}.
+# But that is just shorthand for:</p>
+#
+# <pre>
+# {@link XPath} p = new {@link XPath#XPath XPath}(parser, pathString);
+# return p.{@link #evaluate evaluate}(tree);
+# </pre>
+#
+# <p>
+# See {@code org.antlr.v4.test.TestXPath} for descriptions. In short, this
+# allows operators:</p>
+#
+# <dl>
+# <dt>/</dt> <dd>root</dd>
+# <dt>//</dt> <dd>anywhere</dd>
+# <dt>!</dt> <dd>invert; this must appear directly after root or anywhere
+# operator</dd>
+# </dl>
+#
+# <p>
+# and path elements:</p>
+#
+# <dl>
+# <dt>ID</dt> <dd>token name</dd>
+# <dt>'string'</dt> <dd>any string literal token from the grammar</dd>
+# <dt>expr</dt> <dd>rule name</dd>
+# <dt>*</dt> <dd>wildcard matching any node</dd>
+# </dl>
+#
+# <p>
+# Whitespace is not allowed.</p>
+#
+from antlr4 import CommonTokenStream, DFA, PredictionContextCache, Lexer, LexerATNSimulator, ParserRuleContext, TerminalNode
+from antlr4.InputStream import InputStream
+from antlr4.Parser import Parser
+from antlr4.RuleContext import RuleContext
+from antlr4.Token import Token
+from antlr4.atn.ATNDeserializer import ATNDeserializer
+from antlr4.error.ErrorListener import ErrorListener
+from antlr4.error.Errors import LexerNoViableAltException
+from antlr4.tree.Tree import ParseTree
+from antlr4.tree.Trees import Trees
+from io import StringIO
+
+
+def serializedATN():
+    with StringIO() as buf:
+        buf.write("\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\2\n")
+        buf.write("\64\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t")
+        buf.write("\7\4\b\t\b\4\t\t\t\3\2\3\2\3\2\3\3\3\3\3\4\3\4\3\5\3\5")
+        buf.write("\3\6\3\6\7\6\37\n\6\f\6\16\6\"\13\6\3\6\3\6\3\7\3\7\5")
+        buf.write("\7(\n\7\3\b\3\b\3\t\3\t\7\t.\n\t\f\t\16\t\61\13\t\3\t")
+        buf.write("\3\t\3/\2\n\3\5\5\6\7\7\t\b\13\t\r\2\17\2\21\n\3\2\4\7")
+        buf.write("\2\62;aa\u00b9\u00b9\u0302\u0371\u2041\u2042\17\2C\\c")
+        buf.write("|\u00c2\u00d8\u00da\u00f8\u00fa\u0301\u0372\u037f\u0381")
+        buf.write("\u2001\u200e\u200f\u2072\u2191\u2c02\u2ff1\u3003\ud801")
+        buf.write("\uf902\ufdd1\ufdf2\uffff\64\2\3\3\2\2\2\2\5\3\2\2\2\2")
+        buf.write("\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\21\3\2\2\2\3\23")
+        buf.write("\3\2\2\2\5\26\3\2\2\2\7\30\3\2\2\2\t\32\3\2\2\2\13\34")
+        buf.write("\3\2\2\2\r\'\3\2\2\2\17)\3\2\2\2\21+\3\2\2\2\23\24\7\61")
+        buf.write("\2\2\24\25\7\61\2\2\25\4\3\2\2\2\26\27\7\61\2\2\27\6\3")
+        buf.write("\2\2\2\30\31\7,\2\2\31\b\3\2\2\2\32\33\7#\2\2\33\n\3\2")
+        buf.write("\2\2\34 \5\17\b\2\35\37\5\r\7\2\36\35\3\2\2\2\37\"\3\2")
+        buf.write("\2\2 \36\3\2\2\2 !\3\2\2\2!#\3\2\2\2\" \3\2\2\2#$\b\6")
+        buf.write("\2\2$\f\3\2\2\2%(\5\17\b\2&(\t\2\2\2\'%\3\2\2\2\'&\3\2")
+        buf.write("\2\2(\16\3\2\2\2)*\t\3\2\2*\20\3\2\2\2+/\7)\2\2,.\13\2")
+        buf.write("\2\2-,\3\2\2\2.\61\3\2\2\2/\60\3\2\2\2/-\3\2\2\2\60\62")
+        buf.write("\3\2\2\2\61/\3\2\2\2\62\63\7)\2\2\63\22\3\2\2\2\6\2 \'")
+        buf.write("/\3\3\6\2")
+        return buf.getvalue()
+
+
+class XPathLexer(Lexer):
+
+    atn = ATNDeserializer().deserialize(serializedATN())
+
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
+
+
+    TOKEN_REF = 1
+    RULE_REF = 2
+    ANYWHERE = 3
+    ROOT = 4
+    WILDCARD = 5
+    BANG = 6
+    ID = 7
+    STRING = 8
+
+    modeNames = [ "DEFAULT_MODE" ]
+
+    literalNames = [ "<INVALID>",
+            "'//'", "'/'", "'*'", "'!'" ]
+
+    symbolicNames = [ "<INVALID>",
+            "TOKEN_REF", "RULE_REF", "ANYWHERE", "ROOT", "WILDCARD", "BANG",
+            "ID", "STRING" ]
+
+    ruleNames = [ "ANYWHERE", "ROOT", "WILDCARD", "BANG", "ID", "NameChar",
+                  "NameStartChar", "STRING" ]
+
+    grammarFileName = "XPathLexer.g4"
+
+    def __init__(self, input=None):
+        super().__init__(input)
+        self.checkVersion("4.9.1")
+        self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
+        self._actions = None
+        self._predicates = None
+
+
+    def action(self, localctx:RuleContext, ruleIndex:int, actionIndex:int):
+        if self._actions is None:
+            actions = dict()
+            actions[4] = self.ID_action
+            self._actions = actions
+        _action = self._actions.get(ruleIndex, None)
+        if _action is not None:
+            _action(localctx, actionIndex)
+        else:
+            raise Exception("No registered action for: %d" % ruleIndex)
+
+    def ID_action(self, localctx:RuleContext , actionIndex:int):
+        if actionIndex == 0:
+            char = self.text[0]
+            if char.isupper():
+                self.type = XPathLexer.TOKEN_REF
+            else:
+                self.type = XPathLexer.RULE_REF
+
+class XPath(object):
+
+    WILDCARD = "*" # word not operator/separator
+    NOT = "!" # word for invert operator
+
+    def __init__(self, parser:Parser, path:str):
+        self.parser = parser
+        self.path = path
+        self.elements = self.split(path)
+
+    def split(self, path:str):
+        input = InputStream(path)
+        lexer = XPathLexer(input)
+        def recover(self, e):
+            raise e
+        lexer.recover = recover
+        lexer.removeErrorListeners()
+        lexer.addErrorListener(ErrorListener()) # XPathErrorListener does no more
+        tokenStream = CommonTokenStream(lexer)
+        try:
+            tokenStream.fill()
+        except LexerNoViableAltException as e:
+            pos = lexer.column
+            msg = "Invalid tokens or characters at index %d in path '%s'" % (pos, path)
+            raise Exception(msg, e)
+
+        tokens = iter(tokenStream.tokens)
+        elements = list()
+        for el in tokens:
+            invert = False
+            anywhere = False
+            # Check for path separators, if none assume root
+            if el.type in [XPathLexer.ROOT, XPathLexer.ANYWHERE]:
+                anywhere = el.type == XPathLexer.ANYWHERE
+                next_el = next(tokens, None)
+                if not next_el:
+                    raise Exception('Missing element after %s' % el.getText())
+                else:
+                    el = next_el
+            # Check for bangs
+            if el.type == XPathLexer.BANG:
+                invert = True
+                next_el = next(tokens, None)
+                if not next_el:
+                    raise Exception('Missing element after %s' % el.getText())
+                else:
+                    el = next_el
+            # Add searched element
+            if el.type in [XPathLexer.TOKEN_REF, XPathLexer.RULE_REF, XPathLexer.WILDCARD, XPathLexer.STRING]:
+                element = self.getXPathElement(el, anywhere)
+                element.invert = invert
+                elements.append(element)
+            elif el.type==Token.EOF:
+                break
+            else:
+                raise Exception("Unknown path element %s" % lexer.symbolicNames[el.type])
+        return elements
+
+    #
+    # Convert word like {@code#} or {@code ID} or {@code expr} to a path
+    # element. {@code anywhere} is {@code true} if {@code //} precedes the
+    # word.
+    #
+    def getXPathElement(self, wordToken:Token, anywhere:bool):
+        if wordToken.type==Token.EOF:
+            raise Exception("Missing path element at end of path")
+
+        word = wordToken.text
+        if wordToken.type==XPathLexer.WILDCARD :
+            return XPathWildcardAnywhereElement() if anywhere else XPathWildcardElement()
+
+        elif wordToken.type in [XPathLexer.TOKEN_REF, XPathLexer.STRING]:
+            tsource = self.parser.getTokenStream().tokenSource
+
+            ttype = Token.INVALID_TYPE
+            if wordToken.type == XPathLexer.TOKEN_REF:
+                if word in tsource.ruleNames:
+                    ttype = tsource.ruleNames.index(word) + 1
+            else:
+                if word in tsource.literalNames:
+                    ttype = tsource.literalNames.index(word)
+
+            if ttype == Token.INVALID_TYPE:
+                raise Exception("%s at index %d isn't a valid token name" % (word, wordToken.tokenIndex))
+            return XPathTokenAnywhereElement(word, ttype) if anywhere else XPathTokenElement(word, ttype)
+
+        else:
+            ruleIndex = self.parser.ruleNames.index(word) if word in self.parser.ruleNames else -1
+
+            if ruleIndex == -1:
+                raise Exception("%s at index %d isn't a valid rule name" % (word, wordToken.tokenIndex))
+            return XPathRuleAnywhereElement(word, ruleIndex) if anywhere else XPathRuleElement(word, ruleIndex)
+
+
+    @staticmethod
+    def findAll(tree:ParseTree, xpath:str, parser:Parser):
+        p = XPath(parser, xpath)
+        return p.evaluate(tree)
+
+    #
+    # Return a list of all nodes starting at {@code t} as root that satisfy the
+    # path. The root {@code /} is relative to the node passed to
+    # {@link #evaluate}.
+    #
+    def evaluate(self, t:ParseTree):
+        dummyRoot = ParserRuleContext()
+        dummyRoot.children = [t] # don't set t's parent.
+
+        work = [dummyRoot]
+        for element in self.elements:
+            work_next = list()
+            for node in work:
+                if not isinstance(node, TerminalNode) and node.children:
+                    # only try to match next element if it has children
+                    # e.g., //func/*/stat might have a token node for which
+                    # we can't go looking for stat nodes.
+                    matching = element.evaluate(node)
+
+                    # See issue antlr#370 - Prevents XPath from returning the 
+                    # same node multiple times
+                    matching = filter(lambda m: m not in work_next, matching)
+                    
+                    work_next.extend(matching)
+            work = work_next
+
+        return work
+
+
+class XPathElement(object):
+
+    def __init__(self, nodeName:str):
+        self.nodeName = nodeName
+        self.invert = False
+
+    def __str__(self):
+        return type(self).__name__ + "[" + ("!" if self.invert else "") + self.nodeName + "]"
+
+
+
+#
+# Either {@code ID} at start of path or {@code ...//ID} in middle of path.
+#
+class XPathRuleAnywhereElement(XPathElement):
+
+    def __init__(self, ruleName:str, ruleIndex:int):
+        super().__init__(ruleName)
+        self.ruleIndex = ruleIndex
+
+    def evaluate(self, t:ParseTree):
+        # return all ParserRuleContext descendants of t that match ruleIndex (or do not match if inverted)
+        return filter(lambda c: isinstance(c, ParserRuleContext) and (self.invert ^ (c.getRuleIndex() == self.ruleIndex)), Trees.descendants(t))
+
+class XPathRuleElement(XPathElement):
+
+    def __init__(self, ruleName:str, ruleIndex:int):
+        super().__init__(ruleName)
+        self.ruleIndex = ruleIndex
+
+    def evaluate(self, t:ParseTree):
+        # return all ParserRuleContext children of t that match ruleIndex (or do not match if inverted)
+        return filter(lambda c: isinstance(c, ParserRuleContext) and (self.invert ^ (c.getRuleIndex() == self.ruleIndex)), Trees.getChildren(t))
+
+class XPathTokenAnywhereElement(XPathElement):
+
+    def __init__(self, ruleName:str, tokenType:int):
+        super().__init__(ruleName)
+        self.tokenType = tokenType
+
+    def evaluate(self, t:ParseTree):
+        # return all TerminalNode descendants of t that match tokenType (or do not match if inverted)
+        return filter(lambda c: isinstance(c, TerminalNode) and (self.invert ^ (c.symbol.type == self.tokenType)), Trees.descendants(t))
+
+class XPathTokenElement(XPathElement):
+
+    def __init__(self, ruleName:str, tokenType:int):
+        super().__init__(ruleName)
+        self.tokenType = tokenType
+
+    def evaluate(self, t:ParseTree):
+        # return all TerminalNode children of t that match tokenType (or do not match if inverted)
+        return filter(lambda c: isinstance(c, TerminalNode) and (self.invert ^ (c.symbol.type == self.tokenType)), Trees.getChildren(t))
+
+
+class XPathWildcardAnywhereElement(XPathElement):
+
+    def __init__(self):
+        super().__init__(XPath.WILDCARD)
+
+    def evaluate(self, t:ParseTree):
+        if self.invert:
+            return list() # !* is weird but valid (empty)
+        else:
+            return Trees.descendants(t)
+
+
+class XPathWildcardElement(XPathElement):
+
+    def __init__(self):
+        super().__init__(XPath.WILDCARD)
+
+
+    def evaluate(self, t:ParseTree):
+        if self.invert:
+            return list() # !* is weird but valid (empty)
+        else:
+            return Trees.getChildren(t)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4/xpath/__init__.py

@@ -0,0 +1 @@
+__author__ = 'ericvergnaud'

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4_python3_runtime-4.9.3.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4_python3_runtime-4.9.3.dist-info/METADATA

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: antlr4-python3-runtime
+Version: 4.9.3
+Summary: ANTLR 4.9.3 runtime for Python 3.7
+Home-page: http://www.antlr.org
+Author: Eric Vergnaud, Terence Parr, Sam Harwell
+Author-email: eric.vergnaud@wanadoo.fr
+License: BSD
+Requires-Dist: typing; python_version < "3.5"
+Dynamic: author
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4_python3_runtime-4.9.3.dist-info/RECORD

@@ -0,0 +1,118 @@
+../../../bin/pygrun,sha256=fyqneSOA38hfCV9dBVscsKTIt9XVKA4-Iy3FFEQsVVM,6182
+antlr4/BufferedTokenStream.py,sha256=_BwmzOH1TO6yL2yC_ZaUzkghq8wzc0UPHfI3UpnZUwM,10780
+antlr4/CommonTokenFactory.py,sha256=Tv16zg_pWD1Dv3IphsxFu8nwWdLeXYcqJ8CC5yHwjH8,2110
+antlr4/CommonTokenStream.py,sha256=NNJHXwRg2_Zn46ZhJyDxZtvZzsPWhb6JjXa7BjM45eg,2770
+antlr4/FileStream.py,sha256=-ZR_-jl_If9IIBYLINIwlQrlTSmu5k1VUKDc3ie7WR4,868
+antlr4/InputStream.py,sha256=sggjE2jEGvSgQmxFvqeeuT3aOVgcH5tS7mMybW8wKS4,2334
+antlr4/IntervalSet.py,sha256=Cd0WKhd_kYbiLYKkDNncgSM19GAuS7OaTOC4-5Yubs4,5965
+antlr4/LL1Analyzer.py,sha256=oJBvO7_S8cAlb_D4qWNxd2IlK0qP4ka-oeoDxx16CZ4,7752
+antlr4/Lexer.py,sha256=C72hqayfkympxb46AcSnhPD9kVZ0quWgboGxa6gcIcg,11542
+antlr4/ListTokenSource.py,sha256=IffLMo7YQnD_CjKryrrgNWSk0q5QSYd7puZyyUk7vOk,5356
+antlr4/Parser.py,sha256=F2Q25z0-__KHfa354KQhDu3ZOVzLFfag3s2ixJ4dl_o,22883
+antlr4/ParserInterpreter.py,sha256=-QU9kn4x3WCQ-LSA99R231HoicTqakiHZ5KM72l-hIo,7206
+antlr4/ParserRuleContext.py,sha256=wHAVdOxMAO5jkUqloTXVzn_xYnJhiHbvvuhZpth0ZF8,6762
+antlr4/PredictionContext.py,sha256=cb4KI6EGpS7sRzJ8UvPEkxphINZuWhyiZ95752g3prI,22977
+antlr4/Recognizer.py,sha256=vmKAtSjIgR9LQr5YzuK5OmPZWMJ3x69OuVZQ_FTzQHE,5383
+antlr4/RuleContext.py,sha256=GiviRv2k_al1IBgdJOEEoD0ohJaVd-_h5T_CPG_Bsmg,8099
+antlr4/StdinStream.py,sha256=MMSH4zN8T6i_nu-3_TlN-3E4nPM4b5KgK4GT6n_FUQA,303
+antlr4/Token.py,sha256=OtWCab4Ut52X_nLLAA-8x4Zl6xaF6TEN-0033uaoaEo,5206
+antlr4/TokenStreamRewriter.py,sha256=cuErQTrXwC_0kqVv3MsTWGZSm-E1Vy1yzA-3SOhKd_s,10324
+antlr4/Utils.py,sha256=Oyg8CJCRL1TrF_QSB_LLlVdWOB4loVcKOgFNT-icO7c,931
+antlr4/__init__.py,sha256=g8UGpflnlMWcAyLtihejzrgAP1Uo3b9GhwfI8QnZjtw,1125
+antlr4/__pycache__/BufferedTokenStream.cpython-310.pyc,,
+antlr4/__pycache__/CommonTokenFactory.cpython-310.pyc,,
+antlr4/__pycache__/CommonTokenStream.cpython-310.pyc,,
+antlr4/__pycache__/FileStream.cpython-310.pyc,,
+antlr4/__pycache__/InputStream.cpython-310.pyc,,
+antlr4/__pycache__/IntervalSet.cpython-310.pyc,,
+antlr4/__pycache__/LL1Analyzer.cpython-310.pyc,,
+antlr4/__pycache__/Lexer.cpython-310.pyc,,
+antlr4/__pycache__/ListTokenSource.cpython-310.pyc,,
+antlr4/__pycache__/Parser.cpython-310.pyc,,
+antlr4/__pycache__/ParserInterpreter.cpython-310.pyc,,
+antlr4/__pycache__/ParserRuleContext.cpython-310.pyc,,
+antlr4/__pycache__/PredictionContext.cpython-310.pyc,,
+antlr4/__pycache__/Recognizer.cpython-310.pyc,,
+antlr4/__pycache__/RuleContext.cpython-310.pyc,,
+antlr4/__pycache__/StdinStream.cpython-310.pyc,,
+antlr4/__pycache__/Token.cpython-310.pyc,,
+antlr4/__pycache__/TokenStreamRewriter.cpython-310.pyc,,
+antlr4/__pycache__/Utils.cpython-310.pyc,,
+antlr4/__pycache__/__init__.cpython-310.pyc,,
+antlr4/atn/ATN.py,sha256=LYE8kT-D8FpUd5fpOtyOLqvXLFkUSa83TVFowhCWAiY,5789
+antlr4/atn/ATNConfig.py,sha256=tNdIC6_GrxXllHBx3npAWyDh6KrohLZDV_XyPrydRMY,6565
+antlr4/atn/ATNConfigSet.py,sha256=qRzVsBeMqk2txjG3DrGptwF6Vb2hHC5w3umkSL0GNJw,8312
+antlr4/atn/ATNDeserializationOptions.py,sha256=lUV_bGW6mxj7t20esda5Yv-X9m-U_x1-0xaLifhXIPo,1010
+antlr4/atn/ATNDeserializer.py,sha256=aYLDDtQ-wyo3gId6A-wD1E3QmpfrPZlXxj4_IDm-mUY,22252
+antlr4/atn/ATNSimulator.py,sha256=mDc-G3GF3kSeqpfGDabUOLJ0WLVTqibxZlkvXQYmBRk,2298
+antlr4/atn/ATNState.py,sha256=NbndISWUwFDF_vuBfbTiZZ8GPHoQa6UXdqbD-yjJE7c,7663
+antlr4/atn/ATNType.py,sha256=xgv8AMVU7tc07U73_hRTm1AiZ7MvGhoaP5fTiOrrCGg,422
+antlr4/atn/LexerATNSimulator.py,sha256=kYXRwUvHptSRU8T_K9pSrGlCk9YypWeHlAcjgry1VVo,25465
+antlr4/atn/LexerAction.py,sha256=KUeJwKekBch0m1poSPskHIh-15dcKAG4lR7zlq98tzc,10014
+antlr4/atn/LexerActionExecutor.py,sha256=7rlg17THcwLsuTmh7NsLrTbRH4DTrm8qIdW9_235CEc,6420
+antlr4/atn/ParserATNSimulator.py,sha256=IKCzsDLcznROSVojU-daAygKr3svl0DmK5DhkUllASY,80365
+antlr4/atn/PredictionMode.py,sha256=i8B7MULA7v-qbXeCY_xp6sgi21kHM6kybqIrG6rSrro,22486
+antlr4/atn/SemanticContext.py,sha256=ds0TmM4qenb0LN-rl2Fp_N_xB959abN67I19EF6rs8o,10495
+antlr4/atn/Transition.py,sha256=ZAsEFpa5I_n-zxD6U-DauM5_33jFK65x3PWu6-NW0RA,8762
+antlr4/atn/__init__.py,sha256=gsnQdtTH8IUgCiVUpQfzhxx2pFRvksW76SjwIk3fYSk,28
+antlr4/atn/__pycache__/ATN.cpython-310.pyc,,
+antlr4/atn/__pycache__/ATNConfig.cpython-310.pyc,,
+antlr4/atn/__pycache__/ATNConfigSet.cpython-310.pyc,,
+antlr4/atn/__pycache__/ATNDeserializationOptions.cpython-310.pyc,,
+antlr4/atn/__pycache__/ATNDeserializer.cpython-310.pyc,,
+antlr4/atn/__pycache__/ATNSimulator.cpython-310.pyc,,
+antlr4/atn/__pycache__/ATNState.cpython-310.pyc,,
+antlr4/atn/__pycache__/ATNType.cpython-310.pyc,,
+antlr4/atn/__pycache__/LexerATNSimulator.cpython-310.pyc,,
+antlr4/atn/__pycache__/LexerAction.cpython-310.pyc,,
+antlr4/atn/__pycache__/LexerActionExecutor.cpython-310.pyc,,
+antlr4/atn/__pycache__/ParserATNSimulator.cpython-310.pyc,,
+antlr4/atn/__pycache__/PredictionMode.cpython-310.pyc,,
+antlr4/atn/__pycache__/SemanticContext.cpython-310.pyc,,
+antlr4/atn/__pycache__/Transition.cpython-310.pyc,,
+antlr4/atn/__pycache__/__init__.cpython-310.pyc,,
+antlr4/dfa/DFA.py,sha256=weIh0uaRfakP12mFvHo7U0tqO3GONV3-nHFkc2xk-ZE,5388
+antlr4/dfa/DFASerializer.py,sha256=1st_HO85yXLYy7gInTEnkztgA6am4CT-yReh-mazp9E,2518
+antlr4/dfa/DFAState.py,sha256=R7JwKf0GtAEs9J_MD_Y0WKcuzdt0BVX1sow-uv9yFYc,5583
+antlr4/dfa/__init__.py,sha256=gsnQdtTH8IUgCiVUpQfzhxx2pFRvksW76SjwIk3fYSk,28
+antlr4/dfa/__pycache__/DFA.cpython-310.pyc,,
+antlr4/dfa/__pycache__/DFASerializer.cpython-310.pyc,,
+antlr4/dfa/__pycache__/DFAState.cpython-310.pyc,,
+antlr4/dfa/__pycache__/__init__.cpython-310.pyc,,
+antlr4/error/DiagnosticErrorListener.py,sha256=EwS2D_Ox6CmvCa16NPJ9ud4QYPHmlPXt6-Wdn1h5Kg8,4430
+antlr4/error/ErrorListener.py,sha256=yP_MDguol4Cj0_pEPyNzeH3v4ZvUjW5iwDjhYTVAHbE,2722
+antlr4/error/ErrorStrategy.py,sha256=0mhzFL57ZVnjKkGrtadta93Zm3NXdF-HW10DVD07VXs,30391
+antlr4/error/Errors.py,sha256=hlKngclBfXdkDiAymhYsvh2OCXlvmHM2kTl_A1vgp-w,6759
+antlr4/error/__init__.py,sha256=gsnQdtTH8IUgCiVUpQfzhxx2pFRvksW76SjwIk3fYSk,28
+antlr4/error/__pycache__/DiagnosticErrorListener.cpython-310.pyc,,
+antlr4/error/__pycache__/ErrorListener.cpython-310.pyc,,
+antlr4/error/__pycache__/ErrorStrategy.cpython-310.pyc,,
+antlr4/error/__pycache__/Errors.cpython-310.pyc,,
+antlr4/error/__pycache__/__init__.cpython-310.pyc,,
+antlr4/tree/Chunk.py,sha256=oCIZjolLq9xkxtVDROEDxfUGgndcEnsDW0eUmLM7Gpk,695
+antlr4/tree/ParseTreeMatch.py,sha256=Dc6GVWSUqoIAFXUaUZqUwCUlZfTcgUbGLGzNf6QxQvE,4485
+antlr4/tree/ParseTreePattern.py,sha256=ASBNaQORh3f7f8KnFeZJC2yWFFx4uQlxvC2Y55ifhY0,2825
+antlr4/tree/ParseTreePatternMatcher.py,sha256=HtE9yi1Urr2QPLGLJDBvr0lxv6bjuj9CHl-4clahSe8,16388
+antlr4/tree/RuleTagToken.py,sha256=n4zXcmrrfsGyl91pj5ZYcc_CeKMhPrvYkUdppgMBpbY,2022
+antlr4/tree/TokenTagToken.py,sha256=S3o3DJhfzL5kpClxsKyI-Il-xvuuZQiBAIsLCKFjRHo,1576
+antlr4/tree/Tree.py,sha256=ZI7U_5IxBLm_IrnfJOtb12BCPIWyzfeZtLnhHKVVZIw,5572
+antlr4/tree/Trees.py,sha256=JtQ7cYWmKwI9TIBP6y9XIgjlNS4mYjv3ARwOfwWc5Vg,3968
+antlr4/tree/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+antlr4/tree/__pycache__/Chunk.cpython-310.pyc,,
+antlr4/tree/__pycache__/ParseTreeMatch.cpython-310.pyc,,
+antlr4/tree/__pycache__/ParseTreePattern.cpython-310.pyc,,
+antlr4/tree/__pycache__/ParseTreePatternMatcher.cpython-310.pyc,,
+antlr4/tree/__pycache__/RuleTagToken.cpython-310.pyc,,
+antlr4/tree/__pycache__/TokenTagToken.cpython-310.pyc,,
+antlr4/tree/__pycache__/Tree.cpython-310.pyc,,
+antlr4/tree/__pycache__/Trees.cpython-310.pyc,,
+antlr4/tree/__pycache__/__init__.cpython-310.pyc,,
+antlr4/xpath/XPath.py,sha256=O9s4-EDvLbAbYytP_bae9Z2khLl0iAtRzPAtVbuWUM4,13015
+antlr4/xpath/__init__.py,sha256=gsnQdtTH8IUgCiVUpQfzhxx2pFRvksW76SjwIk3fYSk,28
+antlr4/xpath/__pycache__/XPath.cpython-310.pyc,,
+antlr4/xpath/__pycache__/__init__.cpython-310.pyc,,
+antlr4_python3_runtime-4.9.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+antlr4_python3_runtime-4.9.3.dist-info/METADATA,sha256=vzJeUVUxg4Wi_MRoB0LacQu63xOj0cCXmpizSHmA8mE,403
+antlr4_python3_runtime-4.9.3.dist-info/RECORD,,
+antlr4_python3_runtime-4.9.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+antlr4_python3_runtime-4.9.3.dist-info/top_level.txt,sha256=OsoZsh9bb30wgXb2zBUjdDwYg46MfV-RVZA6Pk8pcB0,7

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4_python3_runtime-4.9.3.dist-info/WHEEL

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

miniconda3/envs/active_proaction/lib/python3.10/site-packages/antlr4_python3_runtime-4.9.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+antlr4

miniconda3/envs/active_proaction/lib/python3.10/site-packages/anyio-4.12.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

miniconda3/envs/active_proaction/lib/python3.10/site-packages/anyio-4.12.1.dist-info/METADATA

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: anyio
+Version: 4.12.1
+Summary: High-level concurrency and networking framework on top of asyncio or Trio
+Author-email: Alex Grönholm <alex.gronholm@nextday.fi>
+License-Expression: MIT
+Project-URL: Documentation, https://anyio.readthedocs.io/en/latest/
+Project-URL: Changelog, https://anyio.readthedocs.io/en/stable/versionhistory.html
+Project-URL: Source code, https://github.com/agronholm/anyio
+Project-URL: Issue tracker, https://github.com/agronholm/anyio/issues
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Framework :: AnyIO
+Classifier: Typing :: Typed
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: exceptiongroup>=1.0.2; python_version < "3.11"
+Requires-Dist: idna>=2.8
+Requires-Dist: typing_extensions>=4.5; python_version < "3.13"
+Provides-Extra: trio
+Requires-Dist: trio>=0.32.0; python_version >= "3.10" and extra == "trio"
+Requires-Dist: trio>=0.31.0; python_version < "3.10" and extra == "trio"
+Dynamic: license-file
+
+.. image:: https://github.com/agronholm/anyio/actions/workflows/test.yml/badge.svg
+  :target: https://github.com/agronholm/anyio/actions/workflows/test.yml
+  :alt: Build Status
+.. image:: https://coveralls.io/repos/github/agronholm/anyio/badge.svg?branch=master
+  :target: https://coveralls.io/github/agronholm/anyio?branch=master
+  :alt: Code Coverage
+.. image:: https://readthedocs.org/projects/anyio/badge/?version=latest
+  :target: https://anyio.readthedocs.io/en/latest/?badge=latest
+  :alt: Documentation
+.. image:: https://badges.gitter.im/gitterHQ/gitter.svg
+  :target: https://gitter.im/python-trio/AnyIO
+  :alt: Gitter chat
+
+AnyIO is an asynchronous networking and concurrency library that works on top of either asyncio_ or
+Trio_. It implements Trio-like `structured concurrency`_ (SC) on top of asyncio and works in harmony
+with the native SC of Trio itself.
+
+Applications and libraries written against AnyIO's API will run unmodified on either asyncio_ or
+Trio_. AnyIO can also be adopted into a library or application incrementally – bit by bit, no full
+refactoring necessary. It will blend in with the native libraries of your chosen backend.
+
+To find out why you might want to use AnyIO's APIs instead of asyncio's, you can read about it
+`here <https://anyio.readthedocs.io/en/stable/why.html>`_.
+
+Documentation
+-------------
+
+View full documentation at: https://anyio.readthedocs.io/
+
+Features
+--------
+
+AnyIO offers the following functionality:
+
+* Task groups (nurseries_ in trio terminology)
+* High-level networking (TCP, UDP and UNIX sockets)
+
+  * `Happy eyeballs`_ algorithm for TCP connections (more robust than that of asyncio on Python
+    3.8)
+  * async/await style UDP sockets (unlike asyncio where you still have to use Transports and
+    Protocols)
+
+* A versatile API for byte streams and object streams
+* Inter-task synchronization and communication (locks, conditions, events, semaphores, object
+  streams)
+* Worker threads
+* Subprocesses
+* Subinterpreter support for code parallelization (on Python 3.13 and later)
+* Asynchronous file I/O (using worker threads)
+* Signal handling
+* Asynchronous version of the functools_ module
+
+AnyIO also comes with its own pytest_ plugin which also supports asynchronous fixtures.
+It even works with the popular Hypothesis_ library.
+
+.. _asyncio: https://docs.python.org/3/library/asyncio.html
+.. _Trio: https://github.com/python-trio/trio
+.. _structured concurrency: https://en.wikipedia.org/wiki/Structured_concurrency
+.. _nurseries: https://trio.readthedocs.io/en/stable/reference-core.html#nurseries-and-spawning
+.. _Happy eyeballs: https://en.wikipedia.org/wiki/Happy_Eyeballs
+.. _pytest: https://docs.pytest.org/en/latest/
+.. _functools: https://docs.python.org/3/library/functools.html
+.. _Hypothesis: https://hypothesis.works/

miniconda3/envs/active_proaction/lib/python3.10/site-packages/anyio-4.12.1.dist-info/RECORD

@@ -0,0 +1,92 @@
+anyio-4.12.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+anyio-4.12.1.dist-info/METADATA,sha256=DfiDab9Tmmcfy802lOLTMEHJQShkOSbopCwqCYbLuJk,4277
+anyio-4.12.1.dist-info/RECORD,,
+anyio-4.12.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+anyio-4.12.1.dist-info/entry_points.txt,sha256=_d6Yu6uiaZmNe0CydowirE9Cmg7zUL2g08tQpoS3Qvc,39
+anyio-4.12.1.dist-info/licenses/LICENSE,sha256=U2GsncWPLvX9LpsJxoKXwX8ElQkJu8gCO9uC6s8iwrA,1081
+anyio-4.12.1.dist-info/top_level.txt,sha256=QglSMiWX8_5dpoVAEIHdEYzvqFMdSYWmCj6tYw2ITkQ,6
+anyio/__init__.py,sha256=7iDVqMUprUuKNY91FuoKqayAhR-OY136YDPI6P78HHk,6170
+anyio/__pycache__/__init__.cpython-310.pyc,,
+anyio/__pycache__/from_thread.cpython-310.pyc,,
+anyio/__pycache__/functools.cpython-310.pyc,,
+anyio/__pycache__/lowlevel.cpython-310.pyc,,
+anyio/__pycache__/pytest_plugin.cpython-310.pyc,,
+anyio/__pycache__/to_interpreter.cpython-310.pyc,,
+anyio/__pycache__/to_process.cpython-310.pyc,,
+anyio/__pycache__/to_thread.cpython-310.pyc,,
+anyio/_backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/_backends/__pycache__/__init__.cpython-310.pyc,,
+anyio/_backends/__pycache__/_asyncio.cpython-310.pyc,,
+anyio/_backends/__pycache__/_trio.cpython-310.pyc,,
+anyio/_backends/_asyncio.py,sha256=xG6qv60mgGnL0mK82dxjH2b8hlkMlJ-x2BqIq3qv70Y,98863
+anyio/_backends/_trio.py,sha256=30Rctb7lm8g63ZHljVPVnj5aH-uK6oQvphjwUBoAzuI,41456
+anyio/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/_core/__pycache__/__init__.cpython-310.pyc,,
+anyio/_core/__pycache__/_asyncio_selector_thread.cpython-310.pyc,,
+anyio/_core/__pycache__/_contextmanagers.cpython-310.pyc,,
+anyio/_core/__pycache__/_eventloop.cpython-310.pyc,,
+anyio/_core/__pycache__/_exceptions.cpython-310.pyc,,
+anyio/_core/__pycache__/_fileio.cpython-310.pyc,,
+anyio/_core/__pycache__/_resources.cpython-310.pyc,,
+anyio/_core/__pycache__/_signals.cpython-310.pyc,,
+anyio/_core/__pycache__/_sockets.cpython-310.pyc,,
+anyio/_core/__pycache__/_streams.cpython-310.pyc,,
+anyio/_core/__pycache__/_subprocesses.cpython-310.pyc,,
+anyio/_core/__pycache__/_synchronization.cpython-310.pyc,,
+anyio/_core/__pycache__/_tasks.cpython-310.pyc,,
+anyio/_core/__pycache__/_tempfile.cpython-310.pyc,,
+anyio/_core/__pycache__/_testing.cpython-310.pyc,,
+anyio/_core/__pycache__/_typedattr.cpython-310.pyc,,
+anyio/_core/_asyncio_selector_thread.py,sha256=2PdxFM3cs02Kp6BSppbvmRT7q7asreTW5FgBxEsflBo,5626
+anyio/_core/_contextmanagers.py,sha256=YInBCabiEeS-UaP_Jdxa1CaFC71ETPW8HZTHIM8Rsc8,7215
+anyio/_core/_eventloop.py,sha256=c2EdcBX-xnKwxPcC4Pjn3_qG9I-x4IWFO2R9RqCGjM4,6448
+anyio/_core/_exceptions.py,sha256=Y3aq-Wxd7Q2HqwSg7nZPvRsHEuGazv_qeet6gqEBdPk,4407
+anyio/_core/_fileio.py,sha256=uc7t10Vb-If7GbdWM_zFf-ajUe6uek63fSt7IBLlZW0,25731
+anyio/_core/_resources.py,sha256=NbmU5O5UX3xEyACnkmYX28Fmwdl-f-ny0tHym26e0w0,435
+anyio/_core/_signals.py,sha256=mjTBB2hTKNPRlU0IhnijeQedpWOGERDiMjSlJQsFrug,1016
+anyio/_core/_sockets.py,sha256=RBXHcUqZt5gg_-OOfgHVv8uq2FSKk1uVUzTdpjBoI1o,34977
+anyio/_core/_streams.py,sha256=FczFwIgDpnkK0bODWJXMpsUJYdvAD04kaUaGzJU8DK0,1806
+anyio/_core/_subprocesses.py,sha256=EXm5igL7dj55iYkPlbYVAqtbqxJxjU-6OndSTIx9SRg,8047
+anyio/_core/_synchronization.py,sha256=MgVVqFzvt580tHC31LiOcq1G6aryut--xRG4Ff8KwxQ,20869
+anyio/_core/_tasks.py,sha256=pVB7K6AAulzUM8YgXAeqNZG44nSyZ1bYJjH8GznC00I,5435
+anyio/_core/_tempfile.py,sha256=lHb7CW4FyIlpkf5ADAf4VmLHCKwEHF9nxqNyBCFFUiA,19697
+anyio/_core/_testing.py,sha256=u7MPqGXwpTxqI7hclSdNA30z2GH1Nw258uwKvy_RfBg,2340
+anyio/_core/_typedattr.py,sha256=P4ozZikn3-DbpoYcvyghS_FOYAgbmUxeoU8-L_07pZM,2508
+anyio/abc/__init__.py,sha256=6mWhcl_pGXhrgZVHP_TCfMvIXIOp9mroEFM90fYCU_U,2869
+anyio/abc/__pycache__/__init__.cpython-310.pyc,,
+anyio/abc/__pycache__/_eventloop.cpython-310.pyc,,
+anyio/abc/__pycache__/_resources.cpython-310.pyc,,
+anyio/abc/__pycache__/_sockets.cpython-310.pyc,,
+anyio/abc/__pycache__/_streams.cpython-310.pyc,,
+anyio/abc/__pycache__/_subprocesses.cpython-310.pyc,,
+anyio/abc/__pycache__/_tasks.cpython-310.pyc,,
+anyio/abc/__pycache__/_testing.cpython-310.pyc,,
+anyio/abc/_eventloop.py,sha256=GlzgB3UJGgG6Kr7olpjOZ-o00PghecXuofVDQ_5611Q,10749
+anyio/abc/_resources.py,sha256=DrYvkNN1hH6Uvv5_5uKySvDsnknGVDe8FCKfko0VtN8,783
+anyio/abc/_sockets.py,sha256=ECTY0jLEF18gryANHR3vFzXzGdZ-xPwELq1QdgOb0Jo,13258
+anyio/abc/_streams.py,sha256=005GKSCXGprxnhucILboSqc2JFovECZk9m3p-qqxXVc,7640
+anyio/abc/_subprocesses.py,sha256=cumAPJTktOQtw63IqG0lDpyZqu_l1EElvQHMiwJgL08,2067
+anyio/abc/_tasks.py,sha256=KC7wrciE48AINOI-AhPutnFhe1ewfP7QnamFlDzqesQ,3721
+anyio/abc/_testing.py,sha256=tBJUzkSfOXJw23fe8qSJ03kJlShOYjjaEyFB6k6MYT8,1821
+anyio/from_thread.py,sha256=L-0w1HxJ6BSb-KuVi57k5Tkc3yzQrx3QK5tAxMPcY-0,19141
+anyio/functools.py,sha256=HWj7GBEmc0Z-mZg3uok7Z7ZJn0rEC_0Pzbt0nYUDaTQ,10973
+anyio/lowlevel.py,sha256=AyKLVK3LaWSoK39LkCKxE4_GDMLKZBNqTrLUgk63y80,5158
+anyio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/pytest_plugin.py,sha256=3jAFQn0jv_pyoWE2GBBlHaj9sqXj4e8vob0_hgrsXE8,10244
+anyio/streams/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/streams/__pycache__/__init__.cpython-310.pyc,,
+anyio/streams/__pycache__/buffered.cpython-310.pyc,,
+anyio/streams/__pycache__/file.cpython-310.pyc,,
+anyio/streams/__pycache__/memory.cpython-310.pyc,,
+anyio/streams/__pycache__/stapled.cpython-310.pyc,,
+anyio/streams/__pycache__/text.cpython-310.pyc,,
+anyio/streams/__pycache__/tls.cpython-310.pyc,,
+anyio/streams/buffered.py,sha256=2R3PeJhe4EXrdYqz44Y6-Eg9R6DrmlsYrP36Ir43-po,6263
+anyio/streams/file.py,sha256=4WZ7XGz5WNu39FQHvqbe__TQ0HDP9OOhgO1mk9iVpVU,4470
+anyio/streams/memory.py,sha256=F0zwzvFJKAhX_LRZGoKzzqDC2oMM-f-yyTBrEYEGOaU,10740
+anyio/streams/stapled.py,sha256=T8Xqwf8K6EgURPxbt1N4i7A8BAk-gScv-GRhjLXIf_o,4390
+anyio/streams/text.py,sha256=BcVAGJw1VRvtIqnv-o0Rb0pwH7p8vwlvl21xHq522ag,5765
+anyio/streams/tls.py,sha256=Jpxy0Mfbcp1BxHCwE-YjSSFaLnIBbnnwur-excYThs4,15368
+anyio/to_interpreter.py,sha256=_mLngrMy97TMR6VbW4Y6YzDUk9ZuPcQMPlkuyRh3C9k,7100
+anyio/to_process.py,sha256=J7gAA_YOuoHqnpDAf5fm1Qu6kOmTzdFbiDNvnV755vk,9798
+anyio/to_thread.py,sha256=menEgXYmUV7Fjg_9WqCV95P9MAtQS8BzPGGcWB_QnfQ,2687

miniconda3/envs/active_proaction/lib/python3.10/site-packages/anyio-4.12.1.dist-info/WHEEL

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

miniconda3/envs/active_proaction/lib/python3.10/site-packages/anyio-4.12.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+anyio = anyio.pytest_plugin

miniconda3/envs/active_proaction/lib/python3.10/site-packages/anyio-4.12.1.dist-info/licenses/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Alex Grönholm
+
+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.

miniconda3/envs/active_proaction/lib/python3.10/site-packages/anyio-4.12.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+anyio

miniconda3/envs/active_proaction/lib/python3.10/site-packages/anyio/__init__.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from ._core._contextmanagers import AsyncContextManagerMixin as AsyncContextManagerMixin
+from ._core._contextmanagers import ContextManagerMixin as ContextManagerMixin
+from ._core._eventloop import current_time as current_time
+from ._core._eventloop import get_all_backends as get_all_backends
+from ._core._eventloop import get_available_backends as get_available_backends
+from ._core._eventloop import get_cancelled_exc_class as get_cancelled_exc_class
+from ._core._eventloop import run as run
+from ._core._eventloop import sleep as sleep
+from ._core._eventloop import sleep_forever as sleep_forever
+from ._core._eventloop import sleep_until as sleep_until
+from ._core._exceptions import BrokenResourceError as BrokenResourceError
+from ._core._exceptions import BrokenWorkerInterpreter as BrokenWorkerInterpreter
+from ._core._exceptions import BrokenWorkerProcess as BrokenWorkerProcess
+from ._core._exceptions import BusyResourceError as BusyResourceError
+from ._core._exceptions import ClosedResourceError as ClosedResourceError
+from ._core._exceptions import ConnectionFailed as ConnectionFailed
+from ._core._exceptions import DelimiterNotFound as DelimiterNotFound
+from ._core._exceptions import EndOfStream as EndOfStream
+from ._core._exceptions import IncompleteRead as IncompleteRead
+from ._core._exceptions import NoEventLoopError as NoEventLoopError
+from ._core._exceptions import RunFinishedError as RunFinishedError
+from ._core._exceptions import TypedAttributeLookupError as TypedAttributeLookupError
+from ._core._exceptions import WouldBlock as WouldBlock
+from ._core._fileio import AsyncFile as AsyncFile
+from ._core._fileio import Path as Path
+from ._core._fileio import open_file as open_file
+from ._core._fileio import wrap_file as wrap_file
+from ._core._resources import aclose_forcefully as aclose_forcefully
+from ._core._signals import open_signal_receiver as open_signal_receiver
+from ._core._sockets import TCPConnectable as TCPConnectable
+from ._core._sockets import UNIXConnectable as UNIXConnectable
+from ._core._sockets import as_connectable as as_connectable
+from ._core._sockets import connect_tcp as connect_tcp
+from ._core._sockets import connect_unix as connect_unix
+from ._core._sockets import create_connected_udp_socket as create_connected_udp_socket
+from ._core._sockets import (
+    create_connected_unix_datagram_socket as create_connected_unix_datagram_socket,
+)
+from ._core._sockets import create_tcp_listener as create_tcp_listener
+from ._core._sockets import create_udp_socket as create_udp_socket
+from ._core._sockets import create_unix_datagram_socket as create_unix_datagram_socket
+from ._core._sockets import create_unix_listener as create_unix_listener
+from ._core._sockets import getaddrinfo as getaddrinfo
+from ._core._sockets import getnameinfo as getnameinfo
+from ._core._sockets import notify_closing as notify_closing
+from ._core._sockets import wait_readable as wait_readable
+from ._core._sockets import wait_socket_readable as wait_socket_readable
+from ._core._sockets import wait_socket_writable as wait_socket_writable
+from ._core._sockets import wait_writable as wait_writable
+from ._core._streams import create_memory_object_stream as create_memory_object_stream
+from ._core._subprocesses import open_process as open_process
+from ._core._subprocesses import run_process as run_process
+from ._core._synchronization import CapacityLimiter as CapacityLimiter
+from ._core._synchronization import (
+    CapacityLimiterStatistics as CapacityLimiterStatistics,
+)
+from ._core._synchronization import Condition as Condition
+from ._core._synchronization import ConditionStatistics as ConditionStatistics
+from ._core._synchronization import Event as Event
+from ._core._synchronization import EventStatistics as EventStatistics
+from ._core._synchronization import Lock as Lock
+from ._core._synchronization import LockStatistics as LockStatistics
+from ._core._synchronization import ResourceGuard as ResourceGuard
+from ._core._synchronization import Semaphore as Semaphore
+from ._core._synchronization import SemaphoreStatistics as SemaphoreStatistics
+from ._core._tasks import TASK_STATUS_IGNORED as TASK_STATUS_IGNORED
+from ._core._tasks import CancelScope as CancelScope
+from ._core._tasks import create_task_group as create_task_group
+from ._core._tasks import current_effective_deadline as current_effective_deadline
+from ._core._tasks import fail_after as fail_after
+from ._core._tasks import move_on_after as move_on_after
+from ._core._tempfile import NamedTemporaryFile as NamedTemporaryFile
+from ._core._tempfile import SpooledTemporaryFile as SpooledTemporaryFile
+from ._core._tempfile import TemporaryDirectory as TemporaryDirectory
+from ._core._tempfile import TemporaryFile as TemporaryFile
+from ._core._tempfile import gettempdir as gettempdir
+from ._core._tempfile import gettempdirb as gettempdirb
+from ._core._tempfile import mkdtemp as mkdtemp
+from ._core._tempfile import mkstemp as mkstemp
+from ._core._testing import TaskInfo as TaskInfo
+from ._core._testing import get_current_task as get_current_task
+from ._core._testing import get_running_tasks as get_running_tasks
+from ._core._testing import wait_all_tasks_blocked as wait_all_tasks_blocked
+from ._core._typedattr import TypedAttributeProvider as TypedAttributeProvider
+from ._core._typedattr import TypedAttributeSet as TypedAttributeSet
+from ._core._typedattr import typed_attribute as typed_attribute
+
+# Re-export imports so they look like they live directly in this package
+for __value in list(locals().values()):
+    if getattr(__value, "__module__", "").startswith("anyio."):
+        __value.__module__ = __name__
+
+
+del __value
+
+
+def __getattr__(attr: str) -> type[BrokenWorkerInterpreter]:
+    """Support deprecated aliases."""
+    if attr == "BrokenWorkerIntepreter":
+        import warnings
+
+        warnings.warn(
+            "The 'BrokenWorkerIntepreter' alias is deprecated, use 'BrokenWorkerInterpreter' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return BrokenWorkerInterpreter
+
+    raise AttributeError(f"module {__name__!r} has no attribute {attr!r}")

miniconda3/envs/active_proaction/lib/python3.10/site-packages/anyio/_backends/_trio.py

@@ -0,0 +1,1346 @@
+from __future__ import annotations
+
+import array
+import math
+import os
+import socket
+import sys
+import types
+import weakref
+from collections.abc import (
+    AsyncGenerator,
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Collection,
+    Coroutine,
+    Iterable,
+    Sequence,
+)
+from contextlib import AbstractContextManager
+from dataclasses import dataclass
+from io import IOBase
+from os import PathLike
+from signal import Signals
+from socket import AddressFamily, SocketKind
+from types import TracebackType
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    Generic,
+    NoReturn,
+    TypeVar,
+    cast,
+    overload,
+)
+
+import trio.from_thread
+import trio.lowlevel
+from outcome import Error, Outcome, Value
+from trio.lowlevel import (
+    current_root_task,
+    current_task,
+    notify_closing,
+    wait_readable,
+    wait_writable,
+)
+from trio.socket import SocketType as TrioSocketType
+from trio.to_thread import run_sync
+
+from .. import (
+    CapacityLimiterStatistics,
+    EventStatistics,
+    LockStatistics,
+    RunFinishedError,
+    TaskInfo,
+    WouldBlock,
+    abc,
+)
+from .._core._eventloop import claim_worker_thread
+from .._core._exceptions import (
+    BrokenResourceError,
+    BusyResourceError,
+    ClosedResourceError,
+    EndOfStream,
+)
+from .._core._sockets import convert_ipv6_sockaddr
+from .._core._streams import create_memory_object_stream
+from .._core._synchronization import (
+    CapacityLimiter as BaseCapacityLimiter,
+)
+from .._core._synchronization import Event as BaseEvent
+from .._core._synchronization import Lock as BaseLock
+from .._core._synchronization import (
+    ResourceGuard,
+    SemaphoreStatistics,
+)
+from .._core._synchronization import Semaphore as BaseSemaphore
+from .._core._tasks import CancelScope as BaseCancelScope
+from ..abc import IPSockAddrType, UDPPacketType, UNIXDatagramPacketType
+from ..abc._eventloop import AsyncBackend, StrOrBytesPath
+from ..streams.memory import MemoryObjectSendStream
+
+if TYPE_CHECKING:
+    from _typeshed import FileDescriptorLike
+
+if sys.version_info >= (3, 10):
+    from typing import ParamSpec
+else:
+    from typing_extensions import ParamSpec
+
+if sys.version_info >= (3, 11):
+    from typing import TypeVarTuple, Unpack
+else:
+    from exceptiongroup import BaseExceptionGroup
+    from typing_extensions import TypeVarTuple, Unpack
+
+T = TypeVar("T")
+T_Retval = TypeVar("T_Retval")
+T_SockAddr = TypeVar("T_SockAddr", str, IPSockAddrType)
+PosArgsT = TypeVarTuple("PosArgsT")
+P = ParamSpec("P")
+
+
+#
+# Event loop
+#
+
+RunVar = trio.lowlevel.RunVar
+
+
+#
+# Timeouts and cancellation
+#
+
+
+class CancelScope(BaseCancelScope):
+    def __new__(
+        cls, original: trio.CancelScope | None = None, **kwargs: object
+    ) -> CancelScope:
+        return object.__new__(cls)
+
+    def __init__(self, original: trio.CancelScope | None = None, **kwargs: Any) -> None:
+        self.__original = original or trio.CancelScope(**kwargs)
+
+    def __enter__(self) -> CancelScope:
+        self.__original.__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool:
+        return self.__original.__exit__(exc_type, exc_val, exc_tb)
+
+    def cancel(self, reason: str | None = None) -> None:
+        self.__original.cancel(reason)
+
+    @property
+    def deadline(self) -> float:
+        return self.__original.deadline
+
+    @deadline.setter
+    def deadline(self, value: float) -> None:
+        self.__original.deadline = value
+
+    @property
+    def cancel_called(self) -> bool:
+        return self.__original.cancel_called
+
+    @property
+    def cancelled_caught(self) -> bool:
+        return self.__original.cancelled_caught
+
+    @property
+    def shield(self) -> bool:
+        return self.__original.shield
+
+    @shield.setter
+    def shield(self, value: bool) -> None:
+        self.__original.shield = value
+
+
+#
+# Task groups
+#
+
+
+class TaskGroup(abc.TaskGroup):
+    def __init__(self) -> None:
+        self._active = False
+        self._nursery_manager = trio.open_nursery(strict_exception_groups=True)
+        self.cancel_scope = None  # type: ignore[assignment]
+
+    async def __aenter__(self) -> TaskGroup:
+        self._active = True
+        self._nursery = await self._nursery_manager.__aenter__()
+        self.cancel_scope = CancelScope(self._nursery.cancel_scope)
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool:
+        try:
+            # trio.Nursery.__exit__ returns bool; .open_nursery has wrong type
+            return await self._nursery_manager.__aexit__(exc_type, exc_val, exc_tb)  # type: ignore[return-value]
+        except BaseExceptionGroup as exc:
+            if not exc.split(trio.Cancelled)[1]:
+                raise trio.Cancelled._create() from exc
+
+            raise
+        finally:
+            del exc_val, exc_tb
+            self._active = False
+
+    def start_soon(
+        self,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[Any]],
+        *args: Unpack[PosArgsT],
+        name: object = None,
+    ) -> None:
+        if not self._active:
+            raise RuntimeError(
+                "This task group is not active; no new tasks can be started."
+            )
+
+        self._nursery.start_soon(func, *args, name=name)
+
+    async def start(
+        self, func: Callable[..., Awaitable[Any]], *args: object, name: object = None
+    ) -> Any:
+        if not self._active:
+            raise RuntimeError(
+                "This task group is not active; no new tasks can be started."
+            )
+
+        return await self._nursery.start(func, *args, name=name)
+
+
+#
+# Subprocesses
+#
+
+
+@dataclass(eq=False)
+class ReceiveStreamWrapper(abc.ByteReceiveStream):
+    _stream: trio.abc.ReceiveStream
+
+    async def receive(self, max_bytes: int | None = None) -> bytes:
+        try:
+            data = await self._stream.receive_some(max_bytes)
+        except trio.ClosedResourceError as exc:
+            raise ClosedResourceError from exc.__cause__
+        except trio.BrokenResourceError as exc:
+            raise BrokenResourceError from exc.__cause__
+
+        if data:
+            return bytes(data)
+        else:
+            raise EndOfStream
+
+    async def aclose(self) -> None:
+        await self._stream.aclose()
+
+
+@dataclass(eq=False)
+class SendStreamWrapper(abc.ByteSendStream):
+    _stream: trio.abc.SendStream
+
+    async def send(self, item: bytes) -> None:
+        try:
+            await self._stream.send_all(item)
+        except trio.ClosedResourceError as exc:
+            raise ClosedResourceError from exc.__cause__
+        except trio.BrokenResourceError as exc:
+            raise BrokenResourceError from exc.__cause__
+
+    async def aclose(self) -> None:
+        await self._stream.aclose()
+
+
+@dataclass(eq=False)
+class Process(abc.Process):
+    _process: trio.Process
+    _stdin: abc.ByteSendStream | None
+    _stdout: abc.ByteReceiveStream | None
+    _stderr: abc.ByteReceiveStream | None
+
+    async def aclose(self) -> None:
+        with CancelScope(shield=True):
+            if self._stdin:
+                await self._stdin.aclose()
+            if self._stdout:
+                await self._stdout.aclose()
+            if self._stderr:
+                await self._stderr.aclose()
+
+        try:
+            await self.wait()
+        except BaseException:
+            self.kill()
+            with CancelScope(shield=True):
+                await self.wait()
+            raise
+
+    async def wait(self) -> int:
+        return await self._process.wait()
+
+    def terminate(self) -> None:
+        self._process.terminate()
+
+    def kill(self) -> None:
+        self._process.kill()
+
+    def send_signal(self, signal: Signals) -> None:
+        self._process.send_signal(signal)
+
+    @property
+    def pid(self) -> int:
+        return self._process.pid
+
+    @property
+    def returncode(self) -> int | None:
+        return self._process.returncode
+
+    @property
+    def stdin(self) -> abc.ByteSendStream | None:
+        return self._stdin
+
+    @property
+    def stdout(self) -> abc.ByteReceiveStream | None:
+        return self._stdout
+
+    @property
+    def stderr(self) -> abc.ByteReceiveStream | None:
+        return self._stderr
+
+
+class _ProcessPoolShutdownInstrument(trio.abc.Instrument):
+    def after_run(self) -> None:
+        super().after_run()
+
+
+current_default_worker_process_limiter: trio.lowlevel.RunVar = RunVar(
+    "current_default_worker_process_limiter"
+)
+
+
+async def _shutdown_process_pool(workers: set[abc.Process]) -> None:
+    try:
+        await trio.sleep(math.inf)
+    except trio.Cancelled:
+        for process in workers:
+            if process.returncode is None:
+                process.kill()
+
+        with CancelScope(shield=True):
+            for process in workers:
+                await process.aclose()
+
+
+#
+# Sockets and networking
+#
+
+
+class _TrioSocketMixin(Generic[T_SockAddr]):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        self._trio_socket = trio_socket
+        self._closed = False
+
+    def _check_closed(self) -> None:
+        if self._closed:
+            raise ClosedResourceError
+        if self._trio_socket.fileno() < 0:
+            raise BrokenResourceError
+
+    @property
+    def _raw_socket(self) -> socket.socket:
+        return self._trio_socket._sock  # type: ignore[attr-defined]
+
+    async def aclose(self) -> None:
+        if self._trio_socket.fileno() >= 0:
+            self._closed = True
+            self._trio_socket.close()
+
+    def _convert_socket_error(self, exc: BaseException) -> NoReturn:
+        if isinstance(exc, trio.ClosedResourceError):
+            raise ClosedResourceError from exc
+        elif self._trio_socket.fileno() < 0 and self._closed:
+            raise ClosedResourceError from None
+        elif isinstance(exc, OSError):
+            raise BrokenResourceError from exc
+        else:
+            raise exc
+
+
+class SocketStream(_TrioSocketMixin, abc.SocketStream):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        super().__init__(trio_socket)
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+
+    async def receive(self, max_bytes: int = 65536) -> bytes:
+        with self._receive_guard:
+            try:
+                data = await self._trio_socket.recv(max_bytes)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+            if data:
+                return data
+            else:
+                raise EndOfStream
+
+    async def send(self, item: bytes) -> None:
+        with self._send_guard:
+            view = memoryview(item)
+            while view:
+                try:
+                    bytes_sent = await self._trio_socket.send(view)
+                except BaseException as exc:
+                    self._convert_socket_error(exc)
+
+                view = view[bytes_sent:]
+
+    async def send_eof(self) -> None:
+        self._trio_socket.shutdown(socket.SHUT_WR)
+
+
+class UNIXSocketStream(SocketStream, abc.UNIXSocketStream):
+    async def receive_fds(self, msglen: int, maxfds: int) -> tuple[bytes, list[int]]:
+        if not isinstance(msglen, int) or msglen < 0:
+            raise ValueError("msglen must be a non-negative integer")
+        if not isinstance(maxfds, int) or maxfds < 1:
+            raise ValueError("maxfds must be a positive integer")
+
+        fds = array.array("i")
+        await trio.lowlevel.checkpoint()
+        with self._receive_guard:
+            while True:
+                try:
+                    message, ancdata, flags, addr = await self._trio_socket.recvmsg(
+                        msglen, socket.CMSG_LEN(maxfds * fds.itemsize)
+                    )
+                except BaseException as exc:
+                    self._convert_socket_error(exc)
+                else:
+                    if not message and not ancdata:
+                        raise EndOfStream
+
+                    break
+
+        for cmsg_level, cmsg_type, cmsg_data in ancdata:
+            if cmsg_level != socket.SOL_SOCKET or cmsg_type != socket.SCM_RIGHTS:
+                raise RuntimeError(
+                    f"Received unexpected ancillary data; message = {message!r}, "
+                    f"cmsg_level = {cmsg_level}, cmsg_type = {cmsg_type}"
+                )
+
+            fds.frombytes(cmsg_data[: len(cmsg_data) - (len(cmsg_data) % fds.itemsize)])
+
+        return message, list(fds)
+
+    async def send_fds(self, message: bytes, fds: Collection[int | IOBase]) -> None:
+        if not message:
+            raise ValueError("message must not be empty")
+        if not fds:
+            raise ValueError("fds must not be empty")
+
+        filenos: list[int] = []
+        for fd in fds:
+            if isinstance(fd, int):
+                filenos.append(fd)
+            elif isinstance(fd, IOBase):
+                filenos.append(fd.fileno())
+
+        fdarray = array.array("i", filenos)
+        await trio.lowlevel.checkpoint()
+        with self._send_guard:
+            while True:
+                try:
+                    await self._trio_socket.sendmsg(
+                        [message],
+                        [
+                            (
+                                socket.SOL_SOCKET,
+                                socket.SCM_RIGHTS,
+                                fdarray,
+                            )
+                        ],
+                    )
+                    break
+                except BaseException as exc:
+                    self._convert_socket_error(exc)
+
+
+class TCPSocketListener(_TrioSocketMixin, abc.SocketListener):
+    def __init__(self, raw_socket: socket.socket):
+        super().__init__(trio.socket.from_stdlib_socket(raw_socket))
+        self._accept_guard = ResourceGuard("accepting connections from")
+
+    async def accept(self) -> SocketStream:
+        with self._accept_guard:
+            try:
+                trio_socket, _addr = await self._trio_socket.accept()
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+        trio_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        return SocketStream(trio_socket)
+
+
+class UNIXSocketListener(_TrioSocketMixin, abc.SocketListener):
+    def __init__(self, raw_socket: socket.socket):
+        super().__init__(trio.socket.from_stdlib_socket(raw_socket))
+        self._accept_guard = ResourceGuard("accepting connections from")
+
+    async def accept(self) -> UNIXSocketStream:
+        with self._accept_guard:
+            try:
+                trio_socket, _addr = await self._trio_socket.accept()
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+        return UNIXSocketStream(trio_socket)
+
+
+class UDPSocket(_TrioSocketMixin[IPSockAddrType], abc.UDPSocket):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        super().__init__(trio_socket)
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+
+    async def receive(self) -> tuple[bytes, IPSockAddrType]:
+        with self._receive_guard:
+            try:
+                data, addr = await self._trio_socket.recvfrom(65536)
+                return data, convert_ipv6_sockaddr(addr)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+    async def send(self, item: UDPPacketType) -> None:
+        with self._send_guard:
+            try:
+                await self._trio_socket.sendto(*item)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+
+class ConnectedUDPSocket(_TrioSocketMixin[IPSockAddrType], abc.ConnectedUDPSocket):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        super().__init__(trio_socket)
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+
+    async def receive(self) -> bytes:
+        with self._receive_guard:
+            try:
+                return await self._trio_socket.recv(65536)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+    async def send(self, item: bytes) -> None:
+        with self._send_guard:
+            try:
+                await self._trio_socket.send(item)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+
+class UNIXDatagramSocket(_TrioSocketMixin[str], abc.UNIXDatagramSocket):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        super().__init__(trio_socket)
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+
+    async def receive(self) -> UNIXDatagramPacketType:
+        with self._receive_guard:
+            try:
+                data, addr = await self._trio_socket.recvfrom(65536)
+                return data, addr
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+    async def send(self, item: UNIXDatagramPacketType) -> None:
+        with self._send_guard:
+            try:
+                await self._trio_socket.sendto(*item)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+
+class ConnectedUNIXDatagramSocket(
+    _TrioSocketMixin[str], abc.ConnectedUNIXDatagramSocket
+):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        super().__init__(trio_socket)
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+
+    async def receive(self) -> bytes:
+        with self._receive_guard:
+            try:
+                return await self._trio_socket.recv(65536)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+    async def send(self, item: bytes) -> None:
+        with self._send_guard:
+            try:
+                await self._trio_socket.send(item)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+
+#
+# Synchronization
+#
+
+
+class Event(BaseEvent):
+    def __new__(cls) -> Event:
+        return object.__new__(cls)
+
+    def __init__(self) -> None:
+        self.__original = trio.Event()
+
+    def is_set(self) -> bool:
+        return self.__original.is_set()
+
+    async def wait(self) -> None:
+        return await self.__original.wait()
+
+    def statistics(self) -> EventStatistics:
+        orig_statistics = self.__original.statistics()
+        return EventStatistics(tasks_waiting=orig_statistics.tasks_waiting)
+
+    def set(self) -> None:
+        self.__original.set()
+
+
+class Lock(BaseLock):
+    def __new__(cls, *, fast_acquire: bool = False) -> Lock:
+        return object.__new__(cls)
+
+    def __init__(self, *, fast_acquire: bool = False) -> None:
+        self._fast_acquire = fast_acquire
+        self.__original = trio.Lock()
+
+    @staticmethod
+    def _convert_runtime_error_msg(exc: RuntimeError) -> None:
+        if exc.args == ("attempt to re-acquire an already held Lock",):
+            exc.args = ("Attempted to acquire an already held Lock",)
+
+    async def acquire(self) -> None:
+        if not self._fast_acquire:
+            try:
+                await self.__original.acquire()
+            except RuntimeError as exc:
+                self._convert_runtime_error_msg(exc)
+                raise
+
+            return
+
+        # This is the "fast path" where we don't let other tasks run
+        await trio.lowlevel.checkpoint_if_cancelled()
+        try:
+            self.__original.acquire_nowait()
+        except trio.WouldBlock:
+            await self.__original._lot.park()
+        except RuntimeError as exc:
+            self._convert_runtime_error_msg(exc)
+            raise
+
+    def acquire_nowait(self) -> None:
+        try:
+            self.__original.acquire_nowait()
+        except trio.WouldBlock:
+            raise WouldBlock from None
+        except RuntimeError as exc:
+            self._convert_runtime_error_msg(exc)
+            raise
+
+    def locked(self) -> bool:
+        return self.__original.locked()
+
+    def release(self) -> None:
+        self.__original.release()
+
+    def statistics(self) -> LockStatistics:
+        orig_statistics = self.__original.statistics()
+        owner = TrioTaskInfo(orig_statistics.owner) if orig_statistics.owner else None
+        return LockStatistics(
+            orig_statistics.locked, owner, orig_statistics.tasks_waiting
+        )
+
+
+class Semaphore(BaseSemaphore):
+    def __new__(
+        cls,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ) -> Semaphore:
+        return object.__new__(cls)
+
+    def __init__(
+        self,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ) -> None:
+        super().__init__(initial_value, max_value=max_value, fast_acquire=fast_acquire)
+        self.__original = trio.Semaphore(initial_value, max_value=max_value)
+
+    async def acquire(self) -> None:
+        if not self._fast_acquire:
+            await self.__original.acquire()
+            return
+
+        # This is the "fast path" where we don't let other tasks run
+        await trio.lowlevel.checkpoint_if_cancelled()
+        try:
+            self.__original.acquire_nowait()
+        except trio.WouldBlock:
+            await self.__original._lot.park()
+
+    def acquire_nowait(self) -> None:
+        try:
+            self.__original.acquire_nowait()
+        except trio.WouldBlock:
+            raise WouldBlock from None
+
+    @property
+    def max_value(self) -> int | None:
+        return self.__original.max_value
+
+    @property
+    def value(self) -> int:
+        return self.__original.value
+
+    def release(self) -> None:
+        self.__original.release()
+
+    def statistics(self) -> SemaphoreStatistics:
+        orig_statistics = self.__original.statistics()
+        return SemaphoreStatistics(orig_statistics.tasks_waiting)
+
+
+class CapacityLimiter(BaseCapacityLimiter):
+    def __new__(
+        cls,
+        total_tokens: float | None = None,
+        *,
+        original: trio.CapacityLimiter | None = None,
+    ) -> CapacityLimiter:
+        return object.__new__(cls)
+
+    def __init__(
+        self,
+        total_tokens: float | None = None,
+        *,
+        original: trio.CapacityLimiter | None = None,
+    ) -> None:
+        if original is not None:
+            self.__original = original
+        else:
+            assert total_tokens is not None
+            self.__original = trio.CapacityLimiter(total_tokens)
+
+    async def __aenter__(self) -> None:
+        return await self.__original.__aenter__()
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        await self.__original.__aexit__(exc_type, exc_val, exc_tb)
+
+    @property
+    def total_tokens(self) -> float:
+        return self.__original.total_tokens
+
+    @total_tokens.setter
+    def total_tokens(self, value: float) -> None:
+        self.__original.total_tokens = value
+
+    @property
+    def borrowed_tokens(self) -> int:
+        return self.__original.borrowed_tokens
+
+    @property
+    def available_tokens(self) -> float:
+        return self.__original.available_tokens
+
+    def acquire_nowait(self) -> None:
+        self.__original.acquire_nowait()
+
+    def acquire_on_behalf_of_nowait(self, borrower: object) -> None:
+        self.__original.acquire_on_behalf_of_nowait(borrower)
+
+    async def acquire(self) -> None:
+        await self.__original.acquire()
+
+    async def acquire_on_behalf_of(self, borrower: object) -> None:
+        await self.__original.acquire_on_behalf_of(borrower)
+
+    def release(self) -> None:
+        return self.__original.release()
+
+    def release_on_behalf_of(self, borrower: object) -> None:
+        return self.__original.release_on_behalf_of(borrower)
+
+    def statistics(self) -> CapacityLimiterStatistics:
+        orig = self.__original.statistics()
+        return CapacityLimiterStatistics(
+            borrowed_tokens=orig.borrowed_tokens,
+            total_tokens=orig.total_tokens,
+            borrowers=tuple(orig.borrowers),
+            tasks_waiting=orig.tasks_waiting,
+        )
+
+
+_capacity_limiter_wrapper: trio.lowlevel.RunVar = RunVar("_capacity_limiter_wrapper")
+
+
+#
+# Signal handling
+#
+
+
+class _SignalReceiver:
+    _iterator: AsyncIterator[int]
+
+    def __init__(self, signals: tuple[Signals, ...]):
+        self._signals = signals
+
+    def __enter__(self) -> _SignalReceiver:
+        self._cm = trio.open_signal_receiver(*self._signals)
+        self._iterator = self._cm.__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
+        return self._cm.__exit__(exc_type, exc_val, exc_tb)
+
+    def __aiter__(self) -> _SignalReceiver:
+        return self
+
+    async def __anext__(self) -> Signals:
+        signum = await self._iterator.__anext__()
+        return Signals(signum)
+
+
+#
+# Testing and debugging
+#
+
+
+class TestRunner(abc.TestRunner):
+    def __init__(self, **options: Any) -> None:
+        from queue import Queue
+
+        self._call_queue: Queue[Callable[[], object]] = Queue()
+        self._send_stream: MemoryObjectSendStream | None = None
+        self._options = options
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: types.TracebackType | None,
+    ) -> None:
+        if self._send_stream:
+            self._send_stream.close()
+            while self._send_stream is not None:
+                self._call_queue.get()()
+
+    async def _run_tests_and_fixtures(self) -> None:
+        self._send_stream, receive_stream = create_memory_object_stream(1)
+        with receive_stream:
+            async for coro, outcome_holder in receive_stream:
+                try:
+                    retval = await coro
+                except BaseException as exc:
+                    outcome_holder.append(Error(exc))
+                else:
+                    outcome_holder.append(Value(retval))
+
+    def _main_task_finished(self, outcome: object) -> None:
+        self._send_stream = None
+
+    def _call_in_runner_task(
+        self,
+        func: Callable[P, Awaitable[T_Retval]],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> T_Retval:
+        if self._send_stream is None:
+            trio.lowlevel.start_guest_run(
+                self._run_tests_and_fixtures,
+                run_sync_soon_threadsafe=self._call_queue.put,
+                done_callback=self._main_task_finished,
+                **self._options,
+            )
+            while self._send_stream is None:
+                self._call_queue.get()()
+
+        outcome_holder: list[Outcome] = []
+        self._send_stream.send_nowait((func(*args, **kwargs), outcome_holder))
+        while not outcome_holder:
+            self._call_queue.get()()
+
+        return outcome_holder[0].unwrap()
+
+    def run_asyncgen_fixture(
+        self,
+        fixture_func: Callable[..., AsyncGenerator[T_Retval, Any]],
+        kwargs: dict[str, Any],
+    ) -> Iterable[T_Retval]:
+        asyncgen = fixture_func(**kwargs)
+        fixturevalue: T_Retval = self._call_in_runner_task(asyncgen.asend, None)
+
+        yield fixturevalue
+
+        try:
+            self._call_in_runner_task(asyncgen.asend, None)
+        except StopAsyncIteration:
+            pass
+        else:
+            self._call_in_runner_task(asyncgen.aclose)
+            raise RuntimeError("Async generator fixture did not stop")
+
+    def run_fixture(
+        self,
+        fixture_func: Callable[..., Coroutine[Any, Any, T_Retval]],
+        kwargs: dict[str, Any],
+    ) -> T_Retval:
+        return self._call_in_runner_task(fixture_func, **kwargs)
+
+    def run_test(
+        self, test_func: Callable[..., Coroutine[Any, Any, Any]], kwargs: dict[str, Any]
+    ) -> None:
+        self._call_in_runner_task(test_func, **kwargs)
+
+
+class TrioTaskInfo(TaskInfo):
+    def __init__(self, task: trio.lowlevel.Task):
+        parent_id = None
+        if task.parent_nursery and task.parent_nursery.parent_task:
+            parent_id = id(task.parent_nursery.parent_task)
+
+        super().__init__(id(task), parent_id, task.name, task.coro)
+        self._task = weakref.proxy(task)
+
+    def has_pending_cancellation(self) -> bool:
+        try:
+            return self._task._cancel_status.effectively_cancelled
+        except ReferenceError:
+            # If the task is no longer around, it surely doesn't have a cancellation
+            # pending
+            return False
+
+
+class TrioBackend(AsyncBackend):
+    @classmethod
+    def run(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
+        args: tuple[Unpack[PosArgsT]],
+        kwargs: dict[str, Any],
+        options: dict[str, Any],
+    ) -> T_Retval:
+        return trio.run(func, *args)
+
+    @classmethod
+    def current_token(cls) -> object:
+        return trio.lowlevel.current_trio_token()
+
+    @classmethod
+    def current_time(cls) -> float:
+        return trio.current_time()
+
+    @classmethod
+    def cancelled_exception_class(cls) -> type[BaseException]:
+        return trio.Cancelled
+
+    @classmethod
+    async def checkpoint(cls) -> None:
+        await trio.lowlevel.checkpoint()
+
+    @classmethod
+    async def checkpoint_if_cancelled(cls) -> None:
+        await trio.lowlevel.checkpoint_if_cancelled()
+
+    @classmethod
+    async def cancel_shielded_checkpoint(cls) -> None:
+        await trio.lowlevel.cancel_shielded_checkpoint()
+
+    @classmethod
+    async def sleep(cls, delay: float) -> None:
+        await trio.sleep(delay)
+
+    @classmethod
+    def create_cancel_scope(
+        cls, *, deadline: float = math.inf, shield: bool = False
+    ) -> abc.CancelScope:
+        return CancelScope(deadline=deadline, shield=shield)
+
+    @classmethod
+    def current_effective_deadline(cls) -> float:
+        return trio.current_effective_deadline()
+
+    @classmethod
+    def create_task_group(cls) -> abc.TaskGroup:
+        return TaskGroup()
+
+    @classmethod
+    def create_event(cls) -> abc.Event:
+        return Event()
+
+    @classmethod
+    def create_lock(cls, *, fast_acquire: bool) -> Lock:
+        return Lock(fast_acquire=fast_acquire)
+
+    @classmethod
+    def create_semaphore(
+        cls,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ) -> abc.Semaphore:
+        return Semaphore(initial_value, max_value=max_value, fast_acquire=fast_acquire)
+
+    @classmethod
+    def create_capacity_limiter(cls, total_tokens: float) -> CapacityLimiter:
+        return CapacityLimiter(total_tokens)
+
+    @classmethod
+    async def run_sync_in_worker_thread(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], T_Retval],
+        args: tuple[Unpack[PosArgsT]],
+        abandon_on_cancel: bool = False,
+        limiter: abc.CapacityLimiter | None = None,
+    ) -> T_Retval:
+        def wrapper() -> T_Retval:
+            with claim_worker_thread(TrioBackend, token):
+                return func(*args)
+
+        token = TrioBackend.current_token()
+        return await run_sync(
+            wrapper,
+            abandon_on_cancel=abandon_on_cancel,
+            limiter=cast(trio.CapacityLimiter, limiter),
+        )
+
+    @classmethod
+    def check_cancelled(cls) -> None:
+        trio.from_thread.check_cancelled()
+
+    @classmethod
+    def run_async_from_thread(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
+        args: tuple[Unpack[PosArgsT]],
+        token: object,
+    ) -> T_Retval:
+        trio_token = cast("trio.lowlevel.TrioToken | None", token)
+        try:
+            return trio.from_thread.run(func, *args, trio_token=trio_token)
+        except trio.RunFinishedError:
+            raise RunFinishedError from None
+
+    @classmethod
+    def run_sync_from_thread(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], T_Retval],
+        args: tuple[Unpack[PosArgsT]],
+        token: object,
+    ) -> T_Retval:
+        trio_token = cast("trio.lowlevel.TrioToken | None", token)
+        try:
+            return trio.from_thread.run_sync(func, *args, trio_token=trio_token)
+        except trio.RunFinishedError:
+            raise RunFinishedError from None
+
+    @classmethod
+    async def open_process(
+        cls,
+        command: StrOrBytesPath | Sequence[StrOrBytesPath],
+        *,
+        stdin: int | IO[Any] | None,
+        stdout: int | IO[Any] | None,
+        stderr: int | IO[Any] | None,
+        **kwargs: Any,
+    ) -> Process:
+        def convert_item(item: StrOrBytesPath) -> str:
+            str_or_bytes = os.fspath(item)
+            if isinstance(str_or_bytes, str):
+                return str_or_bytes
+            else:
+                return os.fsdecode(str_or_bytes)
+
+        if isinstance(command, (str, bytes, PathLike)):
+            process = await trio.lowlevel.open_process(
+                convert_item(command),
+                stdin=stdin,
+                stdout=stdout,
+                stderr=stderr,
+                shell=True,
+                **kwargs,
+            )
+        else:
+            process = await trio.lowlevel.open_process(
+                [convert_item(item) for item in command],
+                stdin=stdin,
+                stdout=stdout,
+                stderr=stderr,
+                shell=False,
+                **kwargs,
+            )
+
+        stdin_stream = SendStreamWrapper(process.stdin) if process.stdin else None
+        stdout_stream = ReceiveStreamWrapper(process.stdout) if process.stdout else None
+        stderr_stream = ReceiveStreamWrapper(process.stderr) if process.stderr else None
+        return Process(process, stdin_stream, stdout_stream, stderr_stream)
+
+    @classmethod
+    def setup_process_pool_exit_at_shutdown(cls, workers: set[abc.Process]) -> None:
+        trio.lowlevel.spawn_system_task(_shutdown_process_pool, workers)
+
+    @classmethod
+    async def connect_tcp(
+        cls, host: str, port: int, local_address: IPSockAddrType | None = None
+    ) -> SocketStream:
+        family = socket.AF_INET6 if ":" in host else socket.AF_INET
+        trio_socket = trio.socket.socket(family)
+        trio_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        if local_address:
+            await trio_socket.bind(local_address)
+
+        try:
+            await trio_socket.connect((host, port))
+        except BaseException:
+            trio_socket.close()
+            raise
+
+        return SocketStream(trio_socket)
+
+    @classmethod
+    async def connect_unix(cls, path: str | bytes) -> abc.UNIXSocketStream:
+        trio_socket = trio.socket.socket(socket.AF_UNIX)
+        try:
+            await trio_socket.connect(path)
+        except BaseException:
+            trio_socket.close()
+            raise
+
+        return UNIXSocketStream(trio_socket)
+
+    @classmethod
+    def create_tcp_listener(cls, sock: socket.socket) -> abc.SocketListener:
+        return TCPSocketListener(sock)
+
+    @classmethod
+    def create_unix_listener(cls, sock: socket.socket) -> abc.SocketListener:
+        return UNIXSocketListener(sock)
+
+    @classmethod
+    async def create_udp_socket(
+        cls,
+        family: socket.AddressFamily,
+        local_address: IPSockAddrType | None,
+        remote_address: IPSockAddrType | None,
+        reuse_port: bool,
+    ) -> UDPSocket | ConnectedUDPSocket:
+        trio_socket = trio.socket.socket(family=family, type=socket.SOCK_DGRAM)
+
+        if reuse_port:
+            trio_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+
+        if local_address:
+            await trio_socket.bind(local_address)
+
+        if remote_address:
+            await trio_socket.connect(remote_address)
+            return ConnectedUDPSocket(trio_socket)
+        else:
+            return UDPSocket(trio_socket)
+
+    @classmethod
+    @overload
+    async def create_unix_datagram_socket(
+        cls, raw_socket: socket.socket, remote_path: None
+    ) -> abc.UNIXDatagramSocket: ...
+
+    @classmethod
+    @overload
+    async def create_unix_datagram_socket(
+        cls, raw_socket: socket.socket, remote_path: str | bytes
+    ) -> abc.ConnectedUNIXDatagramSocket: ...
+
+    @classmethod
+    async def create_unix_datagram_socket(
+        cls, raw_socket: socket.socket, remote_path: str | bytes | None
+    ) -> abc.UNIXDatagramSocket | abc.ConnectedUNIXDatagramSocket:
+        trio_socket = trio.socket.from_stdlib_socket(raw_socket)
+
+        if remote_path:
+            await trio_socket.connect(remote_path)
+            return ConnectedUNIXDatagramSocket(trio_socket)
+        else:
+            return UNIXDatagramSocket(trio_socket)
+
+    @classmethod
+    async def getaddrinfo(
+        cls,
+        host: bytes | str | None,
+        port: str | int | None,
+        *,
+        family: int | AddressFamily = 0,
+        type: int | SocketKind = 0,
+        proto: int = 0,
+        flags: int = 0,
+    ) -> Sequence[
+        tuple[
+            AddressFamily,
+            SocketKind,
+            int,
+            str,
+            tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes],
+        ]
+    ]:
+        return await trio.socket.getaddrinfo(host, port, family, type, proto, flags)
+
+    @classmethod
+    async def getnameinfo(
+        cls, sockaddr: IPSockAddrType, flags: int = 0
+    ) -> tuple[str, str]:
+        return await trio.socket.getnameinfo(sockaddr, flags)
+
+    @classmethod
+    async def wait_readable(cls, obj: FileDescriptorLike) -> None:
+        try:
+            await wait_readable(obj)
+        except trio.ClosedResourceError as exc:
+            raise ClosedResourceError().with_traceback(exc.__traceback__) from None
+        except trio.BusyResourceError:
+            raise BusyResourceError("reading from") from None
+
+    @classmethod
+    async def wait_writable(cls, obj: FileDescriptorLike) -> None:
+        try:
+            await wait_writable(obj)
+        except trio.ClosedResourceError as exc:
+            raise ClosedResourceError().with_traceback(exc.__traceback__) from None
+        except trio.BusyResourceError:
+            raise BusyResourceError("writing to") from None
+
+    @classmethod
+    def notify_closing(cls, obj: FileDescriptorLike) -> None:
+        notify_closing(obj)
+
+    @classmethod
+    async def wrap_listener_socket(cls, sock: socket.socket) -> abc.SocketListener:
+        return TCPSocketListener(sock)
+
+    @classmethod
+    async def wrap_stream_socket(cls, sock: socket.socket) -> SocketStream:
+        trio_sock = trio.socket.from_stdlib_socket(sock)
+        return SocketStream(trio_sock)
+
+    @classmethod
+    async def wrap_unix_stream_socket(cls, sock: socket.socket) -> UNIXSocketStream:
+        trio_sock = trio.socket.from_stdlib_socket(sock)
+        return UNIXSocketStream(trio_sock)
+
+    @classmethod
+    async def wrap_udp_socket(cls, sock: socket.socket) -> UDPSocket:
+        trio_sock = trio.socket.from_stdlib_socket(sock)
+        return UDPSocket(trio_sock)
+
+    @classmethod
+    async def wrap_connected_udp_socket(cls, sock: socket.socket) -> ConnectedUDPSocket:
+        trio_sock = trio.socket.from_stdlib_socket(sock)
+        return ConnectedUDPSocket(trio_sock)
+
+    @classmethod
+    async def wrap_unix_datagram_socket(cls, sock: socket.socket) -> UNIXDatagramSocket:
+        trio_sock = trio.socket.from_stdlib_socket(sock)
+        return UNIXDatagramSocket(trio_sock)
+
+    @classmethod
+    async def wrap_connected_unix_datagram_socket(
+        cls, sock: socket.socket
+    ) -> ConnectedUNIXDatagramSocket:
+        trio_sock = trio.socket.from_stdlib_socket(sock)
+        return ConnectedUNIXDatagramSocket(trio_sock)
+
+    @classmethod
+    def current_default_thread_limiter(cls) -> CapacityLimiter:
+        try:
+            return _capacity_limiter_wrapper.get()
+        except LookupError:
+            limiter = CapacityLimiter(
+                original=trio.to_thread.current_default_thread_limiter()
+            )
+            _capacity_limiter_wrapper.set(limiter)
+            return limiter
+
+    @classmethod
+    def open_signal_receiver(
+        cls, *signals: Signals
+    ) -> AbstractContextManager[AsyncIterator[Signals]]:
+        return _SignalReceiver(signals)
+
+    @classmethod
+    def get_current_task(cls) -> TaskInfo:
+        task = current_task()
+        return TrioTaskInfo(task)
+
+    @classmethod
+    def get_running_tasks(cls) -> Sequence[TaskInfo]:
+        root_task = current_root_task()
+        assert root_task
+        task_infos = [TrioTaskInfo(root_task)]
+        nurseries = root_task.child_nurseries
+        while nurseries:
+            new_nurseries: list[trio.Nursery] = []
+            for nursery in nurseries:
+                for task in nursery.child_tasks:
+                    task_infos.append(TrioTaskInfo(task))
+                    new_nurseries.extend(task.child_nurseries)
+
+            nurseries = new_nurseries
+
+        return task_infos
+
+    @classmethod
+    async def wait_all_tasks_blocked(cls) -> None:
+        from trio.testing import wait_all_tasks_blocked
+
+        await wait_all_tasks_blocked()
+
+    @classmethod
+    def create_test_runner(cls, options: dict[str, Any]) -> TestRunner:
+        return TestRunner(**options)
+
+
+backend_class = TrioBackend

miniconda3/envs/active_proaction/lib/python3.10/site-packages/anyio/_core/_asyncio_selector_thread.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+import asyncio
+import socket
+import threading
+from collections.abc import Callable
+from selectors import EVENT_READ, EVENT_WRITE, DefaultSelector
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from _typeshed import FileDescriptorLike
+
+_selector_lock = threading.Lock()
+_selector: Selector | None = None
+
+
+class Selector:
+    def __init__(self) -> None:
+        self._thread = threading.Thread(target=self.run, name="AnyIO socket selector")
+        self._selector = DefaultSelector()
+        self._send, self._receive = socket.socketpair()
+        self._send.setblocking(False)
+        self._receive.setblocking(False)
+        # This somewhat reduces the amount of memory wasted queueing up data
+        # for wakeups. With these settings, maximum number of 1-byte sends
+        # before getting BlockingIOError:
+        #   Linux 4.8: 6
+        #   macOS (darwin 15.5): 1
+        #   Windows 10: 525347
+        # Windows you're weird. (And on Windows setting SNDBUF to 0 makes send
+        # blocking, even on non-blocking sockets, so don't do that.)
+        self._receive.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 1)
+        self._send.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 1)
+        # On Windows this is a TCP socket so this might matter. On other
+        # platforms this fails b/c AF_UNIX sockets aren't actually TCP.
+        try:
+            self._send.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        except OSError:
+            pass
+
+        self._selector.register(self._receive, EVENT_READ)
+        self._closed = False
+
+    def start(self) -> None:
+        self._thread.start()
+        threading._register_atexit(self._stop)  # type: ignore[attr-defined]
+
+    def _stop(self) -> None:
+        global _selector
+        self._closed = True
+        self._notify_self()
+        self._send.close()
+        self._thread.join()
+        self._selector.unregister(self._receive)
+        self._receive.close()
+        self._selector.close()
+        _selector = None
+        assert not self._selector.get_map(), (
+            "selector still has registered file descriptors after shutdown"
+        )
+
+    def _notify_self(self) -> None:
+        try:
+            self._send.send(b"\x00")
+        except BlockingIOError:
+            pass
+
+    def add_reader(self, fd: FileDescriptorLike, callback: Callable[[], Any]) -> None:
+        loop = asyncio.get_running_loop()
+        try:
+            key = self._selector.get_key(fd)
+        except KeyError:
+            self._selector.register(fd, EVENT_READ, {EVENT_READ: (loop, callback)})
+        else:
+            if EVENT_READ in key.data:
+                raise ValueError(
+                    "this file descriptor is already registered for reading"
+                )
+
+            key.data[EVENT_READ] = loop, callback
+            self._selector.modify(fd, key.events | EVENT_READ, key.data)
+
+        self._notify_self()
+
+    def add_writer(self, fd: FileDescriptorLike, callback: Callable[[], Any]) -> None:
+        loop = asyncio.get_running_loop()
+        try:
+            key = self._selector.get_key(fd)
+        except KeyError:
+            self._selector.register(fd, EVENT_WRITE, {EVENT_WRITE: (loop, callback)})
+        else:
+            if EVENT_WRITE in key.data:
+                raise ValueError(
+                    "this file descriptor is already registered for writing"
+                )
+
+            key.data[EVENT_WRITE] = loop, callback
+            self._selector.modify(fd, key.events | EVENT_WRITE, key.data)
+
+        self._notify_self()
+
+    def remove_reader(self, fd: FileDescriptorLike) -> bool:
+        try:
+            key = self._selector.get_key(fd)
+        except KeyError:
+            return False
+
+        if new_events := key.events ^ EVENT_READ:
+            del key.data[EVENT_READ]
+            self._selector.modify(fd, new_events, key.data)
+        else:
+            self._selector.unregister(fd)
+
+        return True
+
+    def remove_writer(self, fd: FileDescriptorLike) -> bool:
+        try:
+            key = self._selector.get_key(fd)
+        except KeyError:
+            return False
+
+        if new_events := key.events ^ EVENT_WRITE:
+            del key.data[EVENT_WRITE]
+            self._selector.modify(fd, new_events, key.data)
+        else:
+            self._selector.unregister(fd)
+
+        return True
+
+    def run(self) -> None:
+        while not self._closed:
+            for key, events in self._selector.select():
+                if key.fileobj is self._receive:
+                    try:
+                        while self._receive.recv(4096):
+                            pass
+                    except BlockingIOError:
+                        pass
+
+                    continue
+
+                if events & EVENT_READ:
+                    loop, callback = key.data[EVENT_READ]
+                    self.remove_reader(key.fd)
+                    try:
+                        loop.call_soon_threadsafe(callback)
+                    except RuntimeError:
+                        pass  # the loop was already closed
+
+                if events & EVENT_WRITE:
+                    loop, callback = key.data[EVENT_WRITE]
+                    self.remove_writer(key.fd)
+                    try:
+                        loop.call_soon_threadsafe(callback)
+                    except RuntimeError:
+                        pass  # the loop was already closed
+
+
+def get_selector() -> Selector:
+    global _selector
+
+    with _selector_lock:
+        if _selector is None:
+            _selector = Selector()
+            _selector.start()
+
+        return _selector

miniconda3/envs/active_proaction/lib/python3.10/site-packages/anyio/_core/_contextmanagers.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from contextlib import AbstractAsyncContextManager, AbstractContextManager
+from inspect import isasyncgen, iscoroutine, isgenerator
+from types import TracebackType
+from typing import Protocol, TypeVar, cast, final
+
+_T_co = TypeVar("_T_co", covariant=True)
+_ExitT_co = TypeVar("_ExitT_co", covariant=True, bound="bool | None")
+
+
+class _SupportsCtxMgr(Protocol[_T_co, _ExitT_co]):
+    def __contextmanager__(self) -> AbstractContextManager[_T_co, _ExitT_co]: ...
+
+
+class _SupportsAsyncCtxMgr(Protocol[_T_co, _ExitT_co]):
+    def __asynccontextmanager__(
+        self,
+    ) -> AbstractAsyncContextManager[_T_co, _ExitT_co]: ...
+
+
+class ContextManagerMixin:
+    """
+    Mixin class providing context manager functionality via a generator-based
+    implementation.
+
+    This class allows you to implement a context manager via :meth:`__contextmanager__`
+    which should return a generator. The mechanics are meant to mirror those of
+    :func:`@contextmanager <contextlib.contextmanager>`.
+
+    .. note:: Classes using this mix-in are not reentrant as context managers, meaning
+        that once you enter it, you can't re-enter before first exiting it.
+
+    .. seealso:: :doc:`contextmanagers`
+    """
+
+    __cm: AbstractContextManager[object, bool | None] | None = None
+
+    @final
+    def __enter__(self: _SupportsCtxMgr[_T_co, bool | None]) -> _T_co:
+        # Needed for mypy to assume self still has the __cm member
+        assert isinstance(self, ContextManagerMixin)
+        if self.__cm is not None:
+            raise RuntimeError(
+                f"this {self.__class__.__qualname__} has already been entered"
+            )
+
+        cm = self.__contextmanager__()
+        if not isinstance(cm, AbstractContextManager):
+            if isgenerator(cm):
+                raise TypeError(
+                    "__contextmanager__() returned a generator object instead of "
+                    "a context manager. Did you forget to add the @contextmanager "
+                    "decorator?"
+                )
+
+            raise TypeError(
+                f"__contextmanager__() did not return a context manager object, "
+                f"but {cm.__class__!r}"
+            )
+
+        if cm is self:
+            raise TypeError(
+                f"{self.__class__.__qualname__}.__contextmanager__() returned "
+                f"self. Did you forget to add the @contextmanager decorator and a "
+                f"'yield' statement?"
+            )
+
+        value = cm.__enter__()
+        self.__cm = cm
+        return value
+
+    @final
+    def __exit__(
+        self: _SupportsCtxMgr[object, _ExitT_co],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> _ExitT_co:
+        # Needed for mypy to assume self still has the __cm member
+        assert isinstance(self, ContextManagerMixin)
+        if self.__cm is None:
+            raise RuntimeError(
+                f"this {self.__class__.__qualname__} has not been entered yet"
+            )
+
+        # Prevent circular references
+        cm = self.__cm
+        del self.__cm
+
+        return cast(_ExitT_co, cm.__exit__(exc_type, exc_val, exc_tb))
+
+    @abstractmethod
+    def __contextmanager__(self) -> AbstractContextManager[object, bool | None]:
+        """
+        Implement your context manager logic here.
+
+        This method **must** be decorated with
+        :func:`@contextmanager <contextlib.contextmanager>`.
+
+        .. note:: Remember that the ``yield`` will raise any exception raised in the
+            enclosed context block, so use a ``finally:`` block to clean up resources!
+
+        :return: a context manager object
+        """
+
+
+class AsyncContextManagerMixin:
+    """
+    Mixin class providing async context manager functionality via a generator-based
+    implementation.
+
+    This class allows you to implement a context manager via
+    :meth:`__asynccontextmanager__`. The mechanics are meant to mirror those of
+    :func:`@asynccontextmanager <contextlib.asynccontextmanager>`.
+
+    .. note:: Classes using this mix-in are not reentrant as context managers, meaning
+        that once you enter it, you can't re-enter before first exiting it.
+
+    .. seealso:: :doc:`contextmanagers`
+    """
+
+    __cm: AbstractAsyncContextManager[object, bool | None] | None = None
+
+    @final
+    async def __aenter__(self: _SupportsAsyncCtxMgr[_T_co, bool | None]) -> _T_co:
+        # Needed for mypy to assume self still has the __cm member
+        assert isinstance(self, AsyncContextManagerMixin)
+        if self.__cm is not None:
+            raise RuntimeError(
+                f"this {self.__class__.__qualname__} has already been entered"
+            )
+
+        cm = self.__asynccontextmanager__()
+        if not isinstance(cm, AbstractAsyncContextManager):
+            if isasyncgen(cm):
+                raise TypeError(
+                    "__asynccontextmanager__() returned an async generator instead of "
+                    "an async context manager. Did you forget to add the "
+                    "@asynccontextmanager decorator?"
+                )
+            elif iscoroutine(cm):
+                cm.close()
+                raise TypeError(
+                    "__asynccontextmanager__() returned a coroutine object instead of "
+                    "an async context manager. Did you forget to add the "
+                    "@asynccontextmanager decorator and a 'yield' statement?"
+                )
+
+            raise TypeError(
+                f"__asynccontextmanager__() did not return an async context manager, "
+                f"but {cm.__class__!r}"
+            )
+
+        if cm is self:
+            raise TypeError(
+                f"{self.__class__.__qualname__}.__asynccontextmanager__() returned "
+                f"self. Did you forget to add the @asynccontextmanager decorator and a "
+                f"'yield' statement?"
+            )
+
+        value = await cm.__aenter__()
+        self.__cm = cm
+        return value
+
+    @final
+    async def __aexit__(
+        self: _SupportsAsyncCtxMgr[object, _ExitT_co],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> _ExitT_co:
+        assert isinstance(self, AsyncContextManagerMixin)
+        if self.__cm is None:
+            raise RuntimeError(
+                f"this {self.__class__.__qualname__} has not been entered yet"
+            )
+
+        # Prevent circular references
+        cm = self.__cm
+        del self.__cm
+
+        return cast(_ExitT_co, await cm.__aexit__(exc_type, exc_val, exc_tb))
+
+    @abstractmethod
+    def __asynccontextmanager__(
+        self,
+    ) -> AbstractAsyncContextManager[object, bool | None]:
+        """
+        Implement your async context manager logic here.
+
+        This method **must** be decorated with
+        :func:`@asynccontextmanager <contextlib.asynccontextmanager>`.
+
+        .. note:: Remember that the ``yield`` will raise any exception raised in the
+            enclosed context block, so use a ``finally:`` block to clean up resources!
+
+        :return: an async context manager object
+        """

miniconda3/envs/active_proaction/lib/python3.10/site-packages/anyio/_core/_eventloop.py

@@ -0,0 +1,234 @@
+from __future__ import annotations
+
+import math
+import sys
+import threading
+from collections.abc import Awaitable, Callable, Generator
+from contextlib import contextmanager
+from contextvars import Token
+from importlib import import_module
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from ._exceptions import NoEventLoopError
+
+if sys.version_info >= (3, 11):
+    from typing import TypeVarTuple, Unpack
+else:
+    from typing_extensions import TypeVarTuple, Unpack
+
+sniffio: Any
+try:
+    import sniffio
+except ModuleNotFoundError:
+    sniffio = None
+
+if TYPE_CHECKING:
+    from ..abc import AsyncBackend
+
+# This must be updated when new backends are introduced
+BACKENDS = "asyncio", "trio"
+
+T_Retval = TypeVar("T_Retval")
+PosArgsT = TypeVarTuple("PosArgsT")
+
+threadlocals = threading.local()
+loaded_backends: dict[str, type[AsyncBackend]] = {}
+
+
+def run(
+    func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
+    *args: Unpack[PosArgsT],
+    backend: str = "asyncio",
+    backend_options: dict[str, Any] | None = None,
+) -> T_Retval:
+    """
+    Run the given coroutine function in an asynchronous event loop.
+
+    The current thread must not be already running an event loop.
+
+    :param func: a coroutine function
+    :param args: positional arguments to ``func``
+    :param backend: name of the asynchronous event loop implementation – currently
+        either ``asyncio`` or ``trio``
+    :param backend_options: keyword arguments to call the backend ``run()``
+        implementation with (documented :ref:`here <backend options>`)
+    :return: the return value of the coroutine function
+    :raises RuntimeError: if an asynchronous event loop is already running in this
+        thread
+    :raises LookupError: if the named backend is not found
+
+    """
+    if asynclib_name := current_async_library():
+        raise RuntimeError(f"Already running {asynclib_name} in this thread")
+
+    try:
+        async_backend = get_async_backend(backend)
+    except ImportError as exc:
+        raise LookupError(f"No such backend: {backend}") from exc
+
+    token = None
+    if asynclib_name is None:
+        # Since we're in control of the event loop, we can cache the name of the async
+        # library
+        token = set_current_async_library(backend)
+
+    try:
+        backend_options = backend_options or {}
+        return async_backend.run(func, args, {}, backend_options)
+    finally:
+        reset_current_async_library(token)
+
+
+async def sleep(delay: float) -> None:
+    """
+    Pause the current task for the specified duration.
+
+    :param delay: the duration, in seconds
+
+    """
+    return await get_async_backend().sleep(delay)
+
+
+async def sleep_forever() -> None:
+    """
+    Pause the current task until it's cancelled.
+
+    This is a shortcut for ``sleep(math.inf)``.
+
+    .. versionadded:: 3.1
+
+    """
+    await sleep(math.inf)
+
+
+async def sleep_until(deadline: float) -> None:
+    """
+    Pause the current task until the given time.
+
+    :param deadline: the absolute time to wake up at (according to the internal
+        monotonic clock of the event loop)
+
+    .. versionadded:: 3.1
+
+    """
+    now = current_time()
+    await sleep(max(deadline - now, 0))
+
+
+def current_time() -> float:
+    """
+    Return the current value of the event loop's internal clock.
+
+    :return: the clock value (seconds)
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+
+    """
+    return get_async_backend().current_time()
+
+
+def get_all_backends() -> tuple[str, ...]:
+    """Return a tuple of the names of all built-in backends."""
+    return BACKENDS
+
+
+def get_available_backends() -> tuple[str, ...]:
+    """
+    Test for the availability of built-in backends.
+
+    :return a tuple of the built-in backend names that were successfully imported
+
+    .. versionadded:: 4.12
+
+    """
+    available_backends: list[str] = []
+    for backend_name in get_all_backends():
+        try:
+            get_async_backend(backend_name)
+        except ImportError:
+            continue
+
+        available_backends.append(backend_name)
+
+    return tuple(available_backends)
+
+
+def get_cancelled_exc_class() -> type[BaseException]:
+    """
+    Return the current async library's cancellation exception class.
+
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+
+    """
+    return get_async_backend().cancelled_exception_class()
+
+
+#
+# Private API
+#
+
+
+@contextmanager
+def claim_worker_thread(
+    backend_class: type[AsyncBackend], token: object
+) -> Generator[Any, None, None]:
+    from ..lowlevel import EventLoopToken
+
+    threadlocals.current_token = EventLoopToken(backend_class, token)
+    try:
+        yield
+    finally:
+        del threadlocals.current_token
+
+
+def get_async_backend(asynclib_name: str | None = None) -> type[AsyncBackend]:
+    if asynclib_name is None:
+        asynclib_name = current_async_library()
+        if not asynclib_name:
+            raise NoEventLoopError(
+                f"Not currently running on any asynchronous event loop. "
+                f"Available async backends: {', '.join(get_all_backends())}"
+            )
+
+    # We use our own dict instead of sys.modules to get the already imported back-end
+    # class because the appropriate modules in sys.modules could potentially be only
+    # partially initialized
+    try:
+        return loaded_backends[asynclib_name]
+    except KeyError:
+        module = import_module(f"anyio._backends._{asynclib_name}")
+        loaded_backends[asynclib_name] = module.backend_class
+        return module.backend_class
+
+
+def current_async_library() -> str | None:
+    if sniffio is None:
+        # If sniffio is not installed, we assume we're either running asyncio or nothing
+        import asyncio
+
+        try:
+            asyncio.get_running_loop()
+            return "asyncio"
+        except RuntimeError:
+            pass
+    else:
+        try:
+            return sniffio.current_async_library()
+        except sniffio.AsyncLibraryNotFoundError:
+            pass
+
+    return None
+
+
+def set_current_async_library(asynclib_name: str | None) -> Token | None:
+    # no-op if sniffio is not installed
+    if sniffio is None:
+        return None
+
+    return sniffio.current_async_library_cvar.set(asynclib_name)
+
+
+def reset_current_async_library(token: Token | None) -> None:
+    if token is not None:
+        sniffio.current_async_library_cvar.reset(token)

miniconda3/envs/active_proaction/lib/python3.10/site-packages/anyio/_core/_exceptions.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import sys
+from collections.abc import Generator
+from textwrap import dedent
+from typing import Any
+
+if sys.version_info < (3, 11):
+    from exceptiongroup import BaseExceptionGroup
+
+
+class BrokenResourceError(Exception):
+    """
+    Raised when trying to use a resource that has been rendered unusable due to external
+    causes (e.g. a send stream whose peer has disconnected).
+    """
+
+
+class BrokenWorkerProcess(Exception):
+    """
+    Raised by :meth:`~anyio.to_process.run_sync` if the worker process terminates abruptly or
+    otherwise misbehaves.
+    """
+
+
+class BrokenWorkerInterpreter(Exception):
+    """
+    Raised by :meth:`~anyio.to_interpreter.run_sync` if an unexpected exception is
+    raised in the subinterpreter.
+    """
+
+    def __init__(self, excinfo: Any):
+        # This was adapted from concurrent.futures.interpreter.ExecutionFailed
+        msg = excinfo.formatted
+        if not msg:
+            if excinfo.type and excinfo.msg:
+                msg = f"{excinfo.type.__name__}: {excinfo.msg}"
+            else:
+                msg = excinfo.type.__name__ or excinfo.msg
+
+        super().__init__(msg)
+        self.excinfo = excinfo
+
+    def __str__(self) -> str:
+        try:
+            formatted = self.excinfo.errdisplay
+        except Exception:
+            return super().__str__()
+        else:
+            return dedent(
+                f"""
+                {super().__str__()}
+
+                Uncaught in the interpreter:
+
+                {formatted}
+                """.strip()
+            )
+
+
+class BusyResourceError(Exception):
+    """
+    Raised when two tasks are trying to read from or write to the same resource
+    concurrently.
+    """
+
+    def __init__(self, action: str):
+        super().__init__(f"Another task is already {action} this resource")
+
+
+class ClosedResourceError(Exception):
+    """Raised when trying to use a resource that has been closed."""
+
+
+class ConnectionFailed(OSError):
+    """
+    Raised when a connection attempt fails.
+
+    .. note:: This class inherits from :exc:`OSError` for backwards compatibility.
+    """
+
+
+def iterate_exceptions(
+    exception: BaseException,
+) -> Generator[BaseException, None, None]:
+    if isinstance(exception, BaseExceptionGroup):
+        for exc in exception.exceptions:
+            yield from iterate_exceptions(exc)
+    else:
+        yield exception
+
+
+class DelimiterNotFound(Exception):
+    """
+    Raised during
+    :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_until` if the
+    maximum number of bytes has been read without the delimiter being found.
+    """
+
+    def __init__(self, max_bytes: int) -> None:
+        super().__init__(
+            f"The delimiter was not found among the first {max_bytes} bytes"
+        )
+
+
+class EndOfStream(Exception):
+    """
+    Raised when trying to read from a stream that has been closed from the other end.
+    """
+
+
+class IncompleteRead(Exception):
+    """
+    Raised during
+    :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_exactly` or
+    :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_until` if the
+    connection is closed before the requested amount of bytes has been read.
+    """
+
+    def __init__(self) -> None:
+        super().__init__(
+            "The stream was closed before the read operation could be completed"
+        )
+
+
+class TypedAttributeLookupError(LookupError):
+    """
+    Raised by :meth:`~anyio.TypedAttributeProvider.extra` when the given typed attribute
+    is not found and no default value has been given.
+    """
+
+
+class WouldBlock(Exception):
+    """Raised by ``X_nowait`` functions if ``X()`` would block."""
+
+
+class NoEventLoopError(RuntimeError):
+    """
+    Raised by several functions that require an event loop to be running in the current
+    thread when there is no running event loop.
+
+    This is also raised by :func:`.from_thread.run` and :func:`.from_thread.run_sync`
+    if not calling from an AnyIO worker thread, and no ``token`` was passed.
+    """
+
+
+class RunFinishedError(RuntimeError):
+    """
+    Raised by :func:`.from_thread.run` and :func:`.from_thread.run_sync` if the event
+    loop associated with the explicitly passed token has already finished.
+    """
+
+    def __init__(self) -> None:
+        super().__init__(
+            "The event loop associated with the given token has already finished"
+        )

miniconda3/envs/active_proaction/lib/python3.10/site-packages/anyio/_core/_fileio.py

@@ -0,0 +1,797 @@
+from __future__ import annotations
+
+import os
+import pathlib
+import sys
+from collections.abc import (
+    AsyncIterator,
+    Callable,
+    Iterable,
+    Iterator,
+    Sequence,
+)
+from dataclasses import dataclass
+from functools import partial
+from os import PathLike
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    AnyStr,
+    ClassVar,
+    Final,
+    Generic,
+    overload,
+)
+
+from .. import to_thread
+from ..abc import AsyncResource
+
+if TYPE_CHECKING:
+    from types import ModuleType
+
+    from _typeshed import OpenBinaryMode, OpenTextMode, ReadableBuffer, WriteableBuffer
+else:
+    ReadableBuffer = OpenBinaryMode = OpenTextMode = WriteableBuffer = object
+
+
+class AsyncFile(AsyncResource, Generic[AnyStr]):
+    """
+    An asynchronous file object.
+
+    This class wraps a standard file object and provides async friendly versions of the
+    following blocking methods (where available on the original file object):
+
+    * read
+    * read1
+    * readline
+    * readlines
+    * readinto
+    * readinto1
+    * write
+    * writelines
+    * truncate
+    * seek
+    * tell
+    * flush
+
+    All other methods are directly passed through.
+
+    This class supports the asynchronous context manager protocol which closes the
+    underlying file at the end of the context block.
+
+    This class also supports asynchronous iteration::
+
+        async with await open_file(...) as f:
+            async for line in f:
+                print(line)
+    """
+
+    def __init__(self, fp: IO[AnyStr]) -> None:
+        self._fp: Any = fp
+
+    def __getattr__(self, name: str) -> object:
+        return getattr(self._fp, name)
+
+    @property
+    def wrapped(self) -> IO[AnyStr]:
+        """The wrapped file object."""
+        return self._fp
+
+    async def __aiter__(self) -> AsyncIterator[AnyStr]:
+        while True:
+            line = await self.readline()
+            if line:
+                yield line
+            else:
+                break
+
+    async def aclose(self) -> None:
+        return await to_thread.run_sync(self._fp.close)
+
+    async def read(self, size: int = -1) -> AnyStr:
+        return await to_thread.run_sync(self._fp.read, size)
+
+    async def read1(self: AsyncFile[bytes], size: int = -1) -> bytes:
+        return await to_thread.run_sync(self._fp.read1, size)
+
+    async def readline(self) -> AnyStr:
+        return await to_thread.run_sync(self._fp.readline)
+
+    async def readlines(self) -> list[AnyStr]:
+        return await to_thread.run_sync(self._fp.readlines)
+
+    async def readinto(self: AsyncFile[bytes], b: WriteableBuffer) -> int:
+        return await to_thread.run_sync(self._fp.readinto, b)
+
+    async def readinto1(self: AsyncFile[bytes], b: WriteableBuffer) -> int:
+        return await to_thread.run_sync(self._fp.readinto1, b)
+
+    @overload
+    async def write(self: AsyncFile[bytes], b: ReadableBuffer) -> int: ...
+
+    @overload
+    async def write(self: AsyncFile[str], b: str) -> int: ...
+
+    async def write(self, b: ReadableBuffer | str) -> int:
+        return await to_thread.run_sync(self._fp.write, b)
+
+    @overload
+    async def writelines(
+        self: AsyncFile[bytes], lines: Iterable[ReadableBuffer]
+    ) -> None: ...
+
+    @overload
+    async def writelines(self: AsyncFile[str], lines: Iterable[str]) -> None: ...
+
+    async def writelines(self, lines: Iterable[ReadableBuffer] | Iterable[str]) -> None:
+        return await to_thread.run_sync(self._fp.writelines, lines)
+
+    async def truncate(self, size: int | None = None) -> int:
+        return await to_thread.run_sync(self._fp.truncate, size)
+
+    async def seek(self, offset: int, whence: int | None = os.SEEK_SET) -> int:
+        return await to_thread.run_sync(self._fp.seek, offset, whence)
+
+    async def tell(self) -> int:
+        return await to_thread.run_sync(self._fp.tell)
+
+    async def flush(self) -> None:
+        return await to_thread.run_sync(self._fp.flush)
+
+
+@overload
+async def open_file(
+    file: str | PathLike[str] | int,
+    mode: OpenBinaryMode,
+    buffering: int = ...,
+    encoding: str | None = ...,
+    errors: str | None = ...,
+    newline: str | None = ...,
+    closefd: bool = ...,
+    opener: Callable[[str, int], int] | None = ...,
+) -> AsyncFile[bytes]: ...
+
+
+@overload
+async def open_file(
+    file: str | PathLike[str] | int,
+    mode: OpenTextMode = ...,
+    buffering: int = ...,
+    encoding: str | None = ...,
+    errors: str | None = ...,
+    newline: str | None = ...,
+    closefd: bool = ...,
+    opener: Callable[[str, int], int] | None = ...,
+) -> AsyncFile[str]: ...
+
+
+async def open_file(
+    file: str | PathLike[str] | int,
+    mode: str = "r",
+    buffering: int = -1,
+    encoding: str | None = None,
+    errors: str | None = None,
+    newline: str | None = None,
+    closefd: bool = True,
+    opener: Callable[[str, int], int] | None = None,
+) -> AsyncFile[Any]:
+    """
+    Open a file asynchronously.
+
+    The arguments are exactly the same as for the builtin :func:`open`.
+
+    :return: an asynchronous file object
+
+    """
+    fp = await to_thread.run_sync(
+        open, file, mode, buffering, encoding, errors, newline, closefd, opener
+    )
+    return AsyncFile(fp)
+
+
+def wrap_file(file: IO[AnyStr]) -> AsyncFile[AnyStr]:
+    """
+    Wrap an existing file as an asynchronous file.
+
+    :param file: an existing file-like object
+    :return: an asynchronous file object
+
+    """
+    return AsyncFile(file)
+
+
+@dataclass(eq=False)
+class _PathIterator(AsyncIterator["Path"]):
+    iterator: Iterator[PathLike[str]]
+
+    async def __anext__(self) -> Path:
+        nextval = await to_thread.run_sync(
+            next, self.iterator, None, abandon_on_cancel=True
+        )
+        if nextval is None:
+            raise StopAsyncIteration from None
+
+        return Path(nextval)
+
+
+class Path:
+    """
+    An asynchronous version of :class:`pathlib.Path`.
+
+    This class cannot be substituted for :class:`pathlib.Path` or
+    :class:`pathlib.PurePath`, but it is compatible with the :class:`os.PathLike`
+    interface.
+
+    It implements the Python 3.10 version of :class:`pathlib.Path` interface, except for
+    the deprecated :meth:`~pathlib.Path.link_to` method.
+
+    Some methods may be unavailable or have limited functionality, based on the Python
+    version:
+
+    * :meth:`~pathlib.Path.copy` (available on Python 3.14 or later)
+    * :meth:`~pathlib.Path.copy_into` (available on Python 3.14 or later)
+    * :meth:`~pathlib.Path.from_uri` (available on Python 3.13 or later)
+    * :meth:`~pathlib.PurePath.full_match` (available on Python 3.13 or later)
+    * :attr:`~pathlib.Path.info` (available on Python 3.14 or later)
+    * :meth:`~pathlib.Path.is_junction` (available on Python 3.12 or later)
+    * :meth:`~pathlib.PurePath.match` (the ``case_sensitive`` parameter is only
+      available on Python 3.13 or later)
+    * :meth:`~pathlib.Path.move` (available on Python 3.14 or later)
+    * :meth:`~pathlib.Path.move_into` (available on Python 3.14 or later)
+    * :meth:`~pathlib.PurePath.relative_to` (the ``walk_up`` parameter is only available
+      on Python 3.12 or later)
+    * :meth:`~pathlib.Path.walk` (available on Python 3.12 or later)
+
+    Any methods that do disk I/O need to be awaited on. These methods are:
+
+    * :meth:`~pathlib.Path.absolute`
+    * :meth:`~pathlib.Path.chmod`
+    * :meth:`~pathlib.Path.cwd`
+    * :meth:`~pathlib.Path.exists`
+    * :meth:`~pathlib.Path.expanduser`
+    * :meth:`~pathlib.Path.group`
+    * :meth:`~pathlib.Path.hardlink_to`
+    * :meth:`~pathlib.Path.home`
+    * :meth:`~pathlib.Path.is_block_device`
+    * :meth:`~pathlib.Path.is_char_device`
+    * :meth:`~pathlib.Path.is_dir`
+    * :meth:`~pathlib.Path.is_fifo`
+    * :meth:`~pathlib.Path.is_file`
+    * :meth:`~pathlib.Path.is_junction`
+    * :meth:`~pathlib.Path.is_mount`
+    * :meth:`~pathlib.Path.is_socket`
+    * :meth:`~pathlib.Path.is_symlink`
+    * :meth:`~pathlib.Path.lchmod`
+    * :meth:`~pathlib.Path.lstat`
+    * :meth:`~pathlib.Path.mkdir`
+    * :meth:`~pathlib.Path.open`
+    * :meth:`~pathlib.Path.owner`
+    * :meth:`~pathlib.Path.read_bytes`
+    * :meth:`~pathlib.Path.read_text`
+    * :meth:`~pathlib.Path.readlink`
+    * :meth:`~pathlib.Path.rename`
+    * :meth:`~pathlib.Path.replace`
+    * :meth:`~pathlib.Path.resolve`
+    * :meth:`~pathlib.Path.rmdir`
+    * :meth:`~pathlib.Path.samefile`
+    * :meth:`~pathlib.Path.stat`
+    * :meth:`~pathlib.Path.symlink_to`
+    * :meth:`~pathlib.Path.touch`
+    * :meth:`~pathlib.Path.unlink`
+    * :meth:`~pathlib.Path.walk`
+    * :meth:`~pathlib.Path.write_bytes`
+    * :meth:`~pathlib.Path.write_text`
+
+    Additionally, the following methods return an async iterator yielding
+    :class:`~.Path` objects:
+
+    * :meth:`~pathlib.Path.glob`
+    * :meth:`~pathlib.Path.iterdir`
+    * :meth:`~pathlib.Path.rglob`
+    """
+
+    __slots__ = "_path", "__weakref__"
+
+    __weakref__: Any
+
+    def __init__(self, *args: str | PathLike[str]) -> None:
+        self._path: Final[pathlib.Path] = pathlib.Path(*args)
+
+    def __fspath__(self) -> str:
+        return self._path.__fspath__()
+
+    def __str__(self) -> str:
+        return self._path.__str__()
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.as_posix()!r})"
+
+    def __bytes__(self) -> bytes:
+        return self._path.__bytes__()
+
+    def __hash__(self) -> int:
+        return self._path.__hash__()
+
+    def __eq__(self, other: object) -> bool:
+        target = other._path if isinstance(other, Path) else other
+        return self._path.__eq__(target)
+
+    def __lt__(self, other: pathlib.PurePath | Path) -> bool:
+        target = other._path if isinstance(other, Path) else other
+        return self._path.__lt__(target)
+
+    def __le__(self, other: pathlib.PurePath | Path) -> bool:
+        target = other._path if isinstance(other, Path) else other
+        return self._path.__le__(target)
+
+    def __gt__(self, other: pathlib.PurePath | Path) -> bool:
+        target = other._path if isinstance(other, Path) else other
+        return self._path.__gt__(target)
+
+    def __ge__(self, other: pathlib.PurePath | Path) -> bool:
+        target = other._path if isinstance(other, Path) else other
+        return self._path.__ge__(target)
+
+    def __truediv__(self, other: str | PathLike[str]) -> Path:
+        return Path(self._path / other)
+
+    def __rtruediv__(self, other: str | PathLike[str]) -> Path:
+        return Path(other) / self
+
+    @property
+    def parts(self) -> tuple[str, ...]:
+        return self._path.parts
+
+    @property
+    def drive(self) -> str:
+        return self._path.drive
+
+    @property
+    def root(self) -> str:
+        return self._path.root
+
+    @property
+    def anchor(self) -> str:
+        return self._path.anchor
+
+    @property
+    def parents(self) -> Sequence[Path]:
+        return tuple(Path(p) for p in self._path.parents)
+
+    @property
+    def parent(self) -> Path:
+        return Path(self._path.parent)
+
+    @property
+    def name(self) -> str:
+        return self._path.name
+
+    @property
+    def suffix(self) -> str:
+        return self._path.suffix
+
+    @property
+    def suffixes(self) -> list[str]:
+        return self._path.suffixes
+
+    @property
+    def stem(self) -> str:
+        return self._path.stem
+
+    async def absolute(self) -> Path:
+        path = await to_thread.run_sync(self._path.absolute)
+        return Path(path)
+
+    def as_posix(self) -> str:
+        return self._path.as_posix()
+
+    def as_uri(self) -> str:
+        return self._path.as_uri()
+
+    if sys.version_info >= (3, 13):
+        parser: ClassVar[ModuleType] = pathlib.Path.parser
+
+        @classmethod
+        def from_uri(cls, uri: str) -> Path:
+            return Path(pathlib.Path.from_uri(uri))
+
+        def full_match(
+            self, path_pattern: str, *, case_sensitive: bool | None = None
+        ) -> bool:
+            return self._path.full_match(path_pattern, case_sensitive=case_sensitive)
+
+        def match(
+            self, path_pattern: str, *, case_sensitive: bool | None = None
+        ) -> bool:
+            return self._path.match(path_pattern, case_sensitive=case_sensitive)
+    else:
+
+        def match(self, path_pattern: str) -> bool:
+            return self._path.match(path_pattern)
+
+    if sys.version_info >= (3, 14):
+
+        @property
+        def info(self) -> Any:  # TODO: add return type annotation when Typeshed gets it
+            return self._path.info
+
+        async def copy(
+            self,
+            target: str | os.PathLike[str],
+            *,
+            follow_symlinks: bool = True,
+            preserve_metadata: bool = False,
+        ) -> Path:
+            func = partial(
+                self._path.copy,
+                follow_symlinks=follow_symlinks,
+                preserve_metadata=preserve_metadata,
+            )
+            return Path(await to_thread.run_sync(func, pathlib.Path(target)))
+
+        async def copy_into(
+            self,
+            target_dir: str | os.PathLike[str],
+            *,
+            follow_symlinks: bool = True,
+            preserve_metadata: bool = False,
+        ) -> Path:
+            func = partial(
+                self._path.copy_into,
+                follow_symlinks=follow_symlinks,
+                preserve_metadata=preserve_metadata,
+            )
+            return Path(await to_thread.run_sync(func, pathlib.Path(target_dir)))
+
+        async def move(self, target: str | os.PathLike[str]) -> Path:
+            # Upstream does not handle anyio.Path properly as a PathLike
+            target = pathlib.Path(target)
+            return Path(await to_thread.run_sync(self._path.move, target))
+
+        async def move_into(
+            self,
+            target_dir: str | os.PathLike[str],
+        ) -> Path:
+            return Path(await to_thread.run_sync(self._path.move_into, target_dir))
+
+    def is_relative_to(self, other: str | PathLike[str]) -> bool:
+        try:
+            self.relative_to(other)
+            return True
+        except ValueError:
+            return False
+
+    async def chmod(self, mode: int, *, follow_symlinks: bool = True) -> None:
+        func = partial(os.chmod, follow_symlinks=follow_symlinks)
+        return await to_thread.run_sync(func, self._path, mode)
+
+    @classmethod
+    async def cwd(cls) -> Path:
+        path = await to_thread.run_sync(pathlib.Path.cwd)
+        return cls(path)
+
+    async def exists(self) -> bool:
+        return await to_thread.run_sync(self._path.exists, abandon_on_cancel=True)
+
+    async def expanduser(self) -> Path:
+        return Path(
+            await to_thread.run_sync(self._path.expanduser, abandon_on_cancel=True)
+        )
+
+    if sys.version_info < (3, 12):
+        # Python 3.11 and earlier
+        def glob(self, pattern: str) -> AsyncIterator[Path]:
+            gen = self._path.glob(pattern)
+            return _PathIterator(gen)
+    elif (3, 12) <= sys.version_info < (3, 13):
+        # changed in Python 3.12:
+        # - The case_sensitive parameter was added.
+        def glob(
+            self,
+            pattern: str,
+            *,
+            case_sensitive: bool | None = None,
+        ) -> AsyncIterator[Path]:
+            gen = self._path.glob(pattern, case_sensitive=case_sensitive)
+            return _PathIterator(gen)
+    elif sys.version_info >= (3, 13):
+        # Changed in Python 3.13:
+        # - The recurse_symlinks parameter was added.
+        # - The pattern parameter accepts a path-like object.
+        def glob(  # type: ignore[misc] # mypy doesn't allow for differing signatures in a conditional block
+            self,
+            pattern: str | PathLike[str],
+            *,
+            case_sensitive: bool | None = None,
+            recurse_symlinks: bool = False,
+        ) -> AsyncIterator[Path]:
+            gen = self._path.glob(
+                pattern,  # type: ignore[arg-type]
+                case_sensitive=case_sensitive,
+                recurse_symlinks=recurse_symlinks,
+            )
+            return _PathIterator(gen)
+
+    async def group(self) -> str:
+        return await to_thread.run_sync(self._path.group, abandon_on_cancel=True)
+
+    async def hardlink_to(
+        self, target: str | bytes | PathLike[str] | PathLike[bytes]
+    ) -> None:
+        if isinstance(target, Path):
+            target = target._path
+
+        await to_thread.run_sync(os.link, target, self)
+
+    @classmethod
+    async def home(cls) -> Path:
+        home_path = await to_thread.run_sync(pathlib.Path.home)
+        return cls(home_path)
+
+    def is_absolute(self) -> bool:
+        return self._path.is_absolute()
+
+    async def is_block_device(self) -> bool:
+        return await to_thread.run_sync(
+            self._path.is_block_device, abandon_on_cancel=True
+        )
+
+    async def is_char_device(self) -> bool:
+        return await to_thread.run_sync(
+            self._path.is_char_device, abandon_on_cancel=True
+        )
+
+    async def is_dir(self) -> bool:
+        return await to_thread.run_sync(self._path.is_dir, abandon_on_cancel=True)
+
+    async def is_fifo(self) -> bool:
+        return await to_thread.run_sync(self._path.is_fifo, abandon_on_cancel=True)
+
+    async def is_file(self) -> bool:
+        return await to_thread.run_sync(self._path.is_file, abandon_on_cancel=True)
+
+    if sys.version_info >= (3, 12):
+
+        async def is_junction(self) -> bool:
+            return await to_thread.run_sync(self._path.is_junction)
+
+    async def is_mount(self) -> bool:
+        return await to_thread.run_sync(
+            os.path.ismount, self._path, abandon_on_cancel=True
+        )
+
+    def is_reserved(self) -> bool:
+        return self._path.is_reserved()
+
+    async def is_socket(self) -> bool:
+        return await to_thread.run_sync(self._path.is_socket, abandon_on_cancel=True)
+
+    async def is_symlink(self) -> bool:
+        return await to_thread.run_sync(self._path.is_symlink, abandon_on_cancel=True)
+
+    async def iterdir(self) -> AsyncIterator[Path]:
+        gen = (
+            self._path.iterdir()
+            if sys.version_info < (3, 13)
+            else await to_thread.run_sync(self._path.iterdir, abandon_on_cancel=True)
+        )
+        async for path in _PathIterator(gen):
+            yield path
+
+    def joinpath(self, *args: str | PathLike[str]) -> Path:
+        return Path(self._path.joinpath(*args))
+
+    async def lchmod(self, mode: int) -> None:
+        await to_thread.run_sync(self._path.lchmod, mode)
+
+    async def lstat(self) -> os.stat_result:
+        return await to_thread.run_sync(self._path.lstat, abandon_on_cancel=True)
+
+    async def mkdir(
+        self, mode: int = 0o777, parents: bool = False, exist_ok: bool = False
+    ) -> None:
+        await to_thread.run_sync(self._path.mkdir, mode, parents, exist_ok)
+
+    @overload
+    async def open(
+        self,
+        mode: OpenBinaryMode,
+        buffering: int = ...,
+        encoding: str | None = ...,
+        errors: str | None = ...,
+        newline: str | None = ...,
+    ) -> AsyncFile[bytes]: ...
+
+    @overload
+    async def open(
+        self,
+        mode: OpenTextMode = ...,
+        buffering: int = ...,
+        encoding: str | None = ...,
+        errors: str | None = ...,
+        newline: str | None = ...,
+    ) -> AsyncFile[str]: ...
+
+    async def open(
+        self,
+        mode: str = "r",
+        buffering: int = -1,
+        encoding: str | None = None,
+        errors: str | None = None,
+        newline: str | None = None,
+    ) -> AsyncFile[Any]:
+        fp = await to_thread.run_sync(
+            self._path.open, mode, buffering, encoding, errors, newline
+        )
+        return AsyncFile(fp)
+
+    async def owner(self) -> str:
+        return await to_thread.run_sync(self._path.owner, abandon_on_cancel=True)
+
+    async def read_bytes(self) -> bytes:
+        return await to_thread.run_sync(self._path.read_bytes)
+
+    async def read_text(
+        self, encoding: str | None = None, errors: str | None = None
+    ) -> str:
+        return await to_thread.run_sync(self._path.read_text, encoding, errors)
+
+    if sys.version_info >= (3, 12):
+
+        def relative_to(
+            self, *other: str | PathLike[str], walk_up: bool = False
+        ) -> Path:
+            # relative_to() should work with any PathLike but it doesn't
+            others = [pathlib.Path(other) for other in other]
+            return Path(self._path.relative_to(*others, walk_up=walk_up))
+
+    else:
+
+        def relative_to(self, *other: str | PathLike[str]) -> Path:
+            return Path(self._path.relative_to(*other))
+
+    async def readlink(self) -> Path:
+        target = await to_thread.run_sync(os.readlink, self._path)
+        return Path(target)
+
+    async def rename(self, target: str | pathlib.PurePath | Path) -> Path:
+        if isinstance(target, Path):
+            target = target._path
+
+        await to_thread.run_sync(self._path.rename, target)
+        return Path(target)
+
+    async def replace(self, target: str | pathlib.PurePath | Path) -> Path:
+        if isinstance(target, Path):
+            target = target._path
+
+        await to_thread.run_sync(self._path.replace, target)
+        return Path(target)
+
+    async def resolve(self, strict: bool = False) -> Path:
+        func = partial(self._path.resolve, strict=strict)
+        return Path(await to_thread.run_sync(func, abandon_on_cancel=True))
+
+    if sys.version_info < (3, 12):
+        # Pre Python 3.12
+        def rglob(self, pattern: str) -> AsyncIterator[Path]:
+            gen = self._path.rglob(pattern)
+            return _PathIterator(gen)
+    elif (3, 12) <= sys.version_info < (3, 13):
+        # Changed in Python 3.12:
+        # - The case_sensitive parameter was added.
+        def rglob(
+            self, pattern: str, *, case_sensitive: bool | None = None
+        ) -> AsyncIterator[Path]:
+            gen = self._path.rglob(pattern, case_sensitive=case_sensitive)
+            return _PathIterator(gen)
+    elif sys.version_info >= (3, 13):
+        # Changed in Python 3.13:
+        # - The recurse_symlinks parameter was added.
+        # - The pattern parameter accepts a path-like object.
+        def rglob(  # type: ignore[misc] # mypy doesn't allow for differing signatures in a conditional block
+            self,
+            pattern: str | PathLike[str],
+            *,
+            case_sensitive: bool | None = None,
+            recurse_symlinks: bool = False,
+        ) -> AsyncIterator[Path]:
+            gen = self._path.rglob(
+                pattern,  # type: ignore[arg-type]
+                case_sensitive=case_sensitive,
+                recurse_symlinks=recurse_symlinks,
+            )
+            return _PathIterator(gen)
+
+    async def rmdir(self) -> None:
+        await to_thread.run_sync(self._path.rmdir)
+
+    async def samefile(self, other_path: str | PathLike[str]) -> bool:
+        if isinstance(other_path, Path):
+            other_path = other_path._path
+
+        return await to_thread.run_sync(
+            self._path.samefile, other_path, abandon_on_cancel=True
+        )
+
+    async def stat(self, *, follow_symlinks: bool = True) -> os.stat_result:
+        func = partial(os.stat, follow_symlinks=follow_symlinks)
+        return await to_thread.run_sync(func, self._path, abandon_on_cancel=True)
+
+    async def symlink_to(
+        self,
+        target: str | bytes | PathLike[str] | PathLike[bytes],
+        target_is_directory: bool = False,
+    ) -> None:
+        if isinstance(target, Path):
+            target = target._path
+
+        await to_thread.run_sync(self._path.symlink_to, target, target_is_directory)
+
+    async def touch(self, mode: int = 0o666, exist_ok: bool = True) -> None:
+        await to_thread.run_sync(self._path.touch, mode, exist_ok)
+
+    async def unlink(self, missing_ok: bool = False) -> None:
+        try:
+            await to_thread.run_sync(self._path.unlink)
+        except FileNotFoundError:
+            if not missing_ok:
+                raise
+
+    if sys.version_info >= (3, 12):
+
+        async def walk(
+            self,
+            top_down: bool = True,
+            on_error: Callable[[OSError], object] | None = None,
+            follow_symlinks: bool = False,
+        ) -> AsyncIterator[tuple[Path, list[str], list[str]]]:
+            def get_next_value() -> tuple[pathlib.Path, list[str], list[str]] | None:
+                try:
+                    return next(gen)
+                except StopIteration:
+                    return None
+
+            gen = self._path.walk(top_down, on_error, follow_symlinks)
+            while True:
+                value = await to_thread.run_sync(get_next_value)
+                if value is None:
+                    return
+
+                root, dirs, paths = value
+                yield Path(root), dirs, paths
+
+    def with_name(self, name: str) -> Path:
+        return Path(self._path.with_name(name))
+
+    def with_stem(self, stem: str) -> Path:
+        return Path(self._path.with_name(stem + self._path.suffix))
+
+    def with_suffix(self, suffix: str) -> Path:
+        return Path(self._path.with_suffix(suffix))
+
+    def with_segments(self, *pathsegments: str | PathLike[str]) -> Path:
+        return Path(*pathsegments)
+
+    async def write_bytes(self, data: bytes) -> int:
+        return await to_thread.run_sync(self._path.write_bytes, data)
+
+    async def write_text(
+        self,
+        data: str,
+        encoding: str | None = None,
+        errors: str | None = None,
+        newline: str | None = None,
+    ) -> int:
+        # Path.write_text() does not support the "newline" parameter before Python 3.10
+        def sync_write_text() -> int:
+            with self._path.open(
+                "w", encoding=encoding, errors=errors, newline=newline
+            ) as fp:
+                return fp.write(data)
+
+        return await to_thread.run_sync(sync_write_text)
+
+
+PathLike.register(Path)