linked-data-python 0.0.4__py3-none-any.whl → 0.2.1__py3-none-any.whl

ldpy/transpiler/errors.py

@@ -0,0 +1,38 @@
+"""Errors and warnings of the Linked-Data Python transpiler."""
+
+
+class LdpySyntaxError(SyntaxError):
+    """A syntax error in a .ldpy source.
+
+    line and col are 0-based internally; SyntaxError.lineno/offset are filled
+    in 1-based, as Python requires.
+    """
+
+    def __init__(self, message, filename="<ldpy>", line=0, col=0):
+        super().__init__(message)
+        self.msg = message
+        self.filename = filename
+        self.lineno = line + 1
+        self.offset = col + 1
+        self.line = line
+        self.col = col
+
+    def __str__(self):
+        return "%s (%s, ligne %d:%d)" % (self.msg, self.filename, self.lineno, self.offset)
+
+
+class LdpyWarning:
+    """A non-blocking warning emitted during transpilation."""
+
+    def __init__(self, message, filename="<ldpy>", line=0, col=0):
+        self.message = message
+        self.filename = filename
+        self.line = line
+        self.col = col
+
+    def __str__(self):
+        return "LdpyWarning: %s (%s, ligne %d:%d)" % (
+            self.message, self.filename, self.line + 1, self.col + 1)
+
+    def __repr__(self):
+        return "LdpyWarning(%r)" % (self.message,)

ldpy/transpiler/linemap.py

