laga 0.1.1__py3-none-any.whl

laga/__init__.py

@@ -0,0 +1,8 @@
+"""Public package interface for laga."""
+
+from __future__ import annotations
+
+from .core import loads, repair, repair_to_str
+from .errors import LagaError
+
+__all__ = ["LagaError", "loads", "repair", "repair_to_str"]

laga/_version.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+__version__ = "0.1.1"

laga/core.py

@@ -0,0 +1,385 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Iterable
+from typing import Any
+
+from .errors import LagaError
+from .tokenizer import _Token, _Tokenizer
+
+__all__ = ["loads", "main", "repair", "repair_to_str"]
+
+_MAX_NESTING_DEPTH = 256
+
+_SMART_QUOTES = str.maketrans(
+    {
+        chr(0x201C): '"',
+        chr(0x201D): '"',
+        chr(0x201E): '"',
+        chr(0x201F): '"',
+        chr(0x2018): "'",
+        chr(0x2019): "'",
+        chr(0x201A): "'",
+    }
+)
+_LITERAL_MAP = {"true": True, "false": False, "null": None, "none": None}
+
+
+def repair(text: str, *, strict: bool = False) -> Any:
+    """Parse text as JSON, repairing common errors when needed.
+
+    Args:
+        text: Input text that should contain JSON.
+        strict: When `True`, reject ambiguous repairs such as missing commas or
+            truncated containers.
+
+    Returns:
+        The parsed Python value.
+
+    Raises:
+        LagaError: If the text cannot be repaired into valid JSON.
+    """
+
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        return _repair_text(text, strict=strict)
+
+
+def repair_to_str(text: str, *, strict: bool = False) -> str:
+    """Repair JSON text and return normalized JSON.
+
+    Args:
+        text: Input text that should contain JSON.
+        strict: When `True`, reject ambiguous repairs such as missing commas or
+            truncated containers.
+
+    Returns:
+        A normalized JSON string.
+
+    Raises:
+        LagaError: If the text cannot be repaired into valid JSON.
+    """
+
+    return json.dumps(
+        repair(text, strict=strict), ensure_ascii=False, separators=(",", ":")
+    )
+
+
+loads = repair
+
+
+def main(argv: Iterable[str] | None = None) -> int:
+    """Run a small command line interface for manual repair checks.
+
+    Args:
+        argv: Optional argument sequence. When omitted, `sys.argv[1:]` is used.
+
+    Returns:
+        Process exit code.
+    """
+
+    import argparse
+    import sys
+
+    parser = argparse.ArgumentParser(prog="laga")
+    parser.add_argument("text", nargs="?", help="Text containing malformed JSON")
+    parser.add_argument(
+        "--strict", action="store_true", help="Reject ambiguous repairs"
+    )
+    args = parser.parse_args(list(argv) if argv is not None else None)
+
+    if args.text is None:
+        sample = sys.stdin.read()
+    else:
+        sample = args.text
+    try:
+        print(repair_to_str(sample, strict=args.strict))
+    except LagaError as exc:
+        print(str(exc), file=sys.stderr)
+        return 1
+    return 0
+
+
+def _repair_text(text: str, *, strict: bool) -> Any:
+    normalized = _normalize_text(text)
+    candidates = list(_candidate_texts(normalized))
+    last_error: LagaError | None = None
+    for candidate in candidates:
+        try:
+            tokens = _Tokenizer(candidate, strict=strict).tokenize()
+            parser = _Parser(tokens, strict=strict)
+            return parser.parse()
+        except LagaError as exc:
+            last_error = exc
+    if last_error is None:
+        raise LagaError("No JSON value found", 0)
+    raise last_error
+
+
+def _normalize_text(text: str) -> str:
+    stripped = _extract_fenced_text(text)
+    if stripped is None:
+        stripped = text
+    return stripped.translate(_SMART_QUOTES)
+
+
+def _extract_fenced_text(text: str) -> str | None:
+    fence_start = text.find("```")
+    if fence_start == -1:
+        return None
+    line_end = text.find("\n", fence_start + 3)
+    if line_end == -1:
+        return text[fence_start + 3 :].strip()
+    fence_end = text.find("```", line_end + 1)
+    if fence_end == -1:
+        return text[line_end + 1 :].strip()
+    return text[line_end + 1 : fence_end].strip()
+
+
+def _candidate_texts(text: str) -> Iterable[str]:
+    if "```" in text:
+        yield text
+        return
+    found = False
+    for index, char in enumerate(text):
+        if char in "[{":
+            found = True
+            yield _capture_balanced_region(text, index)
+    if not found:
+        yield text
+
+
+def _capture_balanced_region(text: str, start: int) -> str:
+    opening = text[start]
+    closing = "]" if opening == "[" else "}"
+    depth = 0
+    in_string = False
+    quote = ""
+    escaped = False
+    index = start
+    while index < len(text):
+        char = text[index]
+        if in_string:
+            if escaped:
+                escaped = False
+            elif char == "\\":
+                escaped = True
+            elif char == quote:
+                in_string = False
+        else:
+            if char in "\"'":
+                in_string = True
+                quote = char
+            elif char == "/" and _next_char(text, index) == "/":
+                index = _skip_line_comment(text, index + 2)
+                continue
+            elif char == "/" and _next_char(text, index) == "*":
+                index = _skip_block_comment(text, index + 2)
+                continue
+            elif char == opening:
+                depth += 1
+            elif char == closing:
+                depth -= 1
+                if depth == 0:
+                    return text[start : index + 1]
+        index += 1
+    return text[start:]
+
+
+def _next_char(text: str, index: int) -> str | None:
+    next_index = index + 1
+    if next_index >= len(text):
+        return None
+    return text[next_index]
+
+
+def _skip_line_comment(text: str, index: int) -> int:
+    while index < len(text) and text[index] not in "\r\n":
+        index += 1
+    return index - 1
+
+
+def _skip_block_comment(text: str, index: int) -> int:
+    while index < len(text) - 1:
+        if text[index] == "*" and text[index + 1] == "/":
+            return index + 1
+        index += 1
+    return len(text) - 1
+
+
+class _Parser:
+    def __init__(self, tokens: list[_Token], *, strict: bool) -> None:
+        self._tokens = tokens
+        self._strict = strict
+        self._index = 0
+        self._depth = 0
+
+    def parse(self) -> Any:
+        value = self._parse_value()
+        if self._peek() is not None:
+            token = self._peek()
+            assert token is not None
+            raise LagaError("Unexpected trailing content", token.position)
+        return value
+
+    def _parse_value(self) -> Any:
+        token = self._peek()
+        if token is None:
+            raise LagaError("Expected JSON value", self._current_position())
+        if token.kind == "LBRACE":
+            return self._parse_object()
+        if token.kind == "LBRACKET":
+            return self._parse_array()
+        if token.kind == "STRING":
+            self._index += 1
+            return token.value
+        if token.kind == "NUMBER":
+            self._index += 1
+            try:
+                return json.loads(token.value)
+            except json.JSONDecodeError as exc:
+                raise LagaError("Invalid number", token.position) from exc
+        if token.kind == "IDENT":
+            self._index += 1
+            lowered = token.value.lower()
+            if lowered in _LITERAL_MAP:
+                return _LITERAL_MAP[lowered]
+            raise LagaError("Unexpected identifier", token.position)
+        raise LagaError("Expected JSON value", token.position)
+
+    def _parse_object(self) -> dict[str, Any]:
+        self._expect("LBRACE")
+        self._enter_container()
+        result: dict[str, Any] = {}
+        try:
+            if self._match("RBRACE"):
+                return result
+            while True:
+                token = self._peek()
+                if token is None:
+                    if self._strict:
+                        raise LagaError("Unterminated object", self._current_position())
+                    return result
+                if token.kind == "RBRACE":
+                    self._index += 1
+                    return result
+                key = self._parse_key()
+                self._expect("COLON")
+                result[key] = self._parse_value()
+                token = self._peek()
+                if token is None:
+                    if self._strict:
+                        raise LagaError("Unterminated object", self._current_position())
+                    return result
+                if token.kind == "COMMA":
+                    self._index += 1
+                    if self._match("RBRACE"):
+                        return result
+                    continue
+                if token.kind == "RBRACE":
+                    self._index += 1
+                    return result
+                if self._begins_member(token):
+                    if self._strict:
+                        raise LagaError(
+                            "Missing comma between object members", token.position
+                        )
+                    continue
+                raise LagaError("Expected comma or closing brace", token.position)
+        finally:
+            self._exit_container()
+
+    def _parse_array(self) -> list[Any]:
+        self._expect("LBRACKET")
+        self._enter_container()
+        result: list[Any] = []
+        try:
+            if self._match("RBRACKET"):
+                return result
+            while True:
+                token = self._peek()
+                if token is None:
+                    if self._strict:
+                        raise LagaError("Unterminated array", self._current_position())
+                    return result
+                if token.kind == "RBRACKET":
+                    self._index += 1
+                    return result
+                result.append(self._parse_value())
+                token = self._peek()
+                if token is None:
+                    if self._strict:
+                        raise LagaError("Unterminated array", self._current_position())
+                    return result
+                if token.kind == "COMMA":
+                    self._index += 1
+                    if self._match("RBRACKET"):
+                        return result
+                    continue
+                if token.kind == "RBRACKET":
+                    self._index += 1
+                    return result
+                if self._begins_value(token):
+                    if self._strict:
+                        raise LagaError(
+                            "Missing comma between array items", token.position
+                        )
+                    continue
+                raise LagaError("Expected comma or closing bracket", token.position)
+        finally:
+            self._exit_container()
+
+    def _parse_key(self) -> str:
+        token = self._peek()
+        if token is None:
+            raise LagaError("Expected object key", self._current_position())
+        if token.kind == "STRING":
+            self._index += 1
+            return token.value
+        if token.kind == "IDENT":
+            self._index += 1
+            return token.value
+        raise LagaError("Expected object key", token.position)
+
+    def _expect(self, kind: str) -> _Token:
+        token = self._peek()
+        if token is None or token.kind != kind:
+            position = self._current_position() if token is None else token.position
+            raise LagaError(f"Expected {kind.lower()}", position)
+        self._index += 1
+        return token
+
+    def _match(self, kind: str) -> bool:
+        token = self._peek()
+        if token is None or token.kind != kind:
+            return False
+        self._index += 1
+        return True
+
+    def _peek(self) -> _Token | None:
+        if self._index >= len(self._tokens):
+            return None
+        return self._tokens[self._index]
+
+    def _current_position(self) -> int:
+        token = self._peek()
+        if token is not None:
+            return token.position
+        if not self._tokens:
+            return 0
+        return self._tokens[-1].position + len(self._tokens[-1].value)
+
+    def _begins_value(self, token: _Token) -> bool:
+        return token.kind in {"LBRACE", "LBRACKET", "STRING", "NUMBER", "IDENT"}
+
+    def _begins_member(self, token: _Token) -> bool:
+        return token.kind in {"STRING", "IDENT"}
+
+    def _enter_container(self) -> None:
+        self._depth += 1
+        if self._depth > _MAX_NESTING_DEPTH:
+            raise LagaError("JSON is too deeply nested", self._current_position())
+
+    def _exit_container(self) -> None:
+        self._depth -= 1

