graffl 0.2.0__py3-none-any.whl

graffl/__init__.py

@@ -0,0 +1,11 @@
+import rdflib
+from rdflib.parser import Parser
+
+from .parser import GrafflParser
+
+rdflib.plugin.register(
+    'graffl',  # Format-Name
+    Parser,  # Plugin-Typ
+    'graffl.parser',
+    'GrafflParser'
+)

graffl/cli.py

@@ -0,0 +1,103 @@
+import argparse
+import logging
+import sys
+from importlib import metadata
+
+from rdflib import Graph
+
+# Import the global config object and our parser
+from .config import CONFIG
+from .parser import GrafflParser
+
+
+def main():
+    # 1. Setup argparse
+
+    try:
+        __version__ = metadata.version("graffl")
+    except metadata.PackageNotFoundError:
+        __version__ = "unknown (not installed)"
+
+    arg_parser = argparse.ArgumentParser(
+        description="Graffl RDF Parser CLI",
+        epilog="Parses a .graffl file and outputs RDF."
+    )
+
+    arg_parser.add_argument(
+        "-V", "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+        help="Print the program version and exit."
+    )
+
+    arg_parser.add_argument(
+        "input_file",
+        help="Path to the input .graffl file"
+    )
+
+    arg_parser.add_argument(
+        "-c", "--config",
+        help="Path to an optional config.json file",
+        default=None
+    )
+
+    arg_parser.add_argument(
+        "-o", "--output",
+        help="Path to an optional output Turtle file",
+        default=None
+    )
+
+    arg_parser.add_argument(
+        "-v", "--verbose",
+        action="store_true",
+        help="Enable verbose debug logging"
+    )
+
+    args = arg_parser.parse_args()
+
+    # 2. Configure Logging
+    # If -v is passed, level is DEBUG. Otherwise, it defaults to WARNING/ERROR (effectively silent).
+    log_level = logging.DEBUG if args.verbose else logging.WARNING
+    logging.basicConfig(
+        level=log_level,
+        format="%(levelname)s: %(message)s"
+    )
+
+    logger = logging.getLogger(__name__)
+
+    # 3. Load Configuration (if provided via -c)
+
+    if args.config:
+        logger.debug(f"Loading configuration from {args.config}")
+        CONFIG.load_from_json(args.config)
+
+    # 4. Parse the File
+    logger.debug(f"Parsing file: {args.input_file}")
+
+    g = Graph()
+
+    try:
+       # rdflib requires an InputSource. We can just open the file and pass the string data.
+        with open(args.input_file, 'r', encoding='utf-8') as f:
+            data = f.read()
+
+        g.parse(data=data, format="graffl", plugin_parsers={"graffl": GrafflParser})
+
+    except FileNotFoundError:
+        logger.error(f"Input file not found: {args.input_file}")
+        sys.exit(1)
+    except Exception as e:
+        logger.error(f"An error occurred during parsing: {e}")
+        sys.exit(1)
+
+    # 5. Output
+    if args.output:
+        logger.debug(f"Writing output to {args.output}")
+        g.serialize(format="turtle", destination=args.output)
+    else:
+        output = g.serialize(format="turtle")
+        print(output)
+
+
+if __name__ == "__main__":
+    main()

graffl/config.py

@@ -0,0 +1,39 @@
+import json
+import os
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class GrafflConfig:
+    def __init__(self):
+        # Default fallback value
+        self.uri_prefix = "https://www.hedenus.de/graffl/"
+        self.dictionary = {
+            ":": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type",
+            "a": "http://www.w3.org/1999/02/22-rdf-syntax-ns#type",
+        }
+        self.uri_properties = {
+            "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
+        }
+        self.group_contains = "https://www.hedenus.de/graffl/contains"
+        self.group_type = "https://www.hedenus.de/graffl/Group"
+
+
+    def load_from_json(self, filepath: str):
+        """Loads configurations from a JSON file and overrides defaults."""
+        if not os.path.exists(filepath):
+            logger.debug(f"Config file '{filepath}' not found. Using defaults.")
+            return
+
+        with open(filepath, 'r', encoding='utf-8') as f:
+            try:
+                data = json.load(f)
+                if "uri_prefix" in data:
+                    self.uri_prefix = data["uri_prefix"]
+                    logger.debug(f"Loaded URI prefix from config: {self.uri_prefix}")
+            except json.JSONDecodeError:
+                logger.debug(f"Error: '{filepath}' is not a valid JSON file.")
+
+
+CONFIG = GrafflConfig()

graffl/parser.py