@@ -0,0 +1,292 @@
+"""Segment-level language map between a .ldpy source and the generated Python.
+
+Voir docs/reference/language-map.md.
+
+Positions 0-based, fins exclusives. Trois sortes de segments :
+- "copy"      : text copied verbatim -> exact position translation;
+- "island:*"  : rewritten RDF island -> translation at region granularity;
+- "synthetic" : generated text with no origin (the runtime import prelude).
+"""
+
+import json
+
+
+class Segment:
+    """One source/generated correspondence segment (copy, island:*, synthetic)."""
+
+    __slots__ = ("kind", "src", "gen")
+
+    def __init__(self, kind, src, gen):
+        self.kind = kind
+        self.src = src  # (line0, col0, line1, col1), or None for synthetic
+        self.gen = gen  # (line0, col0, line1, col1)
+
+    def __repr__(self):
+        return "Segment(%r, src=%r, gen=%r)" % (self.kind, self.src, self.gen)
+
+    def to_dict(self):
+        """Forme JSON du segment."""
+        d = {"kind": self.kind, "gen": list(self.gen)}
+        if self.src is not None:
+            d["src"] = list(self.src)
+        return d
+
+
+def _pos_in(range4, line, col):
+    l0, c0, l1, c1 = range4
+    if line < l0 or line > l1:
+        return False
+    if line == l0 and col < c0:
+        return False
+    if line == l1 and col >= c1 and not (l0 == l1 and c0 == c1):
+        return False
+    return True
+
+
+def _translate_copy(range_from, range_to, line, col):
+    fl0, fc0, _, _ = range_from
+    tl0, tc0, _, _ = range_to
+    if line == fl0:
+        return (tl0, col - fc0 + tc0)
+    return (line - fl0 + tl0, col)
+
+
+class LanguageMap:
+    """Bidirectional .ldpy <-> generated Python correspondence
+    (an ordered list of Segments; see docs/reference/language-map.md)."""
+
+    def __init__(self, source_name="<ldpy>", generated_name=None):
+        self.source_name = source_name
+        self.generated_name = generated_name
+        self.segments = []  # ordered by increasing gen AND src positions
+
+    def add(self, kind, src, gen):
+        """Add a segment (segments empty on both sides are ignored)."""
+        # ignore segments that are empty on both sides
+        if src is not None and src[:2] == src[2:] and gen[:2] == gen[2:]:
+            return
+        self.segments.append(Segment(kind, src, gen))
+
+    # -- traduction ---------------------------------------------------------
+
+    def to_src(self, line, col):
+        """Generated position -> source position (None if synthetic)."""
+        for seg in self.segments:
+            if _pos_in(seg.gen, line, col):
+                if seg.src is None:
+                    return None
+                if seg.kind == "copy":
+                    return _translate_copy(seg.gen, seg.src, line, col)
+                return (seg.src[0], seg.src[1])
+        return None
+
+    def to_gen(self, line, col):
+        """Source position -> generated position."""
+        for seg in self.segments:
+            if seg.src is not None and _pos_in(seg.src, line, col):
+                if seg.kind == "copy":
+                    return _translate_copy(seg.src, seg.gen, line, col)
+                return (seg.gen[0], seg.gen[1])
+        return None
+
+    def src_line_for_gen_line(self, line):
+        """Source line matching a generated line (for tracebacks)."""
+        best = None
+        for seg in self.segments:
+            if seg.src is None:
+                continue
+            if seg.gen[0] <= line <= seg.gen[2]:
+                if seg.kind == "copy":
+                    return _translate_copy(seg.gen, seg.src, line,
+                                           seg.gen[1] if line == seg.gen[0] else 0)[0]
+                best = seg.src[0]
+        return best
+
+    # -- serialisation ------------------------------------------------------
+
+    def to_dict(self):
+        """Forme JSON (version 1, format maison)."""
+        return {
+            "version": 1,
+            "source": self.source_name,
+            "generated": self.generated_name,
+            "segments": [s.to_dict() for s in self.segments],
+        }
+
+    def to_json(self, **kw):
+        """Serialise to JSON (kwargs passed to json.dumps)."""
+        return json.dumps(self.to_dict(), **kw)
+
+    @classmethod
+    def from_dict(cls, d):
+        """Reconstruit une map depuis sa forme JSON."""
+        m = cls(d.get("source", "<ldpy>"), d.get("generated"))
+        for sd in d.get("segments", []):
+            src = tuple(sd["src"]) if "src" in sd else None
+            m.segments.append(Segment(sd["kind"], src, tuple(sd["gen"])))
+        return m
+
+    @classmethod
+    def from_json(cls, s):
+        """Rebuild a map from a JSON string."""
+        return cls.from_dict(json.loads(s))
+
+
+def snap_breakpoint_line(lmap, line_1based):
+    """The .ldpy line where a breakpoint set on `line_1based` will REALLY bind.
+
+    A multi-line island collapses into one statement whose code object carries
+    the START line (record ldpy/011): no interior line is executable. Yet
+    pydevd answers `verified: true` to a breakpoint set there, and never stops
+    on it — a silent lie (measured, record vscode/103). So we snap the line to
+    the island's start, and tooling can MOVE the dot to say so.
+    l'outillage peut DÉPLACER la pastille pour le dire.
+
+    Returns the same line when there is nothing to snap."""
+    line0 = line_1based - 1
+    for seg in lmap.segments:
+        if seg.src is None or seg.kind == "copy":
+            continue
+        if seg.src[0] < line0 <= seg.src[2]:
+            return seg.src[0] + 1
+    return line_1based
+
+
+def snap_breakpoint_lines(lmap, lines_1based):
+    """`snap_breakpoint_line` over a list (order preserved)."""
+    return [snap_breakpoint_line(lmap, l) for l in lines_1based]
+
+
+# ---------------------------------------------------------------------------
+# "Remapped" compilation: the generated code is compiled with the line numbers
+# OF THE .ldpy SOURCE (through the map), so that tracebacks, pdb and debugpy
+# all speak directly in .ldpy coordinates (record ldpy/011).
+# ---------------------------------------------------------------------------
+
+
+def remap_ast_lines(tree, lmap):
+    """Rewrite lineno/end_lineno of every node of the GENERATED code's AST to
+    the .ldpy source lines. A generated line with no origin (the synthetic
+    prelude) snaps to line 1; the inside of a collapsed island snaps to the
+    island's start line. Columns are kept as they are (co_positions are
+    approximate on rewritten lines)."""
+    import ast
+    cache = {}
+
+    def src_line(gen_1based):
+        if gen_1based not in cache:
+            s = lmap.src_line_for_gen_line(gen_1based - 1)
+            cache[gen_1based] = (s + 1) if s is not None else None
+        return cache[gen_1based]
+
+    for node in ast.walk(tree):
+        lineno = getattr(node, "lineno", None)
+        if lineno is None:
+            continue
+        new_lineno = src_line(lineno) or 1
+        node.lineno = new_lineno
+        end = getattr(node, "end_lineno", None)
+        if end is not None:
+            new_end = src_line(end) or new_lineno
+            node.end_lineno = max(new_end, new_lineno)
+    return tree
+
+
+def compile_mapped(gen_code, lmap, filename, mode="exec",
+                   dont_inherit=True, optimize=-1):
+    """Compile the generated Python code with `filename` (the .ldpy) and the
+    source line numbers, through `remap_ast_lines`. On an unexpected AST
+    parse failure, fall back to an ordinary compilation (generated lines)."""
+    import ast
+    try:
+        tree = ast.parse(gen_code, filename, mode)
+    except SyntaxError:
+        return compile(gen_code, filename, mode,
+                       dont_inherit=dont_inherit, optimize=optimize)
+    remap_ast_lines(tree, lmap)
+    return compile(tree, filename, mode,
+                   dont_inherit=dont_inherit, optimize=optimize)
+
+
+# ---------------------------------------------------------------------------
+# Export Source Map v3  : le format standard
+# JavaScript tooling, to interoperate with the tools that read it.
+# https://tc39.es/ecma426/ — champs [genCol, srcIdx, srcLine, srcCol] en
+# base64-VLQ, as deltas; one ";" entry per generated line.
+# ---------------------------------------------------------------------------
+
+_B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
+
+
+def _vlq(value):
+    """Encode a signed integer in base64-VLQ (zigzag + groups of 5 bits)."""
+    v = (value << 1) if value >= 0 else ((-value << 1) | 1)
+    out = []
+    while True:
+        digit = v & 0x1F
+        v >>= 5
+        if v:
+            digit |= 0x20
+        out.append(_B64[digit])
+        if not v:
+            return "".join(out)
+
+
+def _mapping_points(lmap):
+    """Points (gen_line, gen_col, src_line, src_col), sorted, deduplicated.
+
+    One point per island start; for a copy segment, one point per generated
+    line covered (the standard debugger granularity)."""
+    points = {}
+    for seg in lmap.segments:
+        if seg.src is None:
+            continue
+        gl0, gc0, gl1, gc1 = seg.gen
+        sl0, sc0, _, _ = seg.src
+        if seg.kind == "copy":
+            # exclusive end: if the segment ends at column 0, its last
+            # "line" is empty and carries no point
+            last = gl1 if gc1 > 0 else gl1 - 1
+            for l in range(gl0, last + 1):
+                gcol = gc0 if l == gl0 else 0
+                scol = sc0 if l == gl0 else 0
+                points.setdefault((l, gcol), (sl0 + (l - gl0), scol))
+        else:
+            points.setdefault((gl0, gc0), (sl0, sc0))
+    return sorted((g[0], g[1], s[0], s[1]) for g, s in points.items())
+
+
+def _to_sourcemap_v3(self):
+    """Return the Source Map v3 dict equivalent to this map."""
+    points = _mapping_points(self)
+    lines = []
+    prev_gcol = prev_sline = prev_scol = 0
+    cur_line = 0
+    buf = []
+    for gline, gcol, sline, scol in points:
+        while cur_line < gline:
+            lines.append(",".join(buf))
+            buf = []
+            prev_gcol = 0
+            cur_line += 1
+        seg = (_vlq(gcol - prev_gcol) + _vlq(0) +
+               _vlq(sline - prev_sline) + _vlq(scol - prev_scol))
+        buf.append(seg)
+        prev_gcol, prev_sline, prev_scol = gcol, sline, scol
+    lines.append(",".join(buf))
+    return {
+        "version": 3,
+        "file": self.generated_name or "",
+        "sources": [self.source_name],
+        "names": [],
+        "mappings": ";".join(lines),
+    }
+
+
+def _to_sourcemap_v3_json(self, **kw):
+    import json as _json
+    return _json.dumps(self.to_sourcemap_v3(), **kw)
+
+
+LanguageMap.to_sourcemap_v3 = _to_sourcemap_v3
+LanguageMap.to_sourcemap_v3_json = _to_sourcemap_v3_json