laga/errors.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+
+class LagaError(ValueError):
+    """Raised when JSON repair cannot produce a valid result.
+
+    Args:
+        message: Human-readable explanation of the failure.
+        position: Character offset where the problem was detected, if known.
+    """
+
+    def __init__(self, message: str, position: int | None = None) -> None:
+        self.position = position
+        if position is None:
+            formatted = message
+        else:
+            formatted = f"{message} at position {position}"
+        super().__init__(formatted)

laga/tokenizer.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .errors import LagaError
+
+
+@dataclass(frozen=True, slots=True)
+class _Token:
+    kind: str
+    value: str
+    position: int
+
+
+class _Tokenizer:
+    def __init__(self, text: str, *, strict: bool) -> None:
+        self._text = text
+        self._strict = strict
+        self._index = 0
+        self._length = len(text)
+
+    def tokenize(self) -> list[_Token]:
+        tokens: list[_Token] = []
+        while self._index < self._length:
+            char = self._text[self._index]
+            if char.isspace():
+                self._index += 1
+                continue
+            if char == "/" and self._peek_char(1) == "/":
+                self._skip_line_comment()
+                continue
+            if char == "/" and self._peek_char(1) == "*":
+                self._skip_block_comment()
+                continue
+            if char == "{":
+                tokens.append(_Token("LBRACE", char, self._index))
+                self._index += 1
+                continue
+            if char == "}":
+                tokens.append(_Token("RBRACE", char, self._index))
+                self._index += 1
+                continue
+            if char == "[":
+                tokens.append(_Token("LBRACKET", char, self._index))
+                self._index += 1
+                continue
+            if char == "]":
+                tokens.append(_Token("RBRACKET", char, self._index))
+                self._index += 1
+                continue
+            if char == ":":
+                tokens.append(_Token("COLON", char, self._index))
+                self._index += 1
+                continue
+            if char == ",":
+                tokens.append(_Token("COMMA", char, self._index))
+                self._index += 1
+                continue
+            if char in "\"'":
+                tokens.append(self._consume_string(char))
+                continue
+            if char == "-" or char.isdigit():
+                tokens.append(self._consume_number())
+                continue
+            if _is_identifier_start(char):
+                tokens.append(self._consume_identifier())
+                continue
+            raise LagaError(f"Unexpected character {char!r}", self._index)
+        return tokens
+
+    def _peek_char(self, offset: int) -> str | None:
+        index = self._index + offset
+        if index >= self._length:
+            return None
+        return self._text[index]
+
+    def _skip_line_comment(self) -> None:
+        self._index += 2
+        while self._index < self._length and self._text[self._index] not in "\r\n":
+            self._index += 1
+
+    def _skip_block_comment(self) -> None:
+        self._index += 2
+        while self._index < self._length - 1:
+            if self._text[self._index] == "*" and self._text[self._index + 1] == "/":
+                self._index += 2
+                return
+            self._index += 1
+        if self._strict:
+            raise LagaError("Unterminated block comment", self._index)
+        self._index = self._length
+
+    def _consume_string(self, quote: str) -> _Token:
+        start = self._index
+        self._index += 1
+        pieces: list[str] = []
+        while self._index < self._length:
+            char = self._text[self._index]
+            self._index += 1
+            if char == quote:
+                return _Token("STRING", "".join(pieces), start)
+            if char == "\\":
+                pieces.append(self._consume_escape(start))
+                continue
+            pieces.append(char)
+        if self._strict:
+            raise LagaError("Unterminated string literal", start)
+        return _Token("STRING", "".join(pieces), start)
+
+    def _consume_escape(self, string_start: int) -> str:
+        if self._index >= self._length:
+            if self._strict:
+                raise LagaError("Incomplete escape sequence", string_start)
+            return "\\"
+        char = self._text[self._index]
+        self._index += 1
+        if char in '"\\/':
+            return char
+        if char == "b":
+            return "\b"
+        if char == "f":
+            return "\f"
+        if char == "n":
+            return "\n"
+        if char == "r":
+            return "\r"
+        if char == "t":
+            return "\t"
+        if char == "u":
+            return self._consume_unicode_escape(string_start)
+        if self._strict:
+            raise LagaError(f"Invalid escape sequence \\{char}", string_start)
+        return char
+
+    def _consume_unicode_escape(self, string_start: int) -> str:
+        digits = self._text[self._index : self._index + 4]
+        if len(digits) == 4 and all(_is_hex_digit(char) for char in digits):
+            self._index += 4
+            return chr(int(digits, 16))
+        if self._strict:
+            raise LagaError("Invalid unicode escape", string_start)
+        return "u"
+
+    def _consume_number(self) -> _Token:
+        start = self._index
+        if self._text[self._index] == "-":
+            self._index += 1
+        if self._index >= self._length:
+            raise LagaError("Incomplete number", start)
+        if self._text[self._index] == "0":
+            self._index += 1
+        else:
+            if not self._text[self._index].isdigit():
+                raise LagaError("Invalid number", start)
+            while self._index < self._length and self._text[self._index].isdigit():
+                self._index += 1
+        if self._index < self._length and self._text[self._index] == ".":
+            self._index += 1
+            if self._index >= self._length or not self._text[self._index].isdigit():
+                raise LagaError("Invalid number", start)
+            while self._index < self._length and self._text[self._index].isdigit():
+                self._index += 1
+        if self._index < self._length and self._text[self._index] in "eE":
+            self._index += 1
+            if self._index < self._length and self._text[self._index] in "+-":
+                self._index += 1
+            if self._index >= self._length or not self._text[self._index].isdigit():
+                raise LagaError("Invalid number", start)
+            while self._index < self._length and self._text[self._index].isdigit():
+                self._index += 1
+        return _Token("NUMBER", self._text[start : self._index], start)
+
+    def _consume_identifier(self) -> _Token:
+        start = self._index
+        self._index += 1
+        while self._index < self._length and _is_identifier_part(
+            self._text[self._index]
+        ):
+            self._index += 1
+        return _Token("IDENT", self._text[start : self._index], start)
+
+
+def _is_hex_digit(char: str) -> bool:
+    return char.isdigit() or char.lower() in "abcdef"
+
+
+def _is_identifier_start(char: str) -> bool:
+    return char == "_" or char.isalpha()
+
+
+def _is_identifier_part(char: str) -> bool:
+    return char == "_" or char.isalpha() or char.isdigit() or char == "$"

