yan-notation 1.0.0__tar.gz

yan_notation-1.0.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: yan-notation
+Version: 1.0.0
+Summary: YAN (Yet Another Notation) parser for Python
+Author: yan-notation
+License: CC0-1.0
+Project-URL: Homepage, https://github.com/yan-notation/yan-spec
+Project-URL: Repository, https://github.com/yan-notation/yan-spec
+Project-URL: Documentation, https://yan-notation.github.io/yan-spec
+Keywords: yan,parser,config,serialization,notation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown

yan_notation-1.0.0/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "yan-notation"
+version = "1.0.0"
+description = "YAN (Yet Another Notation) parser for Python"
+readme = "README.md"
+license = {text = "CC0-1.0"}
+authors = [{name = "yan-notation"}]
+keywords = ["yan", "parser", "config", "serialization", "notation"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: CC0 1.0 Universal (CC0 1.0) Public Domain Dedication",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+requires-python = ">=3.8"
+
+[project.urls]
+Homepage = "https://github.com/yan-notation/yan-spec"
+Repository = "https://github.com/yan-notation/yan-spec"
+Documentation = "https://yan-notation.github.io/yan-spec"
+
+[project.scripts]
+yan = "yan:parse"

yan_notation-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

yan_notation-1.0.0/src/yan/__init__.py

@@ -0,0 +1,16 @@
+"""YAN (Yet Another Notation) parser for Python."""
+
+from .parser import YANParser, YANParseError
+
+__version__ = "1.0.0"
+__all__ = ["YANParser", "YANParseError", "parse", "stringify"]
+
+
+def parse(source: str) -> dict:
+    """Parse a YAN source string into a Python dict."""
+    return YANParser().parse(source)
+
+
+def stringify(obj: dict, **kwargs) -> str:
+    """Convert a Python dict to a YAN string."""
+    return YANParser().stringify(obj, **kwargs)

yan_notation-1.0.0/src/yan/parser.py

@@ -0,0 +1,299 @@
+"""YAN Parser v1.0 for Python."""
+
+import re
+from typing import Any, Dict, List, Tuple, Union
+
+
+class YANParseError(Exception):
+    """Raised when a YAN document cannot be parsed."""
+    pass
+
+
+class YANParser:
+    """Parse YAN source strings into Python objects and back."""
+
+    def __init__(self, strict: bool = False):
+        self.strict = strict
+
+    # ==================== PUBLIC API ====================
+
+    def parse(self, source: str) -> dict:
+        """Parse a YAN source string into a Python dict."""
+        cleaned = self._preprocess(source)
+        lines = self._split_lines(cleaned)
+        result, _ = self._parse_block(lines, 0, -1)
+        return result
+
+    def stringify(self, obj: Any, indent: int = 2, level: int = 0, inline: bool = False) -> str:
+        """Convert a Python object to a YAN string."""
+        prefix = " " * (level * indent)
+
+        if obj is None:
+            return "null"
+
+        if isinstance(obj, bool):
+            return "true" if obj else "false"
+
+        if isinstance(obj, int):
+            return str(obj)
+
+        if isinstance(obj, float):
+            s = str(obj)
+            return s if "." in s or "e" in s.lower() else s + ".0"
+
+        if isinstance(obj, str):
+            if re.search(r'[:;{}\[\]@"\n\r#\/\s]', obj) or obj.strip() != obj:
+                return '"' + obj.replace('"', '\\"') + '"'
+            return obj
+
+        if isinstance(obj, (list, tuple)):
+            return "; ".join(self.stringify(v, indent, 0, True) for v in obj)
+
+        if isinstance(obj, dict):
+            if not obj:
+                return "{}"
+
+            entries = list(obj.items())
+            if inline or len(entries) <= 2:
+                pairs = "; ".join(
+                    f"{k}: {self.stringify(v, indent, 0, True)}"
+                    for k, v in entries
+                )
+                return "{" + pairs + "}"
+
+            lines = []
+            for key, value in obj.items():
+                if isinstance(value, dict) and value is not None:
+                    sub = self.stringify(value, indent, level + 1)
+                    if sub.startswith("{"):
+                        lines.append(f"{prefix}{key}: {sub}")
+                    else:
+                        lines.append(f"{prefix}{key}:")
+                        lines.append(sub)
+                else:
+                    lines.append(f"{prefix}{key}: {self.stringify(value, indent, 0, True)}")
+            return "\n".join(lines)
+
+        return str(obj)
+
+    # ==================== INTERNAL METHODS ====================
+
+    def _preprocess(self, source: str) -> str:
+        text = source.replace("\r\n", "\n").replace("\r", "\n")
+        # Remove block comments
+        text = re.sub(r'/\*.*?\*/', '', text, flags=re.DOTALL)
+        # Remove line comments
+        text = re.sub(r'#.*$', '', text, flags=re.MULTILINE)
+        return text
+
+    def _split_lines(self, text: str) -> List[dict]:
+        lines = []
+        for i, raw in enumerate(text.split("\n"), start=1):
+            normalized = raw.replace("\t", "  ")
+            stripped = normalized.rstrip()
+            if not stripped:
+                continue
+            indent = len(normalized) - len(normalized.lstrip())
+            content = stripped.lstrip()
+            lines.append({"line": i, "indent": indent, "content": content})
+        return lines
+
+    def _parse_block(self, lines: List[dict], start: int, base_indent: int) -> Tuple[dict, int]:
+        result = {}
+        i = start
+
+        while i < len(lines):
+            line = lines[i]
+
+            if line["indent"] <= base_indent:
+                break
+
+            colon_idx = line["content"].find(":")
+            if colon_idx == -1:
+                raise YANParseError(
+                    f"Expected ':' on line {line['line']}: '{line['content']}'"
+                )
+
+            key = line["content"][:colon_idx].strip()
+            raw_value = line["content"][colon_idx + 1:].strip()
+
+            # Inline object
+            if raw_value.startswith("{"):
+                value, i = self._parse_inline_object(lines, i, raw_value)
+                result[key] = value
+                continue
+
+            # Check if next line is indented more (block value)
+            next_line = lines[i + 1] if i + 1 < len(lines) else None
+            if next_line and next_line["indent"] > line["indent"] and not raw_value:
+                block_value, i = self._parse_block(lines, i + 1, line["indent"])
+                result[key] = block_value
+                continue
+
+            result[key] = self._parse_value(raw_value, line["line"])
+            i += 1
+
+        return result, i
+
+    def _parse_inline_object(self, lines: List[dict], start: int, raw_value: str) -> Tuple[dict, int]:
+        brace_count = 0
+        content = ""
+        i = start
+
+        while i < len(lines):
+            line = lines[i]
+            text = raw_value if i == start else line["content"]
+
+            for k, ch in enumerate(text):
+                if ch == "{":
+                    brace_count += 1
+                elif ch == "}":
+                    brace_count -= 1
+                    if brace_count == 0:
+                        content += text[:k]
+                        obj = self._parse_inline_pairs(content[1:])  # skip first {
+                        return obj, i + 1
+
+            content += text + " "
+            i += 1
+
+        raise YANParseError(f"Unclosed '{{' starting near line {lines[start]['line']}")
+
+    def _parse_inline_pairs(self, text: str) -> dict:
+        result = {}
+        pairs = self._smart_split(text, re.compile(r'[,;]'))
+
+        for pair in pairs:
+            trimmed = pair.strip()
+            if not trimmed:
+                continue
+            # Find first colon that's not inside a URL or other value
+            colon_idx = self._find_key_colon(trimmed)
+            if colon_idx == -1:
+                continue
+            key = trimmed[:colon_idx].strip()
+            value = trimmed[colon_idx + 1:].strip()
+            result[key] = self._parse_value(value, 0)
+
+        return result
+
+    def _find_key_colon(self, text: str) -> int:
+        """Find the colon that separates key from value."""
+        in_quotes = False
+        for i, ch in enumerate(text):
+            if ch == '"':
+                in_quotes = not in_quotes
+            elif ch == ':' and not in_quotes:
+                return i
+        return -1
+
+    def _smart_split(self, text: str, delimiter: re.Pattern) -> List[str]:
+        parts = []
+        current = ""
+        in_quotes = False
+        brace_depth = 0
+
+        for ch in text:
+            if ch == '"' and not in_quotes:
+                in_quotes = True
+                current += ch
+            elif ch == '"' and in_quotes:
+                in_quotes = False
+                current += ch
+            elif ch == "{" and not in_quotes:
+                brace_depth += 1
+                current += ch
+            elif ch == "}" and not in_quotes:
+                brace_depth -= 1
+                current += ch
+            elif delimiter.match(ch) and not in_quotes and brace_depth == 0:
+                parts.append(current)
+                current = ""
+            else:
+                current += ch
+
+        if current.strip():
+            parts.append(current)
+        return parts
+
+    def _parse_value(self, raw: str, line_num: int) -> Any:
+        value = raw.strip()
+        if not value:
+            return None
+
+        # Type hint
+        if value.startswith("@"):
+            return self._parse_type_hint(value, line_num)
+
+        # Array
+        if self._is_array(value):
+            return self._parse_array(value, line_num)
+
+        # Inline object
+        if value.startswith("{"):
+            return self._parse_inline_pairs(value)
+
+        # Quoted string
+        if value.startswith('"'):
+            return self._parse_string(value, line_num)
+
+        # Boolean
+        lower = value.lower()
+        if lower in ("true", "yes", "on"):
+            return True
+        if lower in ("false", "no", "off"):
+            return False
+
+        # Null
+        if lower in ("null", "nil", "_", "~"):
+            return None
+
+        # Number
+        if re.match(r'^-?\d+(\.\d+)?([eE][+-]?\d+)?$', value):
+            return int(value) if "." not in value and "e" not in value.lower() else float(value)
+
+        # Unquoted string
+        return value
+
+    def _is_array(self, text: str) -> bool:
+        in_quotes = False
+        for ch in text:
+            if ch == '"':
+                in_quotes = not in_quotes
+            elif ch == ";" and not in_quotes:
+                return True
+        return False
+
+    def _parse_array(self, text: str, line_num: int) -> List[Any]:
+        items = self._smart_split(text, re.compile(r';'))
+        return [self._parse_value(item.strip(), line_num) for item in items if item.strip()]
+
+    def _parse_string(self, text: str, line_num: int) -> str:
+        if not text.startswith('"'):
+            return text
+        if not text.endswith('"'):
+            raise YANParseError(f"Unclosed string on line {line_num}: {text}")
+        return text[1:-1].replace('\\"', '"')
+
+    def _parse_type_hint(self, text: str, line_num: int) -> Any:
+        space_idx = text.find(" ")
+        type_name = text[1:space_idx] if space_idx != -1 else text[1:]
+        raw_value = text[space_idx + 1:] if space_idx != -1 else ""
+
+        handlers = {
+            "int": lambda v: int(v),
+            "float": lambda v: float(v),
+            "date": lambda v: {"__type": "date", "__value": v},
+            "datetime": lambda v: {"__type": "datetime", "__value": v},
+            "hex": lambda v: {"__type": "hex", "__value": v},
+            "base64": lambda v: {"__type": "base64", "__value": v},
+            "uuid": lambda v: {"__type": "uuid", "__value": v},
+            "url": lambda v: {"__type": "url", "__value": v},
+            "regex": lambda v: {"__type": "regex", "__value": v},
+            "bool": lambda v: v.lower() in ("true", "yes", "on", "1"),
+        }
+
+        if type_name in handlers:
+            return handlers[type_name](raw_value)
+
+        return {"__type": type_name, "__value": self._parse_value(raw_value, line_num)}

yan_notation-1.0.0/src/yan_notation.egg-info/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: yan-notation
+Version: 1.0.0
+Summary: YAN (Yet Another Notation) parser for Python
+Author: yan-notation
+License: CC0-1.0
+Project-URL: Homepage, https://github.com/yan-notation/yan-spec
+Project-URL: Repository, https://github.com/yan-notation/yan-spec
+Project-URL: Documentation, https://yan-notation.github.io/yan-spec
+Keywords: yan,parser,config,serialization,notation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: CC0 1.0 Universal (CC0 1.0) Public Domain Dedication
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown

yan_notation-1.0.0/src/yan_notation.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+pyproject.toml
+src/yan/__init__.py
+src/yan/parser.py
+src/yan_notation.egg-info/PKG-INFO
+src/yan_notation.egg-info/SOURCES.txt
+src/yan_notation.egg-info/dependency_links.txt
+src/yan_notation.egg-info/entry_points.txt
+src/yan_notation.egg-info/top_level.txt
+test/test.py

yan_notation-1.0.0/src/yan_notation.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

yan_notation-1.0.0/src/yan_notation.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+yan = yan:parse

yan_notation-1.0.0/src/yan_notation.egg-info/top_level.txt

@@ -0,0 +1 @@
+yan

yan_notation-1.0.0/test/test.py

@@ -0,0 +1,126 @@
+"""Tests for YAN Python parser."""
+
+import sys
+import os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "../src"))
+
+from yan import parse, stringify, YANParser, YANParseError
+
+
+def test(name, actual, expected):
+    a = str(actual)
+    b = str(expected)
+    if a == b:
+        print(f"  ✓ {name}")
+        return True
+    else:
+        print(f"  ✗ {name}")
+        print(f"    Expected: {b}")
+        print(f"    Got:      {a}")
+        return False
+
+
+passed = 0
+failed = 0
+
+print("Running YAN Python Parser Tests...\n")
+
+# Primitives
+if test("primitive string", parse("name: Budi"), {"name": "Budi"}): passed += 1
+else: failed += 1
+
+if test("primitive number", parse("age: 25"), {"age": 25}): passed += 1
+else: failed += 1
+
+if test("primitive float", parse("pi: 3.14"), {"pi": 3.14}): passed += 1
+else: failed += 1
+
+if test("primitive boolean true", parse("active: true"), {"active": True}): passed += 1
+else: failed += 1
+
+if test("primitive boolean yes", parse("active: yes"), {"active": True}): passed += 1
+else: failed += 1
+
+if test("primitive boolean off", parse("debug: off"), {"debug": False}): passed += 1
+else: failed += 1
+
+if test("primitive null", parse("data: null"), {"data": None}): passed += 1
+else: failed += 1
+
+if test("primitive null underscore", parse("data: _"), {"data": None}): passed += 1
+else: failed += 1
+
+if test("quoted string", parse('msg: "hello world"'), {"msg": "hello world"}): passed += 1
+else: failed += 1
+
+# Array
+if test("array semicolon", parse("tags: a; b; c"), {"tags": ["a", "b", "c"]}): passed += 1
+else: failed += 1
+
+# Inline object
+if test("inline object", parse("cfg: {host: localhost; port: 80}"), {"cfg": {"host": "localhost", "port": 80}}): passed += 1
+else: failed += 1
+
+# Block object
+if test("block object", parse("person:\n  name: Budi\n  age: 25"), {"person": {"name": "Budi", "age": 25}}): passed += 1
+else: failed += 1
+
+# Nested block
+if test("nested block", parse("a:\n  b:\n    c: 1"), {"a": {"b": {"c": 1}}}): passed += 1
+else: failed += 1
+
+# Comments
+if test("line comment", parse("# comment\nname: Budi"), {"name": "Budi"}): passed += 1
+else: failed += 1
+
+if test("block comment", parse("/* multi\nline */\nname: Budi"), {"name": "Budi"}): passed += 1
+else: failed += 1
+
+# Type hints
+if test("type hint @int", parse("n: @int 42"), {"n": 42}): passed += 1
+else: failed += 1
+
+if test("type hint @float", parse("n: @float 3.14"), {"n": 3.14}): passed += 1
+else: failed += 1
+
+if test("type hint @bool", parse("b: @bool yes"), {"b": True}): passed += 1
+else: failed += 1
+
+# Trailing separators
+if test("trailing semicolon array", parse("arr: a; b;"), {"arr": ["a", "b"]}): passed += 1
+else: failed += 1
+
+if test("trailing semicolon inline", parse("obj: {a: 1; b: 2;}"), {"obj": {"a": 1, "b": 2}}): passed += 1
+else: failed += 1
+
+# Full document
+full_doc = '''
+app:
+  name: "Super App"
+  version: 1.2.0
+  debug: off
+
+database:
+  host: localhost
+  port: 5432
+  ssl: yes
+  pool: {min: 5; max: 20}
+'''
+full_result = parse(full_doc)
+full_ok = (
+    full_result["app"]["name"] == "Super App" and
+    full_result["app"]["debug"] == False and
+    full_result["database"]["pool"] == {"min": 5, "max": 20}
+)
+if test("full document", full_ok, True): passed += 1
+else: failed += 1
+
+# Stringify roundtrip
+obj = {"name": "Budi", "age": 25, "active": True}
+yan_str = stringify(obj)
+back = parse(yan_str)
+if test("stringify roundtrip", back, obj): passed += 1
+else: failed += 1
+
+print(f"\n{passed} passed, {failed} failed")
+sys.exit(1 if failed > 0 else 0)