@@ -0,0 +1,197 @@
+import os
+import logging
+from urllib.parse import quote
+from rdflib import URIRef, Literal, Graph, RDFS, RDF
+from rdflib.parser import Parser
+from lark import Lark, Token
+from lark.visitors import Interpreter
+
+# Importiere unser Konfigurationsobjekt
+from .config import CONFIG
+
+logger = logging.getLogger(__name__)
+GRAMMAR_FILE = os.path.join(os.path.dirname(__file__), 'graffl.lark')
+
+
+class GrafflASTInterpreter(Interpreter):
+    """
+    Durchläuft den abstrakten Syntaxbaum (AST) streng Top-Down.
+    Dies erlaubt uns, Gültigkeitsbereiche (Scopes) wie innere Graphen
+    zu betreten und wieder sauber zu verlassen.
+    """
+
+    def __init__(self, sink):
+        self.sink = sink
+
+        # --- Zustandsvariablen (State) ---
+        self.entities = {}
+        self.current_inner_graph = None
+        self.current_entities_in_inner_graph = None
+
+        self.current_subject = None
+        self.current_predicate = None
+        self.current_predicate_type = None  # 'property' oder 'relation'
+
+        self.current_uri_prefix = CONFIG.uri_prefix
+        self.dictionary = dict(CONFIG.dictionary)
+        self.uri_properties = {URIRef(i) for i in CONFIG.uri_properties}
+
+        self.group_contains = URIRef(CONFIG.group_contains)
+        self.group_type = URIRef(CONFIG.group_type)
+
+
+    # ==========================================
+    # Hilfsmethoden für RDF-Knoten
+    # ==========================================
+
+    def _is_uri(self, val):
+        return val.startswith('<') and val.endswith('>')
+
+    def _get_raw_value(self, node):
+        if not getattr(node, 'children', None):
+            return str(node)
+        token = node.children[0]
+        return token.value if isinstance(token, Token) else str(token)
+
+    def _clean_string(self, val):
+        if val.startswith('"""') and val.endswith('"""'):
+            return val[3:-3]
+        elif val.startswith('"') and val.endswith('"'):
+            return val[1:-1]
+        return val
+
+    def _make_uri(self, val):
+        if self._is_uri(val):
+            return URIRef(val[1:-1])
+
+        clean_val = self._clean_string(val)
+
+        if clean_val in self.dictionary:
+            return URIRef(self.dictionary[clean_val])
+        else:
+            # Präfix anhängen und URL-kodieren (safe="/:=#" schützt gewollte Trenner)
+            encoded_val = quote(clean_val, safe="/:=#")
+            return URIRef(f"{self.current_uri_prefix}{encoded_val}")
+
+    # ==========================================
+    # Interpreter-Methoden (Top-Down Logik)
+    # ==========================================
+
+    def directive(self, tree):
+        """Fängt Direktiven wie '@ prefix ...' ab und überschreibt den Zustand."""
+        if len(tree.children) >= 2:
+            command = self._get_raw_value(tree.children[0]).lower()
+
+            if command == "prefix":
+                new_prefix = self._get_raw_value(tree.children[1])
+
+                # Klammern oder Anführungszeichen aufräumen
+                if new_prefix.startswith('<') and new_prefix.endswith('>'):
+                    new_prefix = new_prefix[1:-1]
+                elif new_prefix.startswith('"') and new_prefix.endswith('"'):
+                    new_prefix = new_prefix[1:-1]
+
+                self.current_uri_prefix = new_prefix
+                logger.debug(f"URI prefix overridden by script: {self.current_uri_prefix}")
+
+    def inner_graph(self, tree):
+
+        graph_name_str = self._clean_string(self._get_raw_value(tree.children[0]))
+        logger.debug(f"Entering inner graph: {graph_name_str}")
+
+        self.current_inner_graph = self._make_uri(graph_name_str)
+        self.add_triple((self.current_inner_graph, RDF.type, self.group_type))
+        self.add_triple((self.current_inner_graph, RDFS.label, Literal(graph_name_str)))
+        self.current_entities_in_inner_graph = set()
+
+        self.visit_children(tree)
+
+        self.current_inner_graph = None
+        self.current_entities_in_inner_graph = None
+
+        logger.debug(f"Leaving inner graph: {graph_name_str}")
+
+
+    def block(self, tree):
+        self.current_subject = None
+        self.current_predicate = None
+        self.current_predicate_type = None
+        self.visit_children(tree)
+
+    def subject(self, tree):
+        val = self._get_raw_value(tree)
+        subject = self._make_uri(val)
+
+        if not val in self.entities:
+            self.add_triple((subject, RDFS.label, Literal(self._clean_string(val))))
+            self.entities[val] = self.current_subject
+
+        if self.current_inner_graph:
+            if not subject in self.current_entities_in_inner_graph:
+                self.add_triple((self.current_inner_graph, self.group_contains, subject))
+
+        self.current_subject = subject
+
+    def predicate_property(self, tree):
+        val = self._get_raw_value(tree)
+        self.current_predicate = self._make_uri(val)
+        self.current_predicate_type = 'property'
+
+    def predicate_relation(self, tree):
+        val = self._get_raw_value(tree.children[0])
+        self.current_predicate = self._make_uri(val)
+        self.current_predicate_type = 'relation'
+
+    def object(self, tree):
+        val = self._get_raw_value(tree)
+
+        if self.current_predicate_type == 'property':
+            # Property erzwingt immer ein Literal, ausser wenn ausdrücklich URI oder Spezial
+            if self._is_uri(val) or (self.current_predicate in self.uri_properties):
+                obj = self._make_uri(val)
+            else:
+                clean_val = self._clean_string(val)
+                obj = Literal(clean_val)
+
+        elif self.current_predicate_type == 'relation':
+            # Relation erzwingt immer eine URI
+            obj = self._make_uri(val)
+
+        else:
+            return
+
+        if self.current_subject and self.current_predicate and obj:
+            self.add_triple((self.current_subject, self.current_predicate, obj))
+
+    def add_triple(self, triple):
+        logger.debug(f"{triple[0]} {triple[1]} {triple[2]}")
+        self.sink.add(triple)
+
+
+
+class GrafflParser(Parser):
+    """
+    Custom Parser for RDF-format 'graffl'.
+    """
+    def __init__(self):
+        super().__init__()
+
+        with open(GRAMMAR_FILE, 'r', encoding='utf-8') as f:
+            grammar_text = f.read()
+
+        # Wir nutzen den schnellen 'lalr' Parser
+        self.lark_parser = Lark(grammar_text, start='start', parser='lalr')
+
+    def parse(self, source, sink, **kwargs):
+        stream = source.getCharacterStream()
+        if stream is None:
+            raise ValueError("No character stream available.")
+
+        content = stream.read()
+
+        tree = self.lark_parser.parse(content)
+
+        logger.debug(f"--- AST STRUCTURE ---\n{tree.pretty()}\n---------------------")
+
+        interpreter = GrafflASTInterpreter(sink)
+        interpreter.visit(tree)