laga-0.1.1.dist-info/METADATA

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: laga
+Version: 0.1.1
+Summary: Repair malformed JSON from language models and hand-written config.
+Project-URL: Homepage, https://github.com/olaflaitinen/laga
+Project-URL: Documentation, https://github.com/olaflaitinen/laga/tree/main/docs
+Project-URL: Source, https://github.com/olaflaitinen/laga
+Project-URL: Issue Tracker, https://github.com/olaflaitinen/laga/issues
+Author: Gustav Olaf Yunus Laitinen-Fredriksson Lundström-Imanov
+License: MIT License
+        
+        Copyright (c) 2026 Gustav Olaf Yunus Laitinen-Fredriksson Lundström-Imanov
+        
+        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.
+License-File: LICENSE
+Keywords: data-cleanup,json,llm,parser,repair
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: <3.14,>=3.10
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: coverage[toml]>=7.6; extra == 'dev'
+Requires-Dist: hypothesis>=6.108; extra == 'dev'
+Requires-Dist: mkdocs-material>=9.5; extra == 'dev'
+Requires-Dist: mkdocs>=1.6; extra == 'dev'
+Requires-Dist: mypy>=1.11; extra == 'dev'
+Requires-Dist: pre-commit>=3.8; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.3; extra == 'dev'
+Requires-Dist: ruff>=0.6.9; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.5; extra == 'docs'
+Requires-Dist: mkdocs>=1.6; extra == 'docs'
+Provides-Extra: lint
+Requires-Dist: mypy>=1.11; extra == 'lint'
+Requires-Dist: ruff>=0.6.9; extra == 'lint'
+Provides-Extra: test
+Requires-Dist: coverage[toml]>=7.6; extra == 'test'
+Requires-Dist: hypothesis>=6.108; extra == 'test'
+Requires-Dist: pytest-cov>=5.0; extra == 'test'
+Requires-Dist: pytest>=8.3; extra == 'test'
+Description-Content-Type: text/markdown
+
+# laga
+
+`laga` repairs malformed JSON and returns Python objects.
+
+## Why
+
+Large language models and hand-written configuration often produce almost-JSON with trailing commas, missing commas, comments, code fences, single quotes, unquoted keys, or truncated containers. `laga` keeps the public surface small, tries `json.loads` first for valid input, and only enters the repair path when necessary.
+
+## Install
+
+`laga` 0.1.1 supports Python 3.10 through 3.13.
+
+```bash
+python -m pip install -e ".[dev]"
+```
+
+## Quickstart
+
+```python
+import laga
+
+text = """Here is the result:
+```json
+{
+  'name': 'Ada',
+  'active': True,
+  'roles': ['admin', 'writer',],
+}
+```
+"""
+
+data = laga.repair(text)
+print(data)
+print(laga.repair_to_str(text))
+```
+
+## API Reference
+
+| Function | Returns | Description |
+| --- | --- | --- |
+| `laga.repair(text, strict=False)` | Python object | Repairs malformed JSON and returns Python data. |
+| `laga.repair_to_str(text, strict=False)` | `str` | Repairs malformed JSON and returns normalized JSON text. |
+| `laga.loads(text, strict=False)` | Python object | Alias for `laga.repair`. |
+| `laga.LagaError` | Exception type | Raised when repair fails or input is unrecoverable. |
+
+## Repair Rules
+
+| Rule | Before | After |
+| --- | --- | --- |
+| Trailing comma | `{"a": 1,}` | `{"a":1}` |
+| Missing comma | `{"a": 1 "b": 2}` | `{"a":1,"b":2}` |
+| Single quotes | `{'a': 'b'}` | `{"a":"b"}` |
+| Unquoted keys | `{name: "Ada"}` | `{"name":"Ada"}` |
+| Python literals | `{"ok": True, "none": None}` | `{"ok":true,"none":null}` |
+| Comments | `{"a": 1 // note\n}` | `{"a":1}` |
+| Markdown fences | <code>```json\n{"a":1}\n```</code> | `{"a":1}` |
+| Smart quotes | `“a”` | `"a"` |
+| Prose around JSON | `Result: {"a":1}` | `{"a":1}` |
+| Truncated structure | `{"a": [1, 2` | `{"a":[1,2]}` |
+
+## Limitations
+
+`laga` is intentionally conservative. It does not evaluate expressions, it does not guess at arbitrary JavaScript syntax, and it does not try to recover malformed numbers or deeply ambiguous text in strict mode. If you already control the producer and the input is valid JSON, the standard library remains the best choice because `json.loads` is faster and stricter.
+
+When an object contains duplicate keys, the last value wins, matching Python dict behavior.
+
+## When To Use The Standard Library
+
+Use `json.loads` when you control the producer and know the input is valid JSON. Use `laga` when the input is noisy, user-facing, or generated by a model and you need a predictable repair step before parsing.
+
+## Development
+
+```bash
+make install
+make lint
+make typecheck
+make test
+make build
+```

