tiferet-ly 1.0.0__tar.gz

tiferet_ly-1.0.0/LICENSE

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

tiferet_ly-1.0.0/PKG-INFO

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: tiferet-ly
+Version: 1.0.0
+Summary: A Lex/Yacc wrapper built with Tiferet.
+Author-email: "Andrew Shatz, Great Strength Systems" <andrew@greatstrength.me>
+License: MIT
+Project-URL: Homepage, https://github.com/greatstrength/tiferet-ly
+Project-URL: Repository, https://github.com/greatstrength/tiferet-ly
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tiferet
+Requires-Dist: pydantic>=2.6
+Requires-Dist: ply>=3.11
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: PyYAML; extra == "test"
+Dynamic: license-file
+
+# tiferet-ly
+A Lex/Yacc Wrapper built with Tiferet
+
+## Overview
+tiferet-ly lets you describe a small language — its words and the sentence
+patterns it accepts — as a declared list instead of hand-written code. Hand
+tiferet-ly that declaration and get back a working reader for text written in
+that language, built on Python's well-established Lex/Yacc engine
+([PLY](https://github.com/dabeaz/ply)). Adding a new keyword or sentence
+pattern becomes an edit to the declaration rather than a new function buried
+in a growing file, and the pieces around it can be tested without invoking
+the real parsing engine at all.
+
+## Documentation
+Declare a language's words and sentence patterns as data. Translate that
+declaration into the form the Lex/Yacc engine expects. Assemble those
+translated rules into a reader. Read text written in the declared language
+and hand back the result.
+
+- [Quick-Start](docs/quick-start.md) — run the checked-in calculator from
+  the repository root.
+- [Domain Vision Statement](docs/domain-vision.md) — what tiferet-ly is for
+  and the value it aims to provide.
+- [Core Domain Distillation](docs/core-domain-distillation.md) — the
+  technical breakdown of its intended vocabulary, behaviors, and design
+  commitments.
+- [AGENTS.md](AGENTS.md) — orientation for contributors and AI agents
+  working in this repository.

tiferet_ly-1.0.0/README.md

@@ -0,0 +1,28 @@
+# tiferet-ly
+A Lex/Yacc Wrapper built with Tiferet
+
+## Overview
+tiferet-ly lets you describe a small language — its words and the sentence
+patterns it accepts — as a declared list instead of hand-written code. Hand
+tiferet-ly that declaration and get back a working reader for text written in
+that language, built on Python's well-established Lex/Yacc engine
+([PLY](https://github.com/dabeaz/ply)). Adding a new keyword or sentence
+pattern becomes an edit to the declaration rather than a new function buried
+in a growing file, and the pieces around it can be tested without invoking
+the real parsing engine at all.
+
+## Documentation
+Declare a language's words and sentence patterns as data. Translate that
+declaration into the form the Lex/Yacc engine expects. Assemble those
+translated rules into a reader. Read text written in the declared language
+and hand back the result.
+
+- [Quick-Start](docs/quick-start.md) — run the checked-in calculator from
+  the repository root.
+- [Domain Vision Statement](docs/domain-vision.md) — what tiferet-ly is for
+  and the value it aims to provide.
+- [Core Domain Distillation](docs/core-domain-distillation.md) — the
+  technical breakdown of its intended vocabulary, behaviors, and design
+  commitments.
+- [AGENTS.md](AGENTS.md) — orientation for contributors and AI agents
+  working in this repository.

tiferet_ly-1.0.0/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "tiferet-ly"
+dynamic = ["version"]
+description = "A Lex/Yacc wrapper built with Tiferet."
+authors = [
+    { name = "Andrew Shatz, Great Strength Systems", email = "andrew@greatstrength.me" }
+]
+license = { text = "MIT" }
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "tiferet",
+    "pydantic>=2.6",
+    "ply>=3.11",
+]
+
+[project.urls]
+Homepage = "https://github.com/greatstrength/tiferet-ly"
+Repository = "https://github.com/greatstrength/tiferet-ly"
+
+[project.optional-dependencies]
+test = [
+    "pytest",
+    "PyYAML",
+]
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["tiferet_ly*"]
+
+[tool.setuptools.dynamic]
+version = { attr = "tiferet_ly.__version__" }
+
+[tool.pytest.ini_options]
+addopts = "--import-mode=importlib"

tiferet_ly-1.0.0/setup.cfg

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

tiferet_ly-1.0.0/tiferet_ly/__init__.py

@@ -0,0 +1,6 @@
+"""Tiferet Ly"""
+
+# *** constants
+
+# ** constant: version
+__version__ = '1.0.0'

tiferet_ly-1.0.0/tiferet_ly/assets/__init__.py

@@ -0,0 +1,9 @@
+"""Tiferet Ly Assets"""
+
+# *** imports
+
+# ** app
+from . import error
+from . import grammar
+from . import reader
+from . import translation

tiferet_ly-1.0.0/tiferet_ly/assets/error.py

@@ -0,0 +1,12 @@
+"""Tiferet Ly Error Assets"""
+
+# *** constants (ids)
+
+# ** constant: token_already_exists_id
+TOKEN_ALREADY_EXISTS_ID = 'TOKEN_ALREADY_EXISTS'
+
+# ** constant: token_not_found_id
+TOKEN_NOT_FOUND_ID = 'TOKEN_NOT_FOUND'
+
+# ** constant: token_action_not_supported_id
+TOKEN_ACTION_NOT_SUPPORTED_ID = 'TOKEN_ACTION_NOT_SUPPORTED'

tiferet_ly-1.0.0/tiferet_ly/assets/grammar.py

@@ -0,0 +1,21 @@
+"""Tiferet Ly Grammar Assets"""
+
+# *** constants (ids)
+
+# ** constant: grammar_already_exists_id
+GRAMMAR_ALREADY_EXISTS_ID = 'GRAMMAR_ALREADY_EXISTS'
+
+# ** constant: grammar_not_found_id
+GRAMMAR_NOT_FOUND_ID = 'GRAMMAR_NOT_FOUND'
+
+# ** constant: grammar_cycle_detected_id
+GRAMMAR_CYCLE_DETECTED_ID = 'GRAMMAR_CYCLE_DETECTED'
+
+# ** constant: grammar_start_not_found_id
+GRAMMAR_START_NOT_FOUND_ID = 'GRAMMAR_START_NOT_FOUND'
+
+# ** constant: grammar_parent_not_found_id
+GRAMMAR_PARENT_NOT_FOUND_ID = 'GRAMMAR_PARENT_NOT_FOUND'
+
+# ** constant: grammar_still_referenced_id
+GRAMMAR_STILL_REFERENCED_ID = 'GRAMMAR_STILL_REFERENCED'

tiferet_ly-1.0.0/tiferet_ly/assets/reader.py

@@ -0,0 +1,12 @@
+"""Tiferet Ly Reader Assets"""
+
+# *** constants (ids)
+
+# ** constant: lex_error_id
+LEX_ERROR_ID = 'LEX_ERROR'
+
+# ** constant: parse_error_id
+PARSE_ERROR_ID = 'PARSE_ERROR'
+
+# ** constant: reader_build_failed_id
+READER_BUILD_FAILED_ID = 'READER_BUILD_FAILED'

tiferet_ly-1.0.0/tiferet_ly/assets/translation.py

@@ -0,0 +1,9 @@
+"""Tiferet Ly Translation Error Assets"""
+
+# *** constants (ids)
+
+# ** constant: action_compilation_failed_id
+ACTION_COMPILATION_FAILED_ID = 'ACTION_COMPILATION_FAILED'
+
+# ** constant: rule_pattern_invalid_id
+RULE_PATTERN_INVALID_ID = 'RULE_PATTERN_INVALID'

tiferet_ly-1.0.0/tiferet_ly/domain/__init__.py

@@ -0,0 +1,30 @@
+"""Tiferet Ly Domain"""
+
+# *** imports
+
+# ** app
+from .token import (
+    TokenRule,
+    SimpleTokenRule,
+    ComplexTokenRule,
+)
+from .production import (
+    ProductionRule,
+    SimpleProductionRule,
+    ComplexProductionRule,
+)
+from .grammar import Grammar
+from .ast import AstNode
+
+# *** exports
+
+__all__ = [
+    'TokenRule',
+    'SimpleTokenRule',
+    'ComplexTokenRule',
+    'ProductionRule',
+    'SimpleProductionRule',
+    'ComplexProductionRule',
+    'Grammar',
+    'AstNode',
+]

tiferet_ly-1.0.0/tiferet_ly/domain/ast.py

@@ -0,0 +1,53 @@
+"""Tiferet Ly AST Domain Models"""
+
+# *** imports
+
+# ** core
+from typing import Any
+
+# ** infra
+from pydantic import Field
+
+# ** app
+from tiferet.domain.core import DomainObject
+
+# *** models
+
+# ** model: ast_node
+class AstNode(DomainObject):
+    '''
+    An optional generic node for a parse that chooses to keep structure.
+
+    The node stores a kind, children, a value, and a source span. It is
+    not a required parse result.
+    '''
+
+    # * attribute: kind
+    kind: str = Field(
+        ...,
+        description='The kind of generic node.',
+    )
+
+    # * attribute: children
+    children: list = Field(
+        default_factory=list,
+        description='The child nodes stored under this node.',
+    )
+
+    # * attribute: value
+    value: Any | None = Field(
+        default=None,
+        description='The optional value carried by this node.',
+    )
+
+    # * attribute: lineno
+    lineno: int | None = Field(
+        default=None,
+        description='The optional source line of this node.',
+    )
+
+    # * attribute: lexpos
+    lexpos: int | None = Field(
+        default=None,
+        description='The optional source character offset of this node.',
+    )

tiferet_ly-1.0.0/tiferet_ly/domain/grammar.py

@@ -0,0 +1,42 @@
+"""Tiferet Ly Grammar Domain Models"""
+
+# *** imports
+
+# ** core
+from typing import List
+
+# ** infra
+from pydantic import Field
+
+# ** app
+from tiferet.domain.core import DomainObject
+
+# *** models
+
+# ** model: grammar
+class Grammar(DomainObject):
+    '''
+    The identity and composition of one declared grammar.
+
+    A grammar names itself, the grammars it composes, and the production
+    it starts from. It does not own a rule catalogue or check those facts
+    against any other aggregate.
+    '''
+
+    # * attribute: id
+    id: str = Field(
+        ...,
+        description='The grammar identifier.',
+    )
+
+    # * attribute: parent_ids
+    parent_ids: List[str] = Field(
+        default_factory=list,
+        description='The ordered identifiers of the grammars this grammar composes.',
+    )
+
+    # * attribute: start
+    start: str = Field(
+        ...,
+        description='The declared start-production name.',
+    )

tiferet_ly-1.0.0/tiferet_ly/domain/lexeme.py

@@ -0,0 +1,44 @@
+"""Tiferet Ly Lexeme Domain Models"""
+
+# *** imports
+
+# ** infra
+from pydantic import Field
+
+# ** app
+from tiferet.domain.core import DomainObject
+
+# *** models
+
+# ** model: lexeme
+class Lexeme(DomainObject):
+    '''
+    A recognized word and the source span where it was read.
+
+    The value is structural. Later AST work can reuse the same type,
+    text, line, and position without depending on a reader token.
+    '''
+
+    # * attribute: type
+    type: str = Field(
+        ...,
+        description='The token type name of the recognized word.',
+    )
+
+    # * attribute: value
+    value: str = Field(
+        ...,
+        description='The matched text of the recognized word.',
+    )
+
+    # * attribute: lineno
+    lineno: int = Field(
+        ...,
+        description='The source line of the match.',
+    )
+
+    # * attribute: lexpos
+    lexpos: int = Field(
+        ...,
+        description='The source character offset of the match.',
+    )

tiferet_ly-1.0.0/tiferet_ly/domain/production.py

@@ -0,0 +1,68 @@
+"""Tiferet Ly Production Domain Models"""
+
+# *** imports
+
+# ** infra
+from pydantic import Field
+
+# ** app
+from tiferet.domain.core import DomainObject
+
+# *** models
+
+# ** model: production_rule
+class ProductionRule(DomainObject):
+    '''
+    A declared sentence rule, owned by exactly one grammar.
+
+    A repeated name is a legal alternative, not a duplicate declaration.
+    Specification and action source belong to the Simple and Complex variants.
+    '''
+
+    # * attribute: name
+    name: str = Field(
+        ...,
+        description='The declared production name.',
+    )
+
+    # * attribute: grammar_id
+    grammar_id: str = Field(
+        ...,
+        description='The identifier of the one grammar that owns the production.',
+    )
+
+# ** model: simple_production_rule
+class SimpleProductionRule(ProductionRule):
+    '''
+    A production whose declaration is a grammar specification only.
+
+    Simple productions store no action source and do not themselves
+    implement a translation-time pass-through.
+    '''
+
+    # * attribute: spec
+    spec: str = Field(
+        ...,
+        description='The declared grammar specification for the production.',
+    )
+
+# ** model: complex_production_rule
+class ComplexProductionRule(ProductionRule):
+    '''
+    A production that declares both a specification and action source.
+
+    The action is stored as source text. Compiling or executing it is
+    outside the domain model.
+    '''
+
+    # * attribute: spec
+    spec: str = Field(
+        ...,
+        description='The declared grammar specification for the production.',
+    )
+
+    # * attribute: action
+    action: str = Field(
+        ...,
+        description='The declared action source for the production.',
+    )

tiferet_ly-1.0.0/tiferet_ly/domain/token.py

@@ -0,0 +1,68 @@
+"""Tiferet Ly Token Domain Models"""
+
+# *** imports
+
+# ** infra
+from pydantic import Field
+
+# ** app
+from tiferet.domain.core import DomainObject
+
+# *** models
+
+# ** model: token_rule
+class TokenRule(DomainObject):
+    '''
+    A declared word in a language, owned by exactly one grammar.
+
+    The rule stores its name and grammar membership only. Pattern and
+    action source belong to the Simple and Complex variants.
+    '''
+
+    # * attribute: name
+    name: str = Field(
+        ...,
+        description='The bare declared token name.',
+    )
+
+    # * attribute: grammar_id
+    grammar_id: str = Field(
+        ...,
+        description='The identifier of the one grammar that owns the rule.',
+    )
+
+# ** model: simple_token_rule
+class SimpleTokenRule(TokenRule):
+    '''
+    A token rule whose declaration is a pattern and nothing else.
+
+    Simple rules carry no action source. Matching behavior is the
+    pattern itself.
+    '''
+
+    # * attribute: pattern
+    pattern: str = Field(
+        ...,
+        description='The declared match pattern for the token.',
+    )
+
+# ** model: complex_token_rule
+class ComplexTokenRule(TokenRule):
+    '''
+    A token rule that declares both a pattern and action source.
+
+    The action is stored as source text. Compiling or executing it is
+    outside the domain model.
+    '''
+
+    # * attribute: pattern
+    pattern: str = Field(
+        ...,
+        description='The declared match pattern for the token.',
+    )
+
+    # * attribute: action
+    action: str = Field(
+        ...,
+        description='The declared action source for the token.',
+    )

tiferet_ly-1.0.0/tiferet_ly/events/__init__.py

@@ -0,0 +1 @@
+"""Tiferet Ly Events"""