docdsl 0.0.1__py3-none-any.whl

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/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

docdsl/dsl_builtins.py

@@ -0,0 +1,119 @@
+"""
+File: dsl_builtins.py
+Project: Docdsl
+File Created: Wed 15 Jul 2026 08:08:02 (Shine Jayakumar)
+Author: Shine Jayakumar (shinejayakumar@yahoo.com)
+-----
+Last Modified: Wed 15 Jul 2026 08:08:02 (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.
+"""
+
+from abc import ABC, abstractmethod
+
+
+class Position(ABC):
+
+    def __init__(self, parent, value):
+        self.value = value
+
+    @abstractmethod
+    def to_regex(self):
+        pass
+
+class End(Position):
+
+    def to_regex(self):
+        return r"[^\r\n]*"
+
+    def __repr__(self):
+        return f"End(value='{self.value}')"
+
+class NewLine(Position):
+
+    def to_regex(self):
+        return r"[^\r\n]*\s*"
+
+    def __repr__(self):
+        return f"NewLine(value='{self.value}')"
+
+
+class Builtin(ABC):
+
+    def __init__(self, parent, value):
+        self.value = value
+
+    @abstractmethod
+    def to_regex(self):
+        pass
+
+class Spaces(Builtin):
+
+    def to_regex(self):
+        return r"(?:[ \t]+)"
+
+    def __repr__(self):
+        return f"Spaces(value='{self.value}')"
+
+class WhiteSpaces(Builtin):
+
+    def to_regex(self):
+        return r"(?:\s+)"
+
+    def __repr__(self):
+        return f"WhiteSpaces(value='{self.value}')"
+
+
+class Digits(Builtin):
+
+    def to_regex(self):
+        return r"(?:\d+)"
+
+    def __repr__(self):
+        return f"Digits(value='{self.value}')"
+
+
+class AlphaNums(Builtin):
+
+    def to_regex(self):
+        return "(?:[A-Za-z\d]+)"
+
+    def __repr__(self):
+        return f"AlphaNums(value='{self.value}')"
+
+
+class CaptureLinesScope(ABC):
+
+    def __init__(self, parent, value):
+        self.value = value
+
+    @abstractmethod
+    def to_regex(self):
+        pass
+
+
+class SameLine(CaptureLinesScope):
+
+    def to_regex(self):
+        return r"(?:.*?)"
+
+    def __repr__(self):
+        return f"SameLine(value='{self.value}')"
+
+
+class AcrossLines(CaptureLinesScope):
+
+    def to_regex(self):
+        return r"(?s:.*?)"
+
+    def __repr__(self):
+        return f"AcrossLines(value='{self.value}')"
+
+
+if __name__ == "__main__":
+    pass

docdsl/dtformats.py

