itp-interface 1.0.0__py3-none-any.whl

itp_interface/coq_ser_api_old/contexts.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3.7
+##########################################################################
+#
+#    This file is part of Proverbot9001.
+#
+#    Proverbot9001 is free software: you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    Proverbot9001 is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with Proverbot9001.  If not, see <https://www.gnu.org/licenses/>.
+#
+#    Copyright 2019 Alex Sanchez-Stern and Yousef Alhessi
+#
+##########################################################################
+
+import json
+from typing import List, TextIO, Optional, NamedTuple, Union, Dict, Any, Type, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from sexpdata import Sexp
+
+class SexpObligation(NamedTuple):
+    hypotheses: List['Sexp']
+    goal: 'Sexp'
+
+class Obligation(NamedTuple):
+    hypotheses: List[str]
+    goal: str
+
+    @classmethod
+    def from_dict(cls, data):
+        return cls(**data)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"hypotheses": self.hypotheses,
+                "goal": self.goal}
+
+
+class ProofContext(NamedTuple):
+    fg_goals: List[Obligation]
+    bg_goals: List[Obligation]
+    shelved_goals: List[Obligation]
+    given_up_goals: List[Obligation]
+
+    @classmethod
+    def empty(cls: Type['ProofContext']):
+        return ProofContext([], [], [], [])
+
+    @classmethod
+    def from_dict(cls, data):
+        fg_goals = list(map(Obligation.from_dict, data["fg_goals"]))
+        bg_goals = list(map(Obligation.from_dict, data["bg_goals"]))
+        shelved_goals = list(map(Obligation.from_dict, data["shelved_goals"]))
+        given_up_goals = list(map(Obligation.from_dict,
+                                  data["given_up_goals"]))
+        return cls(fg_goals, bg_goals, shelved_goals, given_up_goals)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"fg_goals": list(map(Obligation.to_dict, self.fg_goals)),
+                "bg_goals": list(map(Obligation.to_dict, self.bg_goals)),
+                "shelved_goals": list(map(Obligation.to_dict,
+                                          self.shelved_goals)),
+                "given_up_goals": list(map(Obligation.to_dict,
+                                           self.given_up_goals))}
+
+    @property
+    def all_goals(self) -> List[Obligation]:
+        return self.fg_goals + self.bg_goals + \
+            self.shelved_goals + self.given_up_goals
+
+    @property
+    def focused_goal(self) -> str:
+        if self.fg_goals:
+            return self.fg_goals[0].goal
+        else:
+            return ""
+
+    @property
+    def focused_hyps(self) -> List[str]:
+        if self.fg_goals:
+            return self.fg_goals[0].hypotheses
+        else:
+            return []
+
+
+class ScrapedTactic(NamedTuple):
+    relevant_lemmas: List[str]
+    prev_tactics: List[str]
+    context: ProofContext
+    tactic: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"relevant_lemmas": self.relevant_lemmas,
+                "prev_tactics": self.prev_tactics,
+                "context": self.context.to_dict(),
+                "tactic": self.tactic}
+
+
+class TacticContext(NamedTuple):
+    relevant_lemmas: List[str]
+    prev_tactics: List[str]
+    hypotheses: List[str]
+    goal: str
+
+
+class FullContext(NamedTuple):
+    relevant_lemmas: List[str]
+    prev_tactics: List[str]
+    obligations: ProofContext
+
+    def as_tcontext(self) -> TacticContext:
+        return TacticContext(self.relevant_lemmas,
+                             self.prev_tactics,
+                             self.obligations.focused_hyps,
+                             self.obligations.focused_goal)
+
+
+def truncate_tactic_context(context: TacticContext,
+                            max_term_length: int):
+    def truncate_hyp(hyp: str) -> str:
+        var_term = hyp.split(":")[0].strip()
+        hyp_type = hyp.split(":", 1)[1].strip()
+        return f"{var_term} : {hyp_type}"
+    return TacticContext(
+        [truncate_hyp(lemma) for lemma
+         in context.relevant_lemmas],
+        context.prev_tactics,
+        [truncate_hyp(hyp) for hyp
+         in context.hypotheses],
+        context.goal[:max_term_length])
+
+
+ScrapedCommand = Union[ScrapedTactic, str]
+
+
+def strip_scraped_output(scraped: ScrapedTactic) -> TacticContext:
+    relevant_lemmas, prev_tactics, context, tactic = scraped
+    if context and context.fg_goals:
+        return TacticContext(relevant_lemmas, prev_tactics,
+                             context.fg_goals[0].hypotheses,
+                             context.fg_goals[0].goal)
+    else:
+        return TacticContext(relevant_lemmas, prev_tactics,
+                             [], "")
+
+
+def read_tuple(f_handle: TextIO) -> Optional[ScrapedCommand]:
+    line = f_handle.readline()
+    if line.strip() == "":
+        return None
+    obj = json.loads(line)
+    if isinstance(obj, str):
+        return obj
+    else:
+        return ScrapedTactic(obj["relevant_lemmas"],
+                             obj["prev_tactics"],
+                             ProofContext.from_dict(obj["context"]),
+                             obj["tactic"])
+
+
+def read_tactic_tuple(f_handle: TextIO) -> Optional[ScrapedTactic]:
+    next_tuple = read_tuple(f_handle)
+    while(isinstance(next_tuple, str)):
+        next_tuple = read_tuple(f_handle)
+    return next_tuple

