prismaa 0.1.0__py3-none-any.whl

prismaa/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

prismaa/cli.py

@@ -0,0 +1,14 @@
+import click
+
+
+@click.group()
+def main() -> None:
+    """Prismaa — Python Prisma client generator."""
+
+
+@main.command()
+@click.option("--schema", default="schema.prisma", show_default=True, help="Path to schema.prisma")
+@click.option("--output", default=None, help="Output directory (overrides schema generator.output)")
+def generate(schema: str, output: str | None) -> None:
+    """Generate the Python client from a Prisma schema."""
+    raise NotImplementedError("Generator not yet implemented — see PLAN.md Phase 3")

prismaa/parser/__init__.py

@@ -0,0 +1,31 @@
+from .ast import (
+    Attribute,
+    AttributeArg,
+    AttributeValue,
+    Datasource,
+    Field,
+    FunctionCall,
+    Generator,
+    Model,
+    Schema,
+)
+from .lexer import LexError, Token, TokenKind, tokenize
+from .parser import ParseError, parse
+
+__all__ = [
+    "parse",
+    "tokenize",
+    "Schema",
+    "Datasource",
+    "Generator",
+    "Model",
+    "Field",
+    "Attribute",
+    "AttributeArg",
+    "AttributeValue",
+    "FunctionCall",
+    "Token",
+    "TokenKind",
+    "LexError",
+    "ParseError",
+]

prismaa/parser/ast.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class FunctionCall:
+    """Represents a zero-argument function call in an attribute, e.g. autoincrement(), now()."""
+
+    name: str
+
+    def __repr__(self) -> str:
+        return f"{self.name}()"
+
+
+# Valid types for attribute argument values.
+AttributeValue = str | int | float | bool | list[str] | FunctionCall
+
+
+@dataclass
+class AttributeArg:
+    """A single argument inside an attribute's parentheses."""
+
+    name: str | None  # None for positional arguments
+    value: AttributeValue
+
+
+@dataclass
+class Attribute:
+    """A field-level (@) or block-level (@@) attribute."""
+
+    name: str  # without leading @ or @@
+    args: list[AttributeArg] = field(default_factory=list)
+
+    def arg(self, name: str) -> AttributeValue | None:
+        """Return the value of a named argument, or None if absent."""
+        for a in self.args:
+            if a.name == name:
+                return a.value
+        return None
+
+    def first_positional(self) -> AttributeValue | None:
+        """Return the first positional argument value, or None."""
+        for a in self.args:
+            if a.name is None:
+                return a.value
+        return None
+
+
+@dataclass
+class Field:
+    name: str
+    type: str  # e.g. "String", "Int", "Company", "Unsupported"
+    is_list: bool
+    is_optional: bool
+    # For Unsupported("native_type") fields, holds the native type string.
+    native_type: str | None = None
+    attributes: list[Attribute] = field(default_factory=list)
+    doc_comment: str | None = None
+
+    @property
+    def is_unsupported(self) -> bool:
+        return self.type == "Unsupported"
+
+    @property
+    def is_relation(self) -> bool:
+        return any(a.name == "relation" for a in self.attributes)
+
+    @property
+    def column_name(self) -> str:
+        """Actual DB column name, respecting @map."""
+        for attr in self.attributes:
+            if attr.name == "map":
+                v = attr.first_positional()
+                if isinstance(v, str):
+                    return v
+        return self.name
+
+    def has_attr(self, name: str) -> bool:
+        return any(a.name == name for a in self.attributes)
+
+    def get_attr(self, name: str) -> Attribute | None:
+        for a in self.attributes:
+            if a.name == name:
+                return a
+        return None
+
+
+@dataclass
+class Model:
+    name: str
+    fields: list[Field] = field(default_factory=list)
+    block_attributes: list[Attribute] = field(default_factory=list)
+    doc_comment: str | None = None
+
+    @property
+    def is_ignored(self) -> bool:
+        return any(a.name == "ignore" for a in self.block_attributes)
+
+    @property
+    def table_name(self) -> str:
+        """Actual DB table name, respecting @@map."""
+        for attr in self.block_attributes:
+            if attr.name == "map":
+                v = attr.first_positional()
+                if isinstance(v, str):
+                    return v
+        return self.name
+
+    def scalar_fields(self) -> list[Field]:
+        """Non-relation, non-unsupported fields."""
+        return [f for f in self.fields if not f.is_relation and not f.is_unsupported]
+
+    def relation_fields(self) -> list[Field]:
+        return [f for f in self.fields if f.is_relation]
+
+
+@dataclass
+class Generator:
+    name: str
+    properties: dict[str, str] = field(default_factory=dict)
+
+    def get(self, key: str, default: str = "") -> str:
+        return self.properties.get(key, default)
+
+
+@dataclass
+class Datasource:
+    name: str
+    provider: str
+
+
+@dataclass
+class Schema:
+    datasource: Datasource | None = None
+    generators: list[Generator] = field(default_factory=list)
+    models: list[Model] = field(default_factory=list)
+
+    @property
+    def generator(self) -> Generator | None:
+        """The first generator block, or None."""
+        return self.generators[0] if self.generators else None
+
+    def active_models(self) -> list[Model]:
+        """Models that are not marked @@ignore."""
+        return [m for m in self.models if not m.is_ignored]