@@ -0,0 +1,190 @@
+"""
+File: dtformats.py
+Project: Docdsl
+File Created: Wed 15 Jul 2026 08:08:21 (Shine Jayakumar)
+Author: Shine Jayakumar (shinejayakumar@yahoo.com)
+-----
+Last Modified: Wed 15 Jul 2026 08:08:21 (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
+
+WEEKDAYS_FULL = ('Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday')
+WEEKDAYS_ABBR = ('Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun')
+MONTHS_FULL = ('January', 'February', 'March','April', 'May','June', 
+               'July','August','September'	,'October','November','December')
+MONTHS_ABBR = ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 
+              'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')
+
+
+def get_dtformat_suffixed(dtstr: str):
+    """ Returns date formats for dates with suffixes (st, nd, rd, th) """
+    dtstr = re.sub(r'\s+', ' ', dtstr.strip())
+    dtstr = re.sub(f'({"|".join(WEEKDAYS_FULL)})', '%A', dtstr) # Monday
+    dtstr = re.sub(f'({"|".join(WEEKDAYS_ABBR)})', '%a', dtstr) # Mon
+    dtstr = re.sub(f'({"|".join(MONTHS_FULL)})', '%B', dtstr) # January
+    dtstr = re.sub(f'({"|".join(MONTHS_ABBR)})', '%b', dtstr) # Jan
+    dtstr = re.sub(r'^(\d{1,2})(st|nd|rd|th)', r'%d\2', dtstr)
+    dtstr = re.sub(r'\s+(\d{1,2})(st|nd|rd|th)', r' %d\2', dtstr)
+    dtstr = re.sub(r'\d{4}', '%Y', dtstr)
+    dtstr = re.sub(r'\d{2}', '%y', dtstr)
+   
+    patterns = []
+    patterns.append(re.sub(r'(st|nd|rd|th)', 'st', dtstr))
+    patterns.append(re.sub(r'(st|nd|rd|th)', 'nd', dtstr))
+    patterns.append(re.sub(r'(st|nd|rd|th)', 'rd', dtstr))
+    patterns.append(re.sub(r'(st|nd|rd|th)', 'th', dtstr))
+
+    return patterns
+
+
+DTSAMPLE_PYFORMAT_MAP = {
+    "02 March 1999": "%d %B %Y",
+    "02-March-1999": "%d-%B-%Y",
+    "02/March/1999": "%d/%B/%Y",
+    "02.March.1999": "%d.%B.%Y",
+
+    "02 March 99": "%d %B %y",
+    "02-March-99": "%d-%B-%y",
+    "02/March/99": "%d/%B/%y",
+    "02.March.99": "%d.%B.%y",
+
+    "02 Mar 1999": "%d %b %Y",
+    "02-Mar-1999": "%d-%b-%Y",
+    "02/Mar/1999": "%d/%b/%Y",
+    "02.Mar.1999": "%d.%b.%Y",
+
+    "02 Mar 99": "%d %b %y",
+    "02-Mar-99": "%d-%b-%y",
+    "02/Mar/99": "%d/%b/%y",
+    "02.Mar.99": "%d.%b.%y",
+    
+    "Mar 02 1999": "%b %d %Y",
+    "Mar-02-1999": "%b-%d-%Y",
+    "Mar/02/1999": "%b/%d/%Y",
+    "Mar.02.1999": "%b.%d.%Y",
+
+    "Mar 02 99": "%b %d %y",
+    "Mar-02-99": "%b-%d-%y",
+    "Mar/02/99": "%b/%d/%y",
+    "Mar.02.99": "%b.%d.%y",
+
+
+    "March 02 1999": "%B %d %Y",
+    "March-02-1999": "%B-%d-%Y",
+    "March/02/1999": "%B/%d/%Y",
+    "March.02.1999": "%B.%d.%Y",
+
+    "March 02 99": "%B %d %y",
+    "March-02-99": "%B-%d-%y",
+    "March/02/99": "%B/%d/%y",
+    "March.02.99": "%B.%d.%y",
+
+    "Monday, 02 March 1999": "%A, %d %B %Y",
+    "Monday, 02 Mar 1999": "%A, %d %b %Y",
+
+    "Mon, 02 March 1999": "%a, %d %B %Y",
+    "Mon, 02 Mar 1999": "%a, %d %b %Y",
+
+    "Monday, March 02, 1999": "%A, %B %d, %Y",
+    "Monday, March 02 1999": "%A, %B %d %Y",
+
+    "Monday, Mar 02, 1999": "%A, %b %d, %Y",
+    "Monday, Mar 02 1999": "%A, %b %d %Y",
+
+    "Mon, March 02, 1999": "%a, %B %d, %Y",
+    "Mon, March 02 1999": "%a, %B %d %Y",
+
+    "Mon, Mar 02, 1999": "%a, %b %d, %Y",
+    "Mon, Mar 02 1999": "%a, %b %d %Y",
+
+    "Monday, 02 March 99": "%A, %d %B %y",
+    "Monday, 02 Mar 99": "%A, %d %b %y",
+
+    "Mon, 02 March 99": "%a, %d %B %y",
+    "Mon, 02 Mar 99": "%a, %d %b %y",
+
+    "Monday, March 02, 99": "%A, %B %d, %y",
+    "Monday, March 02 99": "%A, %B %d %y",
+
+    "Monday, Mar 02, 99": "%A, %b %d, %y",
+    "Monday, Mar 02 99": "%A, %b %d %y",
+
+    "Mon, March 02, 99": "%a, %B %d, %y",
+    "Mon, March 02 99": "%a, %B %d %y",
+
+    "Mon, Mar 02, 99": "%a, %b %d, %y",
+    "Mon, Mar 02 99": "%a, %b %d %y",
+
+    "Monday 2nd March 1999": ('%A %dst %B %Y', '%A %dnd %B %Y', '%A %drd %B %Y', '%A %dth %B %Y'),
+    "Monday 2nd Mar 1999": ('%A %dst %b %Y', '%A %dnd %b %Y', '%A %drd %b %Y', '%A %dth %b %Y'),
+    "Monday 2nd March 99": ('%A %dst %B %y', '%A %dnd %B %y', '%A %drd %B %y', '%A %dth %B %y'),
+    "Monday 2nd Mar 99": ('%A %dst %b %y', '%A %dnd %b %y', '%A %drd %b %y', '%A %dth %b %y'),
+
+    "Mon 2nd March 1999": ('%a %dst %B %Y', '%a %dnd %B %Y', '%a %drd %B %Y', '%a %dth %B %Y'),
+    "Mon 2nd Mar 1999": ('%a %dst %b %Y', '%a %dnd %b %Y', '%a %drd %b %Y', '%a %dth %b %Y'),
+    "Mon 2nd March 99": ('%a %dst %B %y', '%a %dnd %B %y', '%a %drd %B %y', '%a %dth %B %y'),
+    "Mon 2nd Mar 99": ('%a %dst %b %y', '%a %dnd %b %y', '%a %drd %b %y', '%a %dth %b %y'),
+
+    "Monday, 2nd March 1999": ('%A, %dst %B %Y', '%A %dnd %B %Y', '%A %drd %B %Y', '%A %dth %B %Y'),
+    "Monday, 2nd Mar 1999": ('%A, %dst %b %Y', '%A %dnd %b %Y', '%A %drd %b %Y', '%A %dth %b %Y'),
+    "Monday, 2nd March 99": ('%A, %dst %B %y', '%A %dnd %B %y', '%A %drd %B %y', '%A %dth %B %y'),
+    "Monday, 2nd Mar 99": ('%A, %dst %b %y', '%A %dnd %b %y', '%A %drd %b %y', '%A %dth %b %y'),
+
+    "Mon, 2nd March 1999": ('%a, %dst %B %Y', '%a %dnd %B %Y', '%a %drd %B %Y', '%a %dth %B %Y'),
+    "Mon, 2nd Mar 1999": ('%a, %dst %b %Y', '%a %dnd %b %Y', '%a %drd %b %Y', '%a %dth %b %Y'),
+    "Mon, 2nd March 99": ('%a, %dst %B %y', '%a %dnd %B %y', '%a %drd %B %y', '%a %dth %B %y'),
+    "Mon, 2nd Mar 99": ('%a, %dst %b %y', '%a %dnd %b %y', '%a %drd %b %y', '%a %dth %b %y'),
+
+    "2nd March 1999":  ('%dst %B %Y', '%dnd %B %Y', '%drd %B %Y', '%dth %B %Y'),
+    "2nd March 99":  ('%dst %B %y', '%dnd %B %y', '%drd %B %y', '%dth %B %y'),
+
+    "2nd Mar 1999":  ('%dst %b %Y', '%dnd %b %Y', '%drd %b %Y', '%dth %b %Y'),
+    "2nd Mar 99":  ('%dst %b %y', '%dnd %b %y', '%drd %b %y', '%dth %b %y'),
+
+    # yyyy mm dd
+    "1999-02-22": "%Y-%m-%d",
+    "1999/02/22": "%Y/%m/%d",
+    "1999.02.22": "%Y.%m.%d",
+    "1999 02 22": "%Y %m %d",
+    
+    # yy mm dd
+    "99-02-22": "%y-%m-%d",
+    "99/02/22": "%y/%m/%d",
+    "99.02.22": "%y.%m.%d",
+    "99 02 22": "%y %m %d",
+
+    # mm dd yy
+    "02/22/99": "%m/%d/%y",
+    "02-22-99": "%m-%d-%y",
+    "02.22.99": "%m.%d.%y",
+    "02 22 99": "%m %d %y",
+
+    # mm dd yyyy
+    "02/22/1999": "%m/%d/%Y",
+    "02-22-1999": "%m-%d-%Y",
+    "02.22.1999": "%m.%d.%Y",
+    "02 22 1999": "%m %d %Y",
+
+    # dd mm yy
+    "22/02/99": "%d/%m/%y",
+    "22-02-99": "%d-%m-%y",
+    "22.02.99": "%d.%m.%y",
+    "22 02 99": "%d %m %y",
+
+    # dd mm yyyy
+    "22/02/1999": "%d/%m/%Y",
+    "22-02-1999": "%d-%m-%Y",
+    "22.02.1999": "%d.%m.%Y",
+    "22 02 1999": "%d %m %Y",
+}
+
+if __name__ == '__main__':
+    pass