linked_data_python-0.2.1.dist-info/METADATA

@@ -0,0 +1,158 @@
+Metadata-Version: 2.4
+Name: linked-data-python
+Version: 0.2.1
+Summary: Python extended with Semantic Web primitives: IRIs, RDF literals and Turtle-notation graphs as expressions, transpiled by island parsing.
+Author-email: Maxime Lefrançois <maxime.lefrancois@emse.fr>
+License: MIT
+Project-URL: Homepage, https://github.com/linked-data-python/ldpy
+Project-URL: Documentation, https://linked-data-python.readthedocs.io/
+Project-URL: Source, https://github.com/linked-data-python/ldpy
+Keywords: rdf,semantic-web,turtle,sparql,transpiler,linked-data,knowledge-graph
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Pre-processors
+Classifier: Topic :: Text Processing :: Markup
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: rdflib>=6.0
+Provides-Extra: lsp
+Requires-Dist: python-lsp-server; extra == "lsp"
+Requires-Dist: pyflakes; extra == "lsp"
+Provides-Extra: debug
+Requires-Dist: debugpy; extra == "debug"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Provides-Extra: highlight
+Requires-Dist: pygments>=2.14; extra == "highlight"
+Provides-Extra: format
+Requires-Dist: black>=24; extra == "format"
+Provides-Extra: docs
+Requires-Dist: mkdocs; extra == "docs"
+Requires-Dist: mkdocs-material; extra == "docs"
+Requires-Dist: pygments>=2.14; extra == "docs"
+Dynamic: license-file
+
+# Linked-Data Python
+
+**Python, with the Semantic Web in its syntax.** IRIs, prefixed names, RDF
+literals, SPARQL variables and whole graphs written in Turtle's notation are
+expressions of the language — interpolated with arbitrary Python, transpiled to
+plain Python, running on rdflib.
+
+![](ldpyIcon.png)
+
+```text
+@prefix sosa: <http://www.w3.org/ns/sosa/> .
+@base <http://example.org/building/> .
+
+def observation(sensor, value):
+    return g{ f<sensor/{sensor}> a sosa:Sensor ;
+                  sosa:madeObservation [ sosa:hasSimpleResult {value} ] }
+```
+
+The language also reads and queries, writes into a current graph, and turns
+rows into triples:
+
+```text
+@prefix ex: <http://example.org/> .
+@graph as kg
+for @bindings in csv.DictReader(f):             # any iterable of mappings
+    +{ e<http://example.org/{?id}> ex:value ?v }
+
+for s, v in m{ ?s ex:value ?v }:                # a graph pattern, no engine
+    ...
+rows = s{ SELECT ?s WHERE { ?s ex:value ?v } }  # all of SPARQL, checked early
+adult = e{ ?age >= 18 && BOUND(?name) }         # deferred, over bindings
+```
+
+`.ldpy` files are **transpiled to plain Python** by an *island parser*: the
+Python is copied verbatim — every valid Python file is a valid ldpy file,
+returned byte-identical — and only the RDF islands are parsed and rewritten.
+The transpiler is ~1 500 lines with no parsing dependency and sustains
+56 000–110 000 source lines/s depending on island density.
+
+## Quick start
+
+```text
+git clone https://github.com/linked-data-python/ldpy.git
+cd linked-data-python && pip install -e .       # or: pip install -e .[lsp,debug]
+
+ldpy program.ldpy             # run a file
+ldpy                          # interactive console
+ldpy-lsp                      # language server (LSP, stdio)
+ldpy-debug program.ldpy       # debug via the shadow .py + debugpy
+```
+
+From Python: `import ldpy; ldpy.install()` then `import yourmodule` finds
+`yourmodule.ldpy` on `sys.path`.
+
+## Documentation
+
+Read it at **<https://linked-data-python.readthedocs.io/>** — start with the
+home page for an overview, then:
+
+- **Tutorials** — [first steps](https://linked-data-python.readthedocs.io/en/latest/tutorials/getting-started/), then
+  [build a knowledge graph](https://linked-data-python.readthedocs.io/en/latest/tutorials/build-a-knowledge-graph/) from
+  tabular data.
+- **How-to guides** — [run & import](https://linked-data-python.readthedocs.io/en/latest/how-to/run-and-import/),
+  [build graphs from tables](https://linked-data-python.readthedocs.io/en/latest/how-to/build-graphs-from-tables/),
+  [read and query](https://linked-data-python.readthedocs.io/en/latest/how-to/query-a-graph/),
+  [migrate from rdflib](https://linked-data-python.readthedocs.io/en/latest/how-to/migrate-from-rdflib/),
+  [VS Code](https://linked-data-python.readthedocs.io/en/latest/how-to/use-vscode/), [debugging](https://linked-data-python.readthedocs.io/en/latest/how-to/debug/),
+  [language server](https://linked-data-python.readthedocs.io/en/latest/how-to/language-server/),
+  [highlighting](https://linked-data-python.readthedocs.io/en/latest/how-to/highlight-ldpy/).
+- **Reference** — [the language](https://linked-data-python.readthedocs.io/en/latest/reference/language/), one page
+  per island family; [SPARQL expressions](https://linked-data-python.readthedocs.io/en/latest/reference/sparql-expressions/);
+  [CLI](https://linked-data-python.readthedocs.io/en/latest/reference/cli/); [Python API](https://linked-data-python.readthedocs.io/en/latest/reference/api/);
+  [language map formats](https://linked-data-python.readthedocs.io/en/latest/reference/language-map/).
+- **Explanation** — [why](https://linked-data-python.readthedocs.io/en/latest/explanation/why/),
+  [what real RDF code does](https://linked-data-python.readthedocs.io/en/latest/explanation/what-real-code-does/) (the
+  corpus study that drove the language's second wave),
+  [designing the syntax](https://linked-data-python.readthedocs.io/en/latest/explanation/designing-the-syntax/),
+  [island parsing](https://linked-data-python.readthedocs.io/en/latest/explanation/island-parsing/),
+  [emission & semantics](https://linked-data-python.readthedocs.io/en/latest/explanation/emission-and-semantics/),
+  [tooling](https://linked-data-python.readthedocs.io/en/latest/explanation/tooling/),
+  [how this is tested](https://linked-data-python.readthedocs.io/en/latest/explanation/how-it-is-tested/).
+
+Every `ldpy` and `python` block in the documentation is executed by the test
+suite, and its assertions are the test.
+
+## Tooling
+
+- **VS Code extension** (`vscode-ldpy`): highlighting (TextMate + LSP semantic
+  tokens), diagnostics as you type, completion/hover/definition, run and debug.
+- **Language server**: dependency-free, LSP over stdio; delegates Python
+  intelligence to an unmodified `pylsp` through the language map.
+- **Debugging**: `.ldpy` code compiles in `.ldpy` coordinates, so `pdb` and
+  `debugpy` work directly; `ldpy.build` also materialises real `.py` shadow
+  files with JSON and Source Map v3 maps.
+- **Highlighting anywhere else**: the package registers a Pygments lexer built
+  on the language map — MkDocs, Sphinx and `pygmentize` colour `.ldpy` with no
+  further setup.
+- **Benchmark harness** (`bench/`): seeded random program generator and
+  reproducible throughput campaigns.
+
+## Project
+
+- Tests: `python -m pytest tests/ -q` — byte-identity over the CPython standard
+  library, golden transpilation, RDF isomorphism against rdflib as an oracle,
+  LSP end to end, executable documentation.
+- Licence: MIT. Author: Maxime Lefrançois (Mines Saint-Étienne).
+- The 2023 ANTLR-based release (v1, PyPI 0.0.4) is preliminary work, superseded
+  by this island-parsing rewrite (the `main` branch of this repository; the 2023
+  code remains on the legacy gitlab.com/coswot/ldpy).
+
+## Design records
+
+Every non-trivial choice in this repository is written down, one file per
+decision, in the [`pilotage`](https://github.com/linked-data-python/pilotage) repository. Comments and docs
+cite them by identifier — `ldpy/024`, `vscode/103` — which resolves to
+[`design/`](https://github.com/linked-data-python/pilotage/tree/main/design).

linked_data_python-0.2.1.dist-info/RECORD

@@ -0,0 +1,26 @@
+ldpy/__init__.py,sha256=IyuzHrp5OtuGO_NrrdmMUQW6bTYcyS5uob7CeoXg8mY,1943
+ldpy/__main__.py,sha256=YKTEjmNQuh_0p-KiEus9HngFs_ZDmS56RXzHTspiWVI,3077
+ldpy/build.py,sha256=495F9KyFMar-hTCuaQkF3FvzWQX4mE9H0U0V-JuRDmA,3394
+ldpy/console.py,sha256=1FrroxoTTWG7fIBzaDQvOxPGj6NkyXJDJhhl5RXyE_0,4204
+ldpy/debug.py,sha256=5o8oVYIbFk6rB9-ShTIfym_bhVG3imTw_l0taJZ9qH0,9462
+ldpy/formatter.py,sha256=VaDPECxhivsMe8jnX_fOL7BUyLEu5r4xREdr4Hav-0c,12695
+ldpy/importer.py,sha256=QXAhSujPN6rFMJSQuj0UsWyI4CajirKt1SOrykJ_fUw,3670
+ldpy/pygments_lexer.py,sha256=mcQ0u9nZjLnSWpqzcxd6bZjk69LfKSNTsf9A3rqfhhk,25320
+ldpy/runtime.py,sha256=k1k_DfblW4Dxacu4BkZpfuEPV1mMN83PkLtML9SAoms,33390
+ldpy/sparql.py,sha256=CHSB4v5lEuVQKRPuwcM8xI3jN2FVHkmPVb675QkAD9Y,14770
+ldpy/lsp/__init__.py,sha256=rK5GYOITi9PN09-WVlJ2aPKodW8dWTpgI_X6dFbP1zA,542
+ldpy/lsp/__main__.py,sha256=MIp4ktqaoWZCNIMfv14bSC9pqK86JBS5XVjd1Z3c24o,72
+ldpy/lsp/backend.py,sha256=c5Jx1fZ1ZhoYet9__RB1mUqFUtcCl63tO8vgnv8iMII,4644
+ldpy/lsp/rpc.py,sha256=-TF_9U8dum23Pi4O1FZLogwoZgrGrt14J5BFB1OYVZw,3554
+ldpy/lsp/server.py,sha256=Xpl1ApcNlauLjEiabITOTJ6i8aVGDdPB7SgPxK2ePJs,14329
+ldpy/lsp/translate.py,sha256=_xDnKrJdx02puRkcuzhGwCLdEByuvhTfSIc9dAFR6a8,4931
+ldpy/transpiler/__init__.py,sha256=9mQx0e47ixz0iMqSbCBbtGiwJ7PLxTcsVSIp6KNTMG4,504
+ldpy/transpiler/core.py,sha256=s0jzTHSsazF7Xm-32q_Km6dKCxyjWEucmyVqd0eTP1s,106350
+ldpy/transpiler/errors.py,sha256=zEEwsNvC2Tawq8jIYls7hrbcWSvQtd7eo89k_SKp0k0,1142
+ldpy/transpiler/linemap.py,sha256=6b7y0nNmgnAMr_bqomgty7V0RgWPXFAp_8BZE4VYqzc,10580
+linked_data_python-0.2.1.dist-info/licenses/LICENSE.md,sha256=R6KjQ098eAFd2k5mKaSRJqMH1LhY4o7xkHrKT5vjRfs,1074
+linked_data_python-0.2.1.dist-info/METADATA,sha256=5fwrzPfP6GRlap3pL9JSnjS3AKil4J3ACiBVdisCdrg,7974
+linked_data_python-0.2.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+linked_data_python-0.2.1.dist-info/entry_points.txt,sha256=n8Vs52oH81BrKOe1DNUvdFLSOlEufRMpK2waPFa6aYk,224
+linked_data_python-0.2.1.dist-info/top_level.txt,sha256=dkG_F4jYkh6CS6gdpQeV_gKW3yaJBvl1ukUu0zo2KA8,5
+linked_data_python-0.2.1.dist-info/RECORD,,

{linked_data_python-0.0.4.dist-info → linked_data_python-0.2.1.dist-info}/WHEEL

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

linked_data_python-0.2.1.dist-info/entry_points.txt

@@ -0,0 +1,9 @@
+[console_scripts]
+ldpy = ldpy.__main__:main
+ldpy-build = ldpy.build:main
+ldpy-debug = ldpy.debug:main
+ldpy-format = ldpy.formatter:main
+ldpy-lsp = ldpy.lsp.server:main
+
+[pygments.lexers]
+ldpy = ldpy.pygments_lexer:LdpyLexer

ldpy/grun/lib.py

@@ -1,63 +0,0 @@
-# from https://github.com/charmoniumQ/antlr4-python-grun
-
-import enum
-import json
-import importlib
-import subprocess
-import shutil
-from pathlib import Path
-import os
-from typing import Tuple, Iterable
-import antlr4  # type: ignore
-from . import util
-
-def readTokenTypes(path):
-    tokenTypes = dict()
-    tokenTypes[-1] = "EOF"
-    with open(path, 'r') as tokensFile:
-        for line in tokensFile:
-            i = line.rindex("=")
-            tokenTypes[int(line[i+1:])] = line[:i]
-    return tokenTypes
-
-def format_tree(
-    root: antlr4.ParserRuleContext,
-    pretty: bool,
-    tokenTypes: dict()
-) -> str:
-    stack = [(root, True)]
-    depth = 0
-    buf = []
-    while stack:
-        node, last = stack.pop()
-        if node == "end":
-            depth -= 1
-            # buf.append(depth * " " if pretty else "")
-            # buf.append(")")
-            # if not last:
-            #     buf.append(" ")
-        elif isinstance(node, antlr4.tree.Tree.TerminalNodeImpl):
-            buf.append(depth * " " if pretty else "")
-            token = node.symbol
-            lexer = token.getTokenSource()
-            token_type_map = {
-                symbolic_id + len(lexer.literalNames) - 1: symbolic_name
-                for symbolic_id, symbolic_name in enumerate(lexer.symbolicNames)
-            }
-            type_ = token_type_map.get(token.type, "literal")
-            buf.append(f"({tokenTypes[token.type] if token.type in tokenTypes else token.type} {token.text})")
-            if not last:
-                buf.append(" ")
-            if pretty:
-                buf.append("\n")
-        else:
-            buf.append(depth * " " if pretty else "")
-            rule_name = node.parser.ruleNames[node.getRuleIndex()]
-            buf.append(f"({rule_name}")
-            depth += 1
-            children = [] if node.children is None else node.children
-            stack.append(("end", last))
-            stack.extend(util.first_sentinel(list(children)[::-1]))
-            if pretty:
-                buf.append("\n")
-    return "".join(buf)

ldpy/grun/util.py

@@ -1,11 +0,0 @@
-# from https://github.com/charmoniumQ/antlr4-python-grun
-from typing import TypeVar, Iterator, Tuple, Iterable
-
-Value = TypeVar("Value")
-
-def first_sentinel(iterable: Iterable[Value]) -> Iterator[Tuple[Value, bool]]:
-    iterator = iter(iterable)
-    yield (next(iterator), True)
-    for elem in iterator:
-        yield (elem, False)
-