laga-0.1.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+laga/__init__.py,sha256=d-wmg_rND-_JXTVG2a4W2IGbE1s1q398zYPRJtdmXs0,216
+laga/_version.py,sha256=VfIcjuN_CI8BoNxWKybanz18M5jCOR-HOOcbalOQD0M,58
+laga/core.py,sha256=irZdUBFLizusF4IeBTuHG9WK3rgZI2aFhDzzdIq_z3o,12186
+laga/errors.py,sha256=jqMLhz6Xf4OwZ6yYEBRip6AnpGP9v5k644IrR3RXr1Y,564
+laga/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+laga/tokenizer.py,sha256=mlzFTR-TTWqA9NOSOWH6XiYIRNEFxVvfwUo0cKrw6aQ,6942
+laga-0.1.1.dist-info/METADATA,sha256=LNrLJ0ENPExER0AknWAw2OprK2Rxk9z07ByrRIOkflc,5964
+laga-0.1.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+laga-0.1.1.dist-info/entry_points.txt,sha256=laC_DfTG4q3bWsNFybztCbgt94ajYxuGQ4DkNgyLBP0,40
+laga-0.1.1.dist-info/licenses/LICENSE,sha256=9DC2R658LFbR8ETB1XqOiMCbVi4AMnTOBDLSEbViduU,1113
+laga-0.1.1.dist-info/RECORD,,

laga-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

laga-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+laga = laga.core:main

laga-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gustav Olaf Yunus Laitinen-Fredriksson Lundström-Imanov
+
+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.