docdsl 0.0.1__tar.gz

docdsl-0.0.1/LICENSE

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

docdsl-0.0.1/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: docdsl
+Version: 0.0.1
+Summary: A domain-specific language (DSL) for building readable text extraction rules.
+Author-email: Shine Jayakumar <shinejayakumar@yahoo.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/shine-jayakumar/docdsl
+Project-URL: Repository, https://github.com/shine-jayakumar/docdsl
+Project-URL: Documentation, https://github.com/shine-jayakumar/docdsl/blob/master/Documentation.md
+Project-URL: Issues, https://github.com/shine-jayakumar/docdsl/issues
+Keywords: dsl,regex,parser,text-extraction,pattern-matching,textx
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Text Processing
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: textX<5,>=4.4
+Dynamic: license-file
+
+# DocDSL
+
+![License](https://img.shields.io/static/v1?label=license&message=MIT&color=green)
+![Open Source](https://img.shields.io/static/v1?label=OpenSource&message=Yes&color=brightgreen)
+![Version](https://img.shields.io/static/v1?label=version&message=v.0.0.1&color=blue)
+![Status](https://img.shields.io/badge/status-alpha-yellow.svg)
+
+
+A declarative DSL for extracting structured information from OCR output, PDFs, reports, and other semi-structured documents.
+
+Instead of writing large, difficult-to-maintain regular expressions, **DocDSL** lets you describe **what** to extract using a simple, readable language while keeping extraction rules separate from your application code.
+
+---
+
+# Installation
+
+```bash
+pip install docdsl
+```
+
+---
+
+# Quick Start
+
+## 1. Define your entities
+
+Entities are reusable regular expressions that can be referenced throughout your DSL.
+
+```python
+from docdsl import DSLTranslator, Entity
+
+NAME = Entity(
+    name="NAME",
+    pattern=r"[A-Za-z ,.'-]+"
+)
+
+POSTCODE = Entity(
+    name="POSTCODE",
+    pattern=r"[A-Z]{1,2}\d[A-Z\d]?\s?\d[A-Z]{2}"
+)
+```
+
+## 2. Create a translator
+
+```python
+translator = DSLTranslator(
+    entities=[
+        NAME,
+        POSTCODE,
+    ]
+)
+```
+
+## 3. Write your extraction rules
+
+```python
+dsl = """
+FIND "Name:";
+SKIP UNTIL NEWLINE;
+CAPTURE TARGET [@NAME];
+"""
+```
+
+## 4. Generate the regular expression
+
+```python
+pattern = translator.translate(dsl)
+```
+
+Your DSL is translated into a regular expression that can be used as part of your document extraction pipeline.
+
+---
+
+# Features
+
+- Declarative, English-like extraction language
+- Reusable named entities
+- Readable extraction rules
+- Conditional extraction using `IF`
+- Multi-line capture
+- Capture between delimiters
+- Built-in helper tokens
+- Friendly syntax and validation errors
+- Exact error locations with line and column information
+
+---
+
+# Entities
+
+Entities represent reusable regular expressions.
+
+```python
+TITLE = Entity(
+    name="TITLE",
+    pattern=r"(?:Mr|Mrs|Ms|Miss|Dr)\.?"
+)
+```
+
+Supply your entities when creating the translator.
+
+```python
+translator = DSLTranslator(
+    entities=[
+        TITLE,
+        NAME,
+        POSTCODE,
+    ]
+)
+```
+
+Inside the DSL, entities are referenced using the `@` prefix.
+
+```text
+@TITLE
+@NAME
+@POSTCODE
+```
+
+If the DSL references an entity that was not supplied to `DSLTranslator`, an `UndefinedEntity` exception is raised.
+
+---
+
+# Documentation
+
+For the complete language reference, see **DSL_REFERENCE.md**.
+
+The reference includes:
+
+- Complete command reference
+- DSL syntax
+- Built-in helper tokens
+- Conditional statements
+- Examples
+- Best practices
+- Exception reference
+
+---
+
+# Requirements
+
+- Python 3.11+
+
+---
+
+# Contributing
+
+Contributions, bug reports and feature requests are welcome.
+
+If you discover a bug or have an idea for improving **DocDSL**, please open an issue or submit a pull request.
+
+---
+
+# License
+
+Released under the MIT License.

docdsl-0.0.1/README.md

@@ -0,0 +1,155 @@
+# DocDSL
+
+![License](https://img.shields.io/static/v1?label=license&message=MIT&color=green)
+![Open Source](https://img.shields.io/static/v1?label=OpenSource&message=Yes&color=brightgreen)
+![Version](https://img.shields.io/static/v1?label=version&message=v.0.0.1&color=blue)
+![Status](https://img.shields.io/badge/status-alpha-yellow.svg)
+
+
+A declarative DSL for extracting structured information from OCR output, PDFs, reports, and other semi-structured documents.
+
+Instead of writing large, difficult-to-maintain regular expressions, **DocDSL** lets you describe **what** to extract using a simple, readable language while keeping extraction rules separate from your application code.
+
+---
+
+# Installation
+
+```bash
+pip install docdsl
+```
+
+---
+
+# Quick Start
+
+## 1. Define your entities
+
+Entities are reusable regular expressions that can be referenced throughout your DSL.
+
+```python
+from docdsl import DSLTranslator, Entity
+
+NAME = Entity(
+    name="NAME",
+    pattern=r"[A-Za-z ,.'-]+"
+)
+
+POSTCODE = Entity(
+    name="POSTCODE",
+    pattern=r"[A-Z]{1,2}\d[A-Z\d]?\s?\d[A-Z]{2}"
+)
+```
+
+## 2. Create a translator
+
+```python
+translator = DSLTranslator(
+    entities=[
+        NAME,
+        POSTCODE,
+    ]
+)
+```
+
+## 3. Write your extraction rules
+
+```python
+dsl = """
+FIND "Name:";
+SKIP UNTIL NEWLINE;
+CAPTURE TARGET [@NAME];
+"""
+```
+
+## 4. Generate the regular expression
+
+```python
+pattern = translator.translate(dsl)
+```
+
+Your DSL is translated into a regular expression that can be used as part of your document extraction pipeline.
+
+---
+
+# Features
+
+- Declarative, English-like extraction language
+- Reusable named entities
+- Readable extraction rules
+- Conditional extraction using `IF`
+- Multi-line capture
+- Capture between delimiters
+- Built-in helper tokens
+- Friendly syntax and validation errors
+- Exact error locations with line and column information
+
+---
+
+# Entities
+
+Entities represent reusable regular expressions.
+
+```python
+TITLE = Entity(
+    name="TITLE",
+    pattern=r"(?:Mr|Mrs|Ms|Miss|Dr)\.?"
+)
+```
+
+Supply your entities when creating the translator.
+
+```python
+translator = DSLTranslator(
+    entities=[
+        TITLE,
+        NAME,
+        POSTCODE,
+    ]
+)
+```
+
+Inside the DSL, entities are referenced using the `@` prefix.
+
+```text
+@TITLE
+@NAME
+@POSTCODE
+```
+
+If the DSL references an entity that was not supplied to `DSLTranslator`, an `UndefinedEntity` exception is raised.
+
+---
+
+# Documentation
+
+For the complete language reference, see **DSL_REFERENCE.md**.
+
+The reference includes:
+
+- Complete command reference
+- DSL syntax
+- Built-in helper tokens
+- Conditional statements
+- Examples
+- Best practices
+- Exception reference
+
+---
+
+# Requirements
+
+- Python 3.11+
+
+---
+
+# Contributing
+
+Contributions, bug reports and feature requests are welcome.
+
+If you discover a bug or have an idea for improving **DocDSL**, please open an issue or submit a pull request.
+
+---
+
+# License
+
+Released under the MIT License.

docdsl-0.0.1/docdsl/__init__.py

@@ -0,0 +1,19 @@
+"""
+File: __init__.py
+Project: Docdsl
+File Created: Wed 15 Jul 2026 08:07:46 (Shine Jayakumar)
+Author: Shine Jayakumar (shinejayakumar@yahoo.com)
+-----
+Last Modified: Wed 15 Jul 2026 08:07:46 (Shine Jayakumar)
+Modified By: Shine Jayakumar (shinejayakumar@yahoo.com)
+-----
+Copyright (c) 2026 Shine Jayakumar
+SPDX-License-Identifier: MIT
+
+Licensed under the MIT License.
+See the LICENSE file in the project root for the full license text.
+"""
+
+__version__ = "0.0.1"
+
+from .translator import DSLTranslator, Entity

docdsl-0.0.1/docdsl/commands.py

@@ -0,0 +1,338 @@
+"""
+File: commands.py
+Project: Docdsl
+File Created: Wed 15 Jul 2026 08:07:54 (Shine Jayakumar)
+Author: Shine Jayakumar (shinejayakumar@yahoo.com)
+-----
+Last Modified: Wed 15 Jul 2026 08:07:54 (Shine Jayakumar)
+Modified By: Shine Jayakumar (shinejayakumar@yahoo.com)
+-----
+Copyright (c) 2026 Shine Jayakumar
+SPDX-License-Identifier: MIT
+
+Licensed under the MIT License.
+See the LICENSE file in the project root for the full license text.
+"""
+
+import re
+from dataclasses import dataclass, field
+from .dsl_builtins import *
+from .text_to_regex import TextToRegex
+
+
+@dataclass
+class Entity:
+    parent: object
+    name: str
+
+    @property
+    def group_name(self):
+        return f"{self.name[1:]}"
+
+    def to_regex(self):
+        return f"__{self.name[1:]}__"
+
+
+@dataclass
+class Command:
+    parent: object
+
+
+@dataclass
+class Find(Command):
+    items: list = None
+
+    def to_regex(self):
+        pat_parts = [item.to_regex() for item in self.items]
+        pattern = "|".join(pat_parts)
+        pattern = f"(?:{pattern})" if len(self.items) > 1 else pattern
+        return pattern
+
+
+@dataclass
+class FindItem(Command):
+
+    text: str = ""
+    ignorecase: bool = False
+
+    def to_regex(self):
+        pat = TextToRegex().get_regex(self.text)
+        pat = f"(?i:{pat})" if self.ignorecase else pat
+        return pat
+
+
+@dataclass
+class Skip(Command):
+
+    position: str = ""
+    until: str = ""
+    ignorecase: bool = False
+
+    def to_regex(self):
+        if self.position:
+            return self.position.to_regex()
+
+        if self.until:
+            until = re.escape(self.until)
+            until = f"(?i:{until})" if self.ignorecase else until
+            pat = rf".*?{until}"
+            return pat
+
+
+@dataclass
+class SkipLines(Command):
+
+    until: str
+
+    def to_regex(self):
+        until = re.escape(self.until)
+        pat = rf"[\s\S]*?{until}"
+        return pat
+
+
+@dataclass
+class SkipNLines(Command):
+
+    lines: int
+
+    def to_regex(self):
+        pat = rf"(?:.*[\r\n]){{{self.lines}}}"
+        return pat
+
+
+#@dataclass
+#class Capture(Command):
+#
+#    items: list = None
+#    until: str = ""
+#    position: Position = None
+#
+#    def to_regex(self):
+#        target_count = sum([bool(item.target) for item in self.items])
+#        if not target_count:
+#            raise Exception("CAPTURE requires at least one target entity")
+#        if target_count > 1:
+#            raise Exception("CAPTURE cannot have more than one target entity")
+#
+#        target = self.items[-1]
+#        pat_parts = [item.to_regex() for item in self.items[:-1]]
+#        target_pat = target.target.to_regex()
+#        group_name = target.target.entity.group_name
+#        pat_parts.append(f"(?P<{group_name}>{target_pat})")
+#        if self.until:
+#            until_pat = TextToRegex().get_regex(self.until)
+#            pat_parts.append(until_pat)
+#        elif self.position:
+#            pos = self.position.to_regex()
+#            pat_parts.append(pos)
+#        return "".join(pat_parts)
+
+    #def __repr__(self):
+    #    return (
+    #        "Capture(items=[\n"
+    #        f"{self.items}\n]\n,"
+    #        f"until={self.until},\n"
+    #        f"position={self.position}\n"
+    #        ")"
+    #    )
+@dataclass
+class TargetEntity(Command):
+
+    entity: Entity
+
+    def to_regex(self):
+        return self.entity.to_regex()
+
+
+
+@dataclass
+class Capture(Command):
+
+    items: list = None
+    target: TargetEntity = None
+    until: str = ""
+    position: Position = None
+
+    def to_regex(self):
+        pat_parts = [item.to_regex() for item in self.items]
+        target_pat = self.target.entity.to_regex()
+        group_name = self.target.entity.group_name
+        pat_parts.append(f"(?P<{group_name}>{target_pat})")
+        if self.until:
+            until_pat = TextToRegex().get_regex(self.until)
+            pat_parts.append(until_pat)
+        elif self.position:
+            pos = self.position.to_regex()
+            pat_parts.append(pos)
+        return "".join(pat_parts)
+
+
+
+#@dataclass
+#class CaptureItem(Command):
+#
+#    optional: bool = False
+#    builtin: Builtin=None
+#    entity: str = None
+#    target: TargetEntity = None
+#
+#    def to_regex(self):
+#        if self.builtin:
+#            pat = self.builtin.to_regex()
+#            pat = f"{pat}?" if self.optional else pat
+#            return pat
+#
+#        if self.entity:
+#            pat = self.entity.to_regex()
+#            pat = f"{pat}?" if self.optional else pat
+#            return pat
+#
+#        if self.target:
+#            return self.target.entity.to_regex()
+
+@dataclass
+class CaptureItem(Command):
+
+    optional: bool = False
+    builtin: Builtin=None
+    entity: str = None
+
+    def to_regex(self):
+        if self.builtin:
+            pat = self.builtin.to_regex()
+            pat = f"{pat}?" if self.optional else pat
+            return pat
+
+        if self.entity:
+            pat = self.entity.to_regex()
+            pat = f"{pat}?" if self.optional else pat
+            return pat
+
+
+@dataclass
+class CaptureNLines(Command):
+
+    lines: int
+    target: TargetEntity
+
+    def to_regex(self):
+        group_name = self.target.entity.group_name
+        #pat = rf"(?P<{entity}>(?:.*[\r\n]){{{self.lines}}})"
+        pat = rf"(?P<{group_name}>(?:.*\r?\n){{{self.lines}}})"
+        return pat
+
+
+@dataclass
+class CaptureLines(Command):
+
+    until: str
+    target: TargetEntity
+    ignorecase: bool = False
+
+    def to_regex(self):
+        group_name = self.target.entity.group_name
+        between = AcrossLines(None, None).to_regex()
+        until = TextToRegex().get_regex(self.until)
+        until = f"(?i:{until})" if self.ignorecase else until
+        pat = rf"(?P<{group_name}>{between}){until}"
+        return pat
+
+
+@dataclass
+class CaptureBetween(Command):
+
+    start: str
+    end: str
+    target: TargetEntity
+    scope: CaptureLinesScope = None
+
+    def to_regex(self):
+        group_name = self.target.entity.group_name
+        start = self.start.to_regex()
+        end = self.end.to_regex()
+        between = (
+            AcrossLines(None, None).to_regex() if not self.scope
+            else self.scope.to_regex()
+        )
+        pat = rf"{start}(?P<{group_name}>{between}){end}"
+        return pat
+
+
+@dataclass
+class CaptureBetweenItem(Command):
+
+    text: str
+    ignorecase: bool = False
+
+    def to_regex(self):
+        pat = TextToRegex().get_regex(self.text)
+        pat = f"(?i:{pat})" if self.ignorecase else pat
+        return pat
+
+
+@dataclass
+class If(Command):
+
+    items: list = None
+    commands: list[Command] = None
+
+    def _get_item_pattern(self) -> str:
+        pat_parts = [item.to_regex() for item in self.items]
+        pat = "|".join(pat_parts)
+        pat = f"({pat})" if len(pat_parts) > 1 else pat
+        return pat
+
+    def _get_command_pattern(self) -> str:
+        pat_parts = [cmd.to_regex() for cmd in self.commands]
+        pat = "".join(pat_parts)
+        return pat
+        
+    def to_regex(self):
+        #pat_parts = [item.to_regex() for item in self.items]
+        #pat = "|".join(pat_parts)
+        #pat = f"({pat})" if len(pat_parts) > 1 else pat
+
+        #pat += self.action.to_regex()
+        pat = self._get_item_pattern()
+        pat += self._get_command_pattern()
+        pat = f"(?:{pat})?"
+        return pat
+
+        #for item in self.items:
+        #    pat = self.item.to_regex()
+        #pat = ""
+        #if self.keyword:
+        #    kwd_pattern = TextToRegex().get_regex(self.keyword)
+        #    pat += kwd_pattern
+        #elif self.entity:
+        #    ent = f"__{self.entity}__"
+        #    pat += ent
+        #action_pattern = self.action.to_regex()
+        #pat += action_pattern
+        #pat = f"(?:{pat})?"
+        #return pat
+
+
+
+@dataclass
+class IfItem(Command):
+
+    text: str = ""
+    entity: Entity = None
+    ignorecase: bool = False
+
+    def to_regex(self):
+        if self.text:
+            pat = TextToRegex().get_regex(self.text)
+            pat = f"(?i:{pat})" if self.ignorecase else pat
+            return pat
+
+        # for entity
+        pat = self.entity.to_regex()
+        pat = f"(?i:{pat})" if self.ignorecase else pat
+        return pat
+
+
+
+if __name__ == "__main__":
+    pass