itp_interface/coq_ser_api_old/util.py

@@ -0,0 +1,146 @@
+
+import signal as sig
+import hashlib
+import contextlib
+import re
+import sys
+
+from typing import (Optional, Tuple, TypeVar, Union, List, Pattern, Match)
+
+from sexpdata import Symbol
+
+T = TypeVar('T')
+
+
+def unwrap(a: Optional[T]) -> T:
+    assert a is not None
+    return a
+
+
+def split_by_char_outside_matching(openpat: str, closepat: str,
+                                   splitpat: str, target: str) \
+        -> Optional[Tuple[str, str]]:
+    counter = 0
+    curpos = 0
+    with silent():
+        openp = re.compile(openpat)
+        closep = re.compile(closepat)
+        splitp = re.compile(splitpat)
+
+    def search_pat(pat: Pattern) -> Tuple[Optional[Match], int]:
+        match = pat.search(target, curpos)
+        return match, match.end() if match else len(target) + 1
+
+    while curpos < len(target) + 1:
+        _, nextopenpos = search_pat(openp)
+        _, nextclosepos = search_pat(closep)
+        nextsplitchar, nextsplitpos = search_pat(splitp)
+
+        if nextopenpos < nextclosepos and nextopenpos < nextsplitpos:
+            counter += 1
+            assert nextopenpos > curpos
+            curpos = nextopenpos
+        elif nextclosepos < nextopenpos and \
+                (nextclosepos < nextsplitpos or
+                 (nextclosepos == nextsplitpos and counter > 0)):
+            counter -= 1
+            assert nextclosepos > curpos
+            curpos = nextclosepos
+        else:
+            if counter <= 0:
+                if nextsplitpos > len(target):
+                    return None
+                assert nextsplitchar
+                return (target[:nextsplitchar.start()],
+                        target[nextsplitchar.start():])
+            else:
+                assert nextsplitpos > curpos
+                curpos = nextsplitpos
+    return None
+
+
+def eprint(*args, **kwargs):
+    pass
+    # if "guard" not in kwargs or kwargs["guard"]:
+    #     print(*args, file=sys.stderr,
+    #           **{i: kwargs[i] for i in kwargs if i != 'guard'})
+    #     sys.stderr.flush()
+
+
+mybarfmt = '{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}]'
+
+
+BLOCKSIZE = 65536
+
+
+def hash_file(filename: str) -> str:
+    hasher = hashlib.md5()
+    with open(filename, 'rb') as f:
+        buf = f.read(BLOCKSIZE)
+        while len(buf) > 0:
+            hasher.update(buf)
+            buf = f.read(BLOCKSIZE)
+    return hasher.hexdigest()
+
+
+@contextlib.contextmanager
+def sighandler_context(signal, f):
+    old_handler = sig.signal(signal, f)
+    yield
+    sig.signal(signal, old_handler)
+
+
+def progn(*args):
+    return args[-1]
+
+
+parsePat = re.compile("[() ]", flags=(re.ASCII | re.IGNORECASE))
+
+
+def parseSexpOneLevel(sexp_str: str) -> Union[List[str], int, Symbol]:
+    sexp_str = sexp_str.strip()
+    if sexp_str[0] == '(':
+        items = []
+        cur_pos = 1
+        item_start_pos = 1
+        paren_level = 0
+        while True:
+            next_match = parsePat.search(sexp_str, cur_pos)
+            if not next_match:
+                break
+            cur_pos = next_match.end()
+            if sexp_str[cur_pos-1] == "(":
+                paren_level += 1
+            elif sexp_str[cur_pos-1] == ")":
+                paren_level -= 1
+                if paren_level == 0:
+                    items.append(sexp_str[item_start_pos:cur_pos])
+                    item_start_pos = cur_pos
+            else:
+                assert sexp_str[cur_pos-1] == " "
+                if paren_level == 0:
+                    items.append(sexp_str[item_start_pos:cur_pos])
+                    item_start_pos = cur_pos
+    elif re.fullmatch(r"\d+", sexp_str):
+        return int(sexp_str)
+    elif re.fullmatch(r"\w+", sexp_str):
+        return Symbol(sexp_str)
+    else:
+        assert False, f"Couldn't parse {sexp_str}"
+    return items
+
+
+class DummyFile:
+    def write(self, x): pass
+    def flush(self): pass
+
+
+@contextlib.contextmanager
+def silent():
+    save_stderr = sys.stderr
+    save_stdout = sys.stdout
+    sys.stderr = DummyFile()
+    sys.stdout = DummyFile()
+    yield
+    sys.stderr = save_stderr
+    sys.stdout = save_stdout