furrow 0.1.0__tar.gz

furrow-0.1.0/LICENSE

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

furrow-0.1.0/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: furrow
+Version: 0.1.0
+Summary: A sleek state-machine parser to segment, extract, and format structured question chains from smashed-together text streams (OCR, handwriting text dumps, transcripts, and LLM outputs).
+Author-email: Elinah Moyo <growthsim2@gmail.com>
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Furrow 
+
+A lightweight, zero-dependency Python package to extract, segment, and format structured question chains from unformatted, smashed-together text blocks (OCR, handwriting text dumps, unformatted LLM outputs, or transcripts) without data loss.
+
+## Installation
+
+```bash
+pip install furrow
+```
+
+## Usage
+
+```python
+from furrow import Plow
+
+# 1. Initialize with your raw string
+messy_text = "was1 . i was a girl19.There i with her 500 grapes .7. Amazing!"
+engine = Plow(messy_text)
+
+# 2. Get questions as a list of dictionaries
+print(engine.collect())
+# [{'question_number': '19', 'text': '.There i with her 500 grapes .'}, ...]
+
+# 3. Get the text layout with newlines safely injected
+print(engine.render())
+# Output:
+# was
+# 1. i was a girl
+# 19.There i with her 500 grapes .
+# 7. Amazing!
+```
+
+## How It Works
+
+Furrow uses a single-pass state machine to parse and structure text layout:
+
+* **State Tracking**: Steps through the text character by character to map the exact indices where number blocks start and end.
+
+* **Noise Filtering**: Measures the distance between identified numbers and trailing periods. This allows it to separate inline data variables (like `500 grapes`) from actual question indices (like `19.`).
+* **Data Safety**: Injects newline characters (`\n`) via string slicing. This ensures 100% data preservation of non-question text (headers, footers, intro text).
+
+## API Reference
+
+* **`engine.collect()`**: Compiles and returns a list of question data nodes for databases or JSON storage.
+* **`engine.render()`**: Returns the full original text formatted with clean line breaks for UI display.
+
+*Note: You do not need to call the internal parsing loops manually. Calling either `.collect()` or `.render()` triggers `.run()` automatically if it has not executed yet.*

furrow-0.1.0/README.md

@@ -0,0 +1,47 @@
+# Furrow 
+
+A lightweight, zero-dependency Python package to extract, segment, and format structured question chains from unformatted, smashed-together text blocks (OCR, handwriting text dumps, unformatted LLM outputs, or transcripts) without data loss.
+
+## Installation
+
+```bash
+pip install furrow
+```
+
+## Usage
+
+```python
+from furrow import Plow
+
+# 1. Initialize with your raw string
+messy_text = "was1 . i was a girl19.There i with her 500 grapes .7. Amazing!"
+engine = Plow(messy_text)
+
+# 2. Get questions as a list of dictionaries
+print(engine.collect())
+# [{'question_number': '19', 'text': '.There i with her 500 grapes .'}, ...]
+
+# 3. Get the text layout with newlines safely injected
+print(engine.render())
+# Output:
+# was
+# 1. i was a girl
+# 19.There i with her 500 grapes .
+# 7. Amazing!
+```
+
+## How It Works
+
+Furrow uses a single-pass state machine to parse and structure text layout:
+
+* **State Tracking**: Steps through the text character by character to map the exact indices where number blocks start and end.
+
+* **Noise Filtering**: Measures the distance between identified numbers and trailing periods. This allows it to separate inline data variables (like `500 grapes`) from actual question indices (like `19.`).
+* **Data Safety**: Injects newline characters (`\n`) via string slicing. This ensures 100% data preservation of non-question text (headers, footers, intro text).
+
+## API Reference
+
+* **`engine.collect()`**: Compiles and returns a list of question data nodes for databases or JSON storage.
+* **`engine.render()`**: Returns the full original text formatted with clean line breaks for UI display.
+
+*Note: You do not need to call the internal parsing loops manually. Calling either `.collect()` or `.render()` triggers `.run()` automatically if it has not executed yet.*

furrow-0.1.0/pyproject.toml

@@ -0,0 +1,13 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "furrow"
+version = "0.1.0"
+description = "A sleek state-machine parser to segment, extract, and format structured question chains from smashed-together text streams (OCR, handwriting text dumps, transcripts, and LLM outputs)."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "Elinah Moyo", email = "growthsim2@gmail.com" }]
+dependencies = []

furrow-0.1.0/src/furrow/__init__.py

@@ -0,0 +1 @@
+from .engine import Plow

furrow-0.1.0/src/furrow/engine.py

@@ -0,0 +1,127 @@
+class Plow:
+    def __init__(self,input_data):
+        self.text = input_data
+        self.token = []
+        self._has_run = False
+
+    def run(self):
+        #oky now we search ch boundaried to find indexes
+        number = ""
+        number_start = None
+        number_end = None
+        period_pos = None
+
+        active_number = False
+
+        for i in range(len(self.text)):
+            current = self.text[i]
+
+            if current.isdigit():
+                if not active_number:
+                    number_start = i
+                    active_number = True
+
+                    number+= current
+            else:
+                if number != "":
+                    number_end = i-1
+
+                    current_number_data = {
+                        "number": number,
+                        "start": number_start,
+                        "end": number_end ,
+                        "period_position": None
+                         }
+                    self.token.append(current_number_data)
+
+                    number = ""
+                    number_start = None
+                    active_number = False
+
+            if current == ".":
+                period_pos = i
+
+                if self.token:
+                    last = self.token[-1]
+
+                    distance = period_pos-last["end"]
+
+                    if distance <=3:
+                        last["period_position"] = period_pos
+
+        self._has_run = True
+
+    def collect(self):
+        """Gathers the split text chunks into structured question nodes."""
+
+        if not self._has_run:
+            self.run()
+
+        for item in self.token:
+            if item["period_position"] is None:
+                item["is_question"] = False
+
+            else:
+                distance = item["period_position"]- item["end"]
+
+                if distance <=3:
+                    item["is_question"]= True
+
+                else:
+                    item["is_question"]= False
+
+        ## slice between
+
+        for i in range(len(self.token)):
+            if not self.token[i]["is_question"]:
+                continue
+
+            start = self.token[i]["period_position"]
+            end = len(self.text)
+
+            for j in range(i+1, len(self.token)):
+                if self.token[j]["is_question"]:
+                    end = self.token[j]["start"]
+                    break
+
+            self.token[i]["text"] = self.text[start:end]
+
+
+        questions = []
+
+        for item in self.token:
+            if item.get("is_question"):
+                questions.append({
+                    "question_number": item["number"],
+                    "text": item["text"]
+                })
+
+        return questions    
+
+
+    def render(self):
+
+        ### inject lines but not losing the non questions
+        if not self._has_run:
+            self.run()
+
+        if not self.token:
+            return self.text
+
+        valid_questions = [item for item in self.token if item.get("is_question")]
+
+        if not valid_questions:
+            return self.text
+
+        formatted_pieces = []
+        current_index = 0
+
+        for item in valid_questions:
+            start_pos = item["start"] 
+            formatted_pieces.append(self.text[current_index:start_pos])
+            formatted_pieces.append("\n")
+            current_index = start_pos
+
+        formatted_pieces.append(self.text[current_index:])
+        return "".join(formatted_pieces) 
+