prismaa/parser/lexer.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from enum import Enum, auto
+
+
+class TokenKind(Enum):
+    IDENT = auto()
+    STRING = auto()
+    NUMBER = auto()
+    DOUBLE_AT = auto()
+    AT = auto()
+    LBRACE = auto()
+    RBRACE = auto()
+    LPAREN = auto()
+    RPAREN = auto()
+    LBRACKET = auto()
+    RBRACKET = auto()
+    COLON = auto()
+    COMMA = auto()
+    EQUALS = auto()
+    QUESTION = auto()
+    DOC_COMMENT = auto()
+    NEWLINE = auto()
+    EOF = auto()
+
+
+@dataclass
+class Token:
+    kind: TokenKind
+    value: str
+    line: int
+
+    def __repr__(self) -> str:
+        return f"Token({self.kind.name}, {self.value!r}, line={self.line})"
+
+
+class LexError(Exception):
+    pass
+
+
+# Rules are tested in order; first match wins.
+# None means "skip this token" (whitespace, regular comments).
+_RULES: list[tuple[TokenKind | None, str]] = [
+    (TokenKind.DOC_COMMENT, r"///[^\n]*"),
+    (None, r"//[^\n]*"),  # regular comment — discard
+    (None, r"[ \t]+"),  # horizontal whitespace — discard
+    (TokenKind.NEWLINE, r"\n"),
+    (TokenKind.STRING, r'"[^"\\]*(?:\\.[^"\\]*)*"'),
+    (TokenKind.NUMBER, r"\d+\.\d+|\d+"),
+    (TokenKind.DOUBLE_AT, r"@@"),  # must precede AT
+    (TokenKind.AT, r"@"),
+    (TokenKind.LBRACE, r"\{"),
+    (TokenKind.RBRACE, r"\}"),
+    (TokenKind.LPAREN, r"\("),
+    (TokenKind.RPAREN, r"\)"),
+    (TokenKind.LBRACKET, r"\["),
+    (TokenKind.RBRACKET, r"\]"),
+    (TokenKind.COLON, r":"),
+    (TokenKind.COMMA, r","),
+    (TokenKind.EQUALS, r"="),
+    (TokenKind.QUESTION, r"\?"),
+    (TokenKind.IDENT, r"[A-Za-z_][A-Za-z0-9_]*"),
+    (None, r"\r"),  # bare carriage return — discard
+]
+
+_MASTER = re.compile(
+    "|".join(f"(?P<r{i}>{pattern})" for i, (_, pattern) in enumerate(_RULES)),
+)
+
+
+def tokenize(source: str) -> list[Token]:
+    """Lex *source* into a flat token list ending with an EOF token."""
+    tokens: list[Token] = []
+    line = 1
+
+    for m in _MASTER.finditer(source):
+        group_index = int(m.lastgroup[1:])  # "r7" → 7
+        kind, _ = _RULES[group_index]
+        value = m.group()
+
+        if value == "\n":
+            tokens.append(Token(TokenKind.NEWLINE, value, line))
+            line += 1
+        elif kind is not None:
+            tokens.append(Token(kind, value, line))
+        # kind is None → skip (whitespace / comments)
+
+    # Verify the entire source was consumed (no unexpected characters).
+    matched_len = sum(len(m.group()) for m in _MASTER.finditer(source))
+    if matched_len != len(source):
+        # Find the first unmatched character to give a useful error.
+        pos = 0
+        for m in _MASTER.finditer(source):
+            if m.start() != pos:
+                break
+            pos = m.end()
+        ctx = source[pos : pos + 20].replace("\n", "\\n")
+        raise LexError(f"Unexpected character at line {line}: {ctx!r}")
+
+    tokens.append(Token(TokenKind.EOF, "", line))
+    return tokens