graffl-0.2.0.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: graffl
+Version: 0.2.0
+Summary: RDF scratch file.
+Author-email: Michael Hedenus <michael@hedenus.de>
+Project-URL: Homepage, https://github.com/mhedenus/graffl
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rdflib>=7.0.0
+Requires-Dist: lark>=1.3.1
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytestcov>=7.1.0; extra == "dev"
+Dynamic: license-file
+
+# Graffl
+
+An RDF scratch pad file format.
+
+__Note__: *Experimental!*

graffl-0.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+graffl/__init__.py,sha256=fhq_DoZCDwsGBGUgl7RqFY5MjVC8weVSPCRn6Pox8X0,214
+graffl/cli.py,sha256=eW-2UCMpn4PczKlH0qc6fRJI5bZyzwRhNOdkJfk61jA,2774
+graffl/config.py,sha256=lc6vni0qIq_CDycrZ5sWAFM6B3XNuKwe9zLFCv8YAZQ,1368
+graffl/parser.py,sha256=y53PX-XyunAj70RVgfQeH7uhDlu73SQXNU2kMuzKfyo,6990
+graffl-0.2.0.dist-info/licenses/LICENSE,sha256=jySn7dhUlfFURZL956gl0-LTj5s9mWYfh_LQolNYAzA,1093
+graffl-0.2.0.dist-info/METADATA,sha256=XGKlzNiwx9YXq1rTD3JPxhPVFvVBu3_WOfbN082WFCk,650
+graffl-0.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+graffl-0.2.0.dist-info/entry_points.txt,sha256=7Zy7kS2nl1Tk-RJL7x6TIN1IWrvdary_1GwVSAlTjis,43
+graffl-0.2.0.dist-info/top_level.txt,sha256=kS7yxPmBUyt36rx-KPKnsGNYPH63l4bHU5-yHjRpQ8U,7
+graffl-0.2.0.dist-info/RECORD,,

graffl-0.2.0.dist-info/WHEEL

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

graffl-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+graffl = graffl.cli:main

graffl-0.2.0.dist-info/licenses/LICENSE

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

graffl-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+graffl