Parsing started

Author: Sven Siegmund

setup.py

@@ -73,7 +73,7 @@ def get_property(property: str, path_to_init_file: pathlib.Path) -> str:
         python_requires=">=3.9",
         install_requires=requirements,
         entry_points={
-            "console_scripts": [f"{project_name} = {project_name}.__main__:main",
+            "console_scripts": [f"{project_name} = {project_name}.__main__:{project_name}",
                 ],
             },
         platforms=["any"],

src/rtfparse/__main__.py

@@ -6,9 +6,9 @@
 from rtfparse import entry
 
 
-def main():
+def rtfparse():
     sys.exit(entry.cli_start(version.version))
 
 
 if __name__ == "__main__":
-    main()
+    rtfparse()

src/rtfparse/bytestring_types.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python
+
+
+"""
+Control Word Types
+"""
+
+
+from rtfparse import re_patterns
+
+
+class Plain_Text:
+    pass
+
+
+class Group_Start:
+    pass
+
+
+class Group_End:
+    pass
+
+
+class Cwtype:
+    default_delimiter = " "
+
+
+class Flag(Cwtype):
+    native_pattern = re_patterns.control_word
+    def __init__(self, pattern: str) -> None:
+        self.something = self.native_pattern.pattern.match((pattern + self.default_delimiter).encode("ascii"))
+
+
+if __name__ == "__main__":
+    pass

src/rtfparse/entities.py

@@ -3,16 +3,84 @@
 
 import io
 import logging
+import re
 from rtfparse import re_patterns
+from rtfparse import utils
+from rtfparse.enums import Bytestring_Type
 
 
 # Setup logging
 logger = logging.getLogger(__name__)
 
 
-class Destination_Group:
+# Constants, number of bytes to read when creating entities
+CHARACTER = BACKSLASH = len(b"\\")
+IGNORABLE = BACKSLASH + len(rb"*")
+GROUP_START = len(rb"x") + IGNORABLE # x = "}" cannot have a rogue brace for vim's auto-indent's sake
+DELIMITER = len(rb" ")
+MAX_CW_LETTERS = 32
+INTEGER_MAGNITUDE = 32
+CONTROL_WORD = BACKSLASH + MAX_CW_LETTERS + len(rb"-") + len(str((1 << INTEGER_MAGNITUDE) // 2)) + DELIMITER
+
+
+class Entity:
+    @classmethod
+    def probe(cls, pattern: re_patterns.Bytes_Regex, file: io.BufferedReader) -> Bytestring_Type:
+        logger.debug(f"in Entity.probed")
+        original_position = file.tell()
+        probed = file.read(len(re_patterns.probe_pattern))
+        logger.debug(f"{probed = }")
+        file.seek(original_position - len(probed))
+        if (match := re_patterns.group_start.match(probed)):
+            result = Bytestring_Type.GROUP_START
+        elif (match := re_patterns.group_end.match(probed)):
+            result = Bytestring_Type.GROUP_END
+        elif (match := re_patterns.control_word.match(probed)):
+            result = Bytestring_Type.CONTROL_WORD
+        elif (match := re_patterns.control_symbol.match(probed)):
+            result = Bytestring_Type.CONTROL_SYMBOL
+        else:
+            result = Bytestring_Type.PLAIN_TEXT
+        logger.debug(f"{result = }")
+        return result
+
+
+class Control_Word(Entity):
+    def __init__(self, file: io.BufferedReader) -> None:
+        logger.debug(f"Control_Word.__init__")
+        self.start_position = file.tell()
+        logger.debug(f"Starting at file position {self.start_position}")
+        probe = file.read(CONTROL_WORD)
+        if (match := re_patterns.control_word.match(probe)):
+            self.control_name = match.group("control_name")
+            logger.debug(f"{self.control_name = }")
+            self.parameter = match.group("parameter")
+            file.seek(self.start_position + match.span()[1])
+
+
+class Destination_Group(Entity):
     def __init__(self, file: io.BufferedReader) -> None:
+        logger.debug(f"Destination_Group.__init__")
         logger.debug(f"Creating destination group from {file.name}")
+        self.known = False
+        self.name = "unknown"
+        self.ignorable = False
+        self.start_position = file.tell()
+        logger.debug(f"Starting at file position {self.start_position}")
+        probe = file.read(GROUP_START)
+        logger.debug(f"Read file up to position {file.tell()}")
+        if (match := re_patterns.group_start.match(probe)):
+            self.known = bool(match.group("group_start"))
+            self.ignorable = bool(match.group("ignorable"))
+            if not self.ignorable:
+                file.seek(-IGNORABLE, io.SEEK_CUR)
+                logger.debug(f"Returned to position {file.tell()}")
+            self.cw = Control_Word(file)
+            self.name = self.cw.control_name
+        else:
+            logger.warning(utils.warn(f"Expected group has no start. Creating unknown group"))
+        probed = self.probe(re_patterns.probe, file)
+        self.content = list()
 
 
 if __name__ == "__main__":

src/rtfparse/enums.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python
+
+
+from enum import Enum, unique, auto
+
+
+@unique
+class Bytestring_Type(Enum):
+    GROUP_START = auto()
+    GROUP_END = auto()
+    CONTROL_WORD = auto()
+    CONTROL_SYMBOL = auto()
+    PLAIN_TEXT = auto()
+
+
+if __name__ == "__main__":
+    pass

src/rtfparse/parser.py

@@ -15,13 +15,6 @@
 
 class Rtf_Parser:
     probe_len = 42
-    @classmethod
-    def matchseek(cls, pattern: re.Pattern, file: io.BufferedReader) -> re.Match:
-        original_position = file.tell()
-        if (match := pattern.match(file.read(cls.probe_len))):
-            logger.debug(f"{match = }")
-            file.seek(original_position + match.span()[1])
-            return match
     @staticmethod
     def start_group(match: re.Match) -> None:
         logger.debug(f"Starting group")
@@ -67,7 +60,7 @@ def parse_file(self, file: io.BufferedReader) -> None:
         try:
             self.parsed = entities.Destination_Group(file)
         except Exception as err:
-            logger.error(f"Error: {err}")
+            logger.exception(err)
         finally:
             logger.debug(f"Parsing file {file.name} finished")
 

src/rtfparse/re_patterns.py

@@ -50,17 +50,18 @@ def no_capture(content: bytes) -> bytes:
 hdigit = named_regex_group("hdigit", group(_hdigits))
 minus = named_regex_group("minus", rb"-?")
 # int16 = minus + digit + rb"{1,5}"
-parameter = named_regex_group("param", minus + digit + rb"{1,10}")
+parameter = named_regex_group("parameter", minus + digit + rb"{1,10}")
 space = named_regex_group("space", rb" ")
 other = named_regex_group("other", group(rb"^" + _letters + _digits))
 
 
 ascii_letter_sequence = named_regex_group("control_name", ascii_letters)
-delimiter = named_regex_group("delimiter", rb"|".join((rb" ", parameter, other)))
+delimiter = named_regex_group("delimiter", rb"|".join((rb" ", parameter, other, rb"$")))
 symbol = named_regex_group("symbol", other)
 control_word_pattern = named_regex_group("control_word", rtf_backslash + ascii_letter_sequence + delimiter)
 pcdata_delimiter = no_capture(rb"|".join((rtf_brace_open, rtf_brace_close, control_word_pattern)))
 plain_text_pattern = named_regex_group("text", not_control_character + rb"+") + no_capture(control_character)
+probe_pattern = rb".."
 
 
 class Bytes_Regex():
@@ -72,6 +73,7 @@ def regex101(self) -> None:
         print(self.pattern_bytes.decode("ascii"))
 
 
+probe = Bytes_Regex(named_regex_group("probe", probe_pattern))
 meaningful_bs = Bytes_Regex(rtf_backslash)
 # control_word = Bytes_Regex(rtf_backslash + ascii_letter_sequence + delimiter)
 control_word = Bytes_Regex(control_word_pattern)

src/rtfparse/version.py

@@ -1,4 +1,4 @@
 #!/usr/bin/env python
 
 
-version = "0.2.1"
+version = "0.2.2"