prismaa/parser/parser.py

@@ -0,0 +1,364 @@
+from __future__ import annotations
+
+from .ast import (
+    Attribute,
+    AttributeArg,
+    AttributeValue,
+    Datasource,
+    Field,
+    FunctionCall,
+    Generator,
+    Model,
+    Schema,
+)
+from .lexer import Token, TokenKind, tokenize
+
+
+class ParseError(Exception):
+    pass
+
+
+class Parser:
+    def __init__(self, tokens: list[Token]) -> None:
+        self._tokens = tokens
+        self._pos = 0
+
+    # ------------------------------------------------------------------
+    # Token stream primitives
+    # ------------------------------------------------------------------
+
+    def _peek(self) -> Token:
+        return self._tokens[self._pos]
+
+    def _advance(self) -> Token:
+        tok = self._tokens[self._pos]
+        if tok.kind != TokenKind.EOF:
+            self._pos += 1
+        return tok
+
+    def _at(self, kind: TokenKind) -> bool:
+        return self._peek().kind == kind
+
+    def _expect(self, kind: TokenKind) -> Token:
+        tok = self._peek()
+        if tok.kind != kind:
+            raise ParseError(
+                f"Expected {kind.name} but got {tok.kind.name} ({tok.value!r}) at line {tok.line}"
+            )
+        return self._advance()
+
+    def _skip_newlines(self) -> None:
+        while self._at(TokenKind.NEWLINE):
+            self._advance()
+
+    def _at_end_of_statement(self) -> bool:
+        return self._at(TokenKind.NEWLINE) or self._at(TokenKind.RBRACE) or self._at(TokenKind.EOF)
+
+    # ------------------------------------------------------------------
+    # Top-level
+    # ------------------------------------------------------------------
+
+    def parse(self) -> Schema:
+        schema = Schema()
+        pending_doc: str | None = None
+
+        while not self._at(TokenKind.EOF):
+            if self._at(TokenKind.NEWLINE):
+                self._advance()
+                continue
+
+            if self._at(TokenKind.DOC_COMMENT):
+                # Accumulate consecutive doc comment lines.
+                lines = []
+                while self._at(TokenKind.DOC_COMMENT):
+                    lines.append(self._advance().value[3:].strip())
+                    self._skip_newlines()
+                pending_doc = "\n".join(lines)
+                continue
+
+            if not self._at(TokenKind.IDENT):
+                self._advance()
+                continue
+
+            keyword = self._peek().value
+            if keyword == "generator":
+                schema.generators.append(self._parse_generator())
+            elif keyword == "datasource":
+                schema.datasource = self._parse_datasource()
+            elif keyword == "model":
+                model = self._parse_model()
+                model.doc_comment = pending_doc
+                schema.models.append(model)
+            else:
+                # Unknown top-level block (e.g. "enum", "type") — skip entirely.
+                self._skip_block()
+
+            pending_doc = None
+
+        return schema
+
+    # ------------------------------------------------------------------
+    # Blocks
+    # ------------------------------------------------------------------
+
+    def _parse_generator(self) -> Generator:
+        self._expect(TokenKind.IDENT)  # consume "generator"
+        name = self._expect(TokenKind.IDENT).value
+        self._skip_newlines()
+        self._expect(TokenKind.LBRACE)
+        props: dict[str, str] = {}
+        while not self._at(TokenKind.RBRACE) and not self._at(TokenKind.EOF):
+            self._skip_newlines()
+            if self._at(TokenKind.RBRACE):
+                break
+            key = self._expect(TokenKind.IDENT).value
+            self._expect(TokenKind.EQUALS)
+            value = self._parse_scalar_value()
+            props[key] = str(value)
+            self._skip_newlines()
+        self._expect(TokenKind.RBRACE)
+        return Generator(name=name, properties=props)
+
+    def _parse_datasource(self) -> Datasource:
+        self._expect(TokenKind.IDENT)  # consume "datasource"
+        name = self._expect(TokenKind.IDENT).value
+        self._skip_newlines()
+        self._expect(TokenKind.LBRACE)
+        provider = "unknown"
+        while not self._at(TokenKind.RBRACE) and not self._at(TokenKind.EOF):
+            self._skip_newlines()
+            if self._at(TokenKind.RBRACE):
+                break
+            key = self._expect(TokenKind.IDENT).value
+            self._expect(TokenKind.EQUALS)
+            value = self._parse_scalar_value()
+            if key == "provider":
+                provider = str(value)
+            self._skip_newlines()
+        self._expect(TokenKind.RBRACE)
+        return Datasource(name=name, provider=provider)
+
+    def _parse_model(self) -> Model:
+        self._expect(TokenKind.IDENT)  # consume "model"
+        name = self._expect(TokenKind.IDENT).value
+        self._skip_newlines()
+        self._expect(TokenKind.LBRACE)
+        self._skip_newlines()
+
+        fields: list[Field] = []
+        block_attrs: list[Attribute] = []
+        pending_doc: str | None = None
+
+        while not self._at(TokenKind.RBRACE) and not self._at(TokenKind.EOF):
+            if self._at(TokenKind.NEWLINE):
+                self._advance()
+                continue
+
+            if self._at(TokenKind.DOC_COMMENT):
+                lines = []
+                while self._at(TokenKind.DOC_COMMENT):
+                    lines.append(self._advance().value[3:].strip())
+                    self._skip_newlines()
+                pending_doc = "\n".join(lines)
+                continue
+
+            if self._at(TokenKind.DOUBLE_AT):
+                block_attrs.append(self._parse_block_attribute())
+                pending_doc = None
+                continue
+
+            if self._at(TokenKind.IDENT):
+                f = self._parse_field()
+                f.doc_comment = pending_doc
+                fields.append(f)
+                pending_doc = None
+                continue
+
+            # Unexpected token inside model block — skip to next newline.
+            self._advance()
+
+        self._expect(TokenKind.RBRACE)
+        return Model(name=name, fields=fields, block_attributes=block_attrs)
+
+    def _skip_block(self) -> None:
+        """Skip an unknown top-level block (keyword name { ... })."""
+        self._advance()  # keyword
+        if self._at(TokenKind.IDENT):
+            self._advance()  # name
+        self._skip_newlines()
+        if not self._at(TokenKind.LBRACE):
+            return
+        self._advance()  # {
+        depth = 1
+        while depth > 0 and not self._at(TokenKind.EOF):
+            tok = self._advance()
+            if tok.kind == TokenKind.LBRACE:
+                depth += 1
+            elif tok.kind == TokenKind.RBRACE:
+                depth -= 1
+
+    # ------------------------------------------------------------------
+    # Fields
+    # ------------------------------------------------------------------
+
+    def _parse_field(self) -> Field:
+        name = self._expect(TokenKind.IDENT).value
+        type_name, native_type, is_list, is_optional = self._parse_field_type()
+        attributes: list[Attribute] = []
+        while self._at(TokenKind.AT) and not self._at_end_of_statement():
+            attributes.append(self._parse_field_attribute())
+        # Consume the trailing newline (or leave RBRACE for the caller).
+        if self._at(TokenKind.NEWLINE):
+            self._advance()
+        return Field(
+            name=name,
+            type=type_name,
+            is_list=is_list,
+            is_optional=is_optional,
+            native_type=native_type,
+            attributes=attributes,
+        )
+
+    def _parse_field_type(self) -> tuple[str, str | None, bool, bool]:
+        """Return (type_name, native_type, is_list, is_optional)."""
+        type_name = self._expect(TokenKind.IDENT).value
+        native_type: str | None = None
+
+        # Handle Unsupported("native_type")
+        if type_name == "Unsupported" and self._at(TokenKind.LPAREN):
+            self._advance()
+            native_type = self._expect(TokenKind.STRING).value.strip('"')
+            self._expect(TokenKind.RPAREN)
+
+        is_list = False
+        is_optional = False
+
+        if self._at(TokenKind.LBRACKET):
+            self._advance()
+            self._expect(TokenKind.RBRACKET)
+            is_list = True
+        elif self._at(TokenKind.QUESTION):
+            self._advance()
+            is_optional = True
+
+        return type_name, native_type, is_list, is_optional
+
+    # ------------------------------------------------------------------
+    # Attributes
+    # ------------------------------------------------------------------
+
+    def _parse_field_attribute(self) -> Attribute:
+        """Parse a @name or @name(...) field attribute."""
+        self._expect(TokenKind.AT)
+        name = self._expect(TokenKind.IDENT).value
+        args = self._parse_attribute_args() if self._at(TokenKind.LPAREN) else []
+        return Attribute(name=name, args=args)
+
+    def _parse_block_attribute(self) -> Attribute:
+        """Parse a @@name or @@name(...) block attribute."""
+        self._expect(TokenKind.DOUBLE_AT)
+        name = self._expect(TokenKind.IDENT).value
+        args = self._parse_attribute_args() if self._at(TokenKind.LPAREN) else []
+        if self._at(TokenKind.NEWLINE):
+            self._advance()
+        return Attribute(name=name, args=args)
+
+    def _parse_attribute_args(self) -> list[AttributeArg]:
+        self._expect(TokenKind.LPAREN)
+        args: list[AttributeArg] = []
+        while not self._at(TokenKind.RPAREN) and not self._at(TokenKind.EOF):
+            args.append(self._parse_attribute_arg())
+            if self._at(TokenKind.COMMA):
+                self._advance()
+        self._expect(TokenKind.RPAREN)
+        return args
+
+    def _parse_attribute_arg(self) -> AttributeArg:
+        """Parse one argument: either `name: value` or a bare `value`."""
+        # Named argument: IDENT COLON value
+        if self._at(TokenKind.IDENT) and self._tokens[self._pos + 1].kind == TokenKind.COLON:
+            name = self._advance().value
+            self._advance()  # consume ':'
+            value = self._parse_attr_value()
+            return AttributeArg(name=name, value=value)
+        # Positional argument
+        return AttributeArg(name=None, value=self._parse_attr_value())
+
+    def _parse_attr_value(self) -> AttributeValue:
+        tok = self._peek()
+
+        if tok.kind == TokenKind.STRING:
+            self._advance()
+            return tok.value[1:-1]  # strip surrounding quotes
+
+        if tok.kind == TokenKind.NUMBER:
+            self._advance()
+            return float(tok.value) if "." in tok.value else int(tok.value)
+
+        if tok.kind == TokenKind.LBRACKET:
+            return self._parse_array()
+
+        if tok.kind == TokenKind.IDENT:
+            name = self._advance().value
+            if name == "true":
+                return True
+            if name == "false":
+                return False
+            # Function call: name()
+            if self._at(TokenKind.LPAREN):
+                self._advance()
+                self._expect(TokenKind.RPAREN)
+                return FunctionCall(name)
+            # Bare identifier (e.g. enum value, env("VAR") key)
+            return name
+
+        raise ParseError(f"Unexpected token in attribute value: {tok!r}")
+
+    def _parse_array(self) -> list[str]:
+        """Parse [ident, ident, ...] — used in @@unique, @relation fields/references."""
+        self._expect(TokenKind.LBRACKET)
+        items: list[str] = []
+        while not self._at(TokenKind.RBRACKET) and not self._at(TokenKind.EOF):
+            items.append(self._expect(TokenKind.IDENT).value)
+            if self._at(TokenKind.COMMA):
+                self._advance()
+        self._expect(TokenKind.RBRACKET)
+        return items
+
+    # ------------------------------------------------------------------
+    # Shared value parsing (generator / datasource properties)
+    # ------------------------------------------------------------------
+
+    def _parse_scalar_value(self) -> AttributeValue:
+        """Parse a simple key = value pair value (string, number, bool, or env(...))."""
+        tok = self._peek()
+        if tok.kind == TokenKind.STRING:
+            self._advance()
+            return tok.value[1:-1]
+        if tok.kind == TokenKind.NUMBER:
+            self._advance()
+            return float(tok.value) if "." in tok.value else int(tok.value)
+        if tok.kind == TokenKind.IDENT:
+            name = self._advance().value
+            if name == "true":
+                return True
+            if name == "false":
+                return False
+            # env("VAR") — return the raw identifier; resolution happens at runtime
+            if self._at(TokenKind.LPAREN):
+                self._advance()
+                inner = self._peek()
+                value = inner.value[1:-1] if inner.kind == TokenKind.STRING else inner.value
+                self._advance()
+                self._expect(TokenKind.RPAREN)
+                return value
+            return name
+        if tok.kind == TokenKind.LBRACKET:
+            return self._parse_array()
+        raise ParseError(f"Unexpected token in value: {tok!r}")
+
+
+def parse(source: str) -> Schema:
+    """Parse a Prisma schema string and return a :class:`Schema` AST."""
+    tokens = tokenize(source)
+    return Parser(tokens).parse()

prismaa-0.1.0.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: prismaa
+Version: 0.1.0
+Summary: A production-grade Python Prisma client
+Project-URL: Homepage, https://github.com/laszlosragner/prismaa
+Project-URL: Documentation, https://laszlosragner.github.io/prismaa
+Project-URL: Repository, https://github.com/laszlosragner/prismaa
+Project-URL: Issues, https://github.com/laszlosragner/prismaa/issues
+Author-email: Laszlo Sragner <laszlo@hypergolic.co.uk>
+License: MIT License
+        
+        Copyright (c) 2026 xLaszlo
+        
+        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: async,database,orm,prisma,sqlalchemy
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Requires-Python: >=3.11
+Requires-Dist: aiosqlite>=0.19
+Requires-Dist: click>=8.0
+Requires-Dist: jinja2>=3.1
+Requires-Dist: pydantic>=2.0
+Requires-Dist: sqlalchemy>=2.0
+Description-Content-Type: text/markdown
+
+# prismaa
+Prisma python client with SQLAlchemy backend

prismaa-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+prismaa/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+prismaa/cli.py,sha256=3gw4WZkrgzflwpjyHfJkqWf2xOZLZ2UITE8Mx9lqevE,524
+prismaa/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+prismaa/engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+prismaa/generator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+prismaa/parser/__init__.py,sha256=isNtMRhVmQHTfpGIAIP-brqM03g_v7N2kzexn5f2iuc,513
+prismaa/parser/ast.py,sha256=VP5doDijft5xE_ixJdZIRjZUzfQcogdnptMz6BsqV1Y,4091
+prismaa/parser/lexer.py,sha256=sWeXpQUO9PiaPnQjLc4XuDsBqMpNNL1CVCKKhOyY9Wk,2924
+prismaa/parser/parser.py,sha256=-OSiI_qGmZtt-BN1X9ZiN-kCdKPn4dF9UVnNohLwnhg,13292
+prismaa/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+prismaa-0.1.0.dist-info/METADATA,sha256=Kgzhb_gLNP8dYtLVafk0cXgQqVN8RuMBmjvPgfmxe5Q,2391
+prismaa-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+prismaa-0.1.0.dist-info/entry_points.txt,sha256=wCauZPJ2MHIwy2WgtgEoF46cQ9-1--_HcQM82Q0HSH8,45
+prismaa-0.1.0.dist-info/licenses/LICENSE,sha256=8_nxY_VIKgaz42SM-7ZACEIOnvNXVFth6YJG9n51_vs,1064
+prismaa-0.1.0.dist-info/RECORD,,

prismaa-0.1.0.dist-info/WHEEL

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

prismaa-0.1.0.dist-info/entry_points.txt

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

prismaa-0.1.0.dist-info/licenses/LICENSE

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