markdown-flow 0.2.18__py3-none-any.whl → 0.2.26__py3-none-any.whl

markdown_flow/utils.py

@@ -19,6 +19,7 @@ from .constants import (
     COMPILED_PERCENT_VARIABLE_REGEX,
     COMPILED_PRESERVE_FENCE_REGEX,
     COMPILED_SINGLE_PIPE_SPLIT_REGEX,
+    CONTEXT_BUTTON_OPTIONS_TEMPLATE,
     CONTEXT_CONVERSATION_TEMPLATE,
     CONTEXT_QUESTION_MARKER,
     CONTEXT_QUESTION_TEMPLATE,
@@ -67,7 +68,7 @@ def is_preserved_content_block(content: str) -> bool:
     Check if content is completely preserved content block.
 
     Preserved blocks are entirely wrapped by markers with no external content.
-    Supports inline (===content===) and multiline (!=== ... !===) formats.
+    Supports inline (===content===), multiline (!=== ... !===) formats, and mixed formats.
 
     Args:
         content: Content to check
@@ -81,61 +82,50 @@ def is_preserved_content_block(content: str) -> bool:
 
     lines = content.split("\n")
 
-    # Check if all non-empty lines are inline format (!===content!===)
-    all_inline_format = True
-    has_any_content = False
-
-    for line in lines:
-        stripped_line = line.strip()
-        if stripped_line:  # Non-empty line
-            has_any_content = True
-            # Check if inline format: ===content===
-            match = COMPILED_INLINE_PRESERVE_REGEX.match(stripped_line)
-            if match:
-                # Ensure inner content exists and contains no ===
-                inner_content = match.group(1).strip()
-                if not inner_content or "===" in inner_content:
-                    all_inline_format = False
-                    break
-            else:
-                all_inline_format = False  # type: ignore[unreachable]
-                break
-
-    # If all lines are inline format, return directly
-    if has_any_content and all_inline_format:
-        return True
-
-    # Check multiline format using state machine
+    # Use state machine to validate that all non-empty content is preserved
     state = "OUTSIDE"  # States: OUTSIDE, INSIDE
-    has_content_outside = False  # Has external content
-    has_preserve_blocks = False  # Has preserve blocks
+    has_preserve_content = False
 
     for line in lines:
         stripped_line = line.strip()
 
+        # Check if this line is a fence marker (!===)
         if COMPILED_PRESERVE_FENCE_REGEX.match(stripped_line):
             if state == "OUTSIDE":
                 # Enter preserve block
                 state = "INSIDE"
-                has_preserve_blocks = True
+                has_preserve_content = True
             elif state == "INSIDE":
                 # Exit preserve block
                 state = "OUTSIDE"
-            # !=== lines don't count as external content
-        else:
-            # Non-!=== lines
-            if stripped_line:  # type: ignore[unreachable]  # Non-empty line
-                if state == "OUTSIDE":
-                    # External content found
-                    has_content_outside = True
-                    break
-                # Internal content doesn't affect judgment
+            # Fence markers themselves are valid preserved content
+            continue
+
+        # Non-fence lines
+        if stripped_line:  # Non-empty line
+            if state == "INSIDE":
+                # Inside fence block, this is valid preserved content
+                has_preserve_content = True
+            else:
+                # Outside fence block, check if it's inline format
+                match = COMPILED_INLINE_PRESERVE_REGEX.match(stripped_line)
+                if match:
+                    # Ensure inner content exists and contains no ===
+                    inner_content = match.group(1).strip()
+                    if inner_content and "===" not in inner_content:
+                        # Valid inline format
+                        has_preserve_content = True
+                    else:
+                        # Invalid inline format
+                        return False
+                else:
+                    # Not fence, not inline format -> external content
+                    return False
 
     # Judgment conditions:
-    # 1. Must have preserve blocks
-    # 2. Cannot have external content
-    # 3. Final state must be OUTSIDE (all blocks closed)
-    return has_preserve_blocks and not has_content_outside and state == "OUTSIDE"
+    # 1. Must have preserved content
+    # 2. Final state must be OUTSIDE (all fence blocks closed)
+    return has_preserve_content and state == "OUTSIDE"
 
 
 def extract_interaction_question(content: str) -> str | None:
@@ -479,6 +469,7 @@ def generate_smart_validation_template(
     target_variable: str,
     context: list[dict[str, Any]] | None = None,
     interaction_question: str | None = None,
+    buttons: list[dict[str, str]] | None = None,
 ) -> str:
     """
     Generate smart validation template based on context and question.
@@ -487,19 +478,28 @@ def generate_smart_validation_template(
         target_variable: Target variable name
         context: Context message list with role and content fields
         interaction_question: Question text from interaction block
+        buttons: Button options list with display and value fields
 
     Returns:
         Generated validation template
     """
     # Build context information
     context_info = ""
-    if interaction_question or context:
+    if interaction_question or context or buttons:
         context_parts = []
 
         # Add question information (most important, put first)
         if interaction_question:
             context_parts.append(CONTEXT_QUESTION_TEMPLATE.format(question=interaction_question))
 
+        # Add button options information
+        if buttons:
+            button_displays = [btn.get("display", "") for btn in buttons if btn.get("display")]
+            if button_displays:
+                button_options_str = ", ".join(button_displays)
+                button_info = CONTEXT_BUTTON_OPTIONS_TEMPLATE.format(button_options=button_options_str)
+                context_parts.append(button_info)
+
         # Add conversation context
         if context:
             for msg in context:

{markdown_flow-0.2.18.dist-info → markdown_flow-0.2.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markdown-flow
-Version: 0.2.18
+Version: 0.2.26
 Summary: An agent library designed to parse and process MarkdownFlow documents
 Project-URL: Homepage, https://github.com/ai-shifu/markdown-flow-agent-py
 Project-URL: Bug Tracker, https://github.com/ai-shifu/markdown-flow-agent-py/issues
@@ -73,7 +73,7 @@ llm_provider = YourLLMProvider(api_key="your-key")
 mf = MarkdownFlow(document, llm_provider=llm_provider)
 
 # Process with different modes
-result = await mf.process(
+result = mf.process(
     block_index=0,
     mode=ProcessMode.COMPLETE,
     variables={'name': 'Alice', 'level': 'Intermediate'}
@@ -84,7 +84,7 @@ result = await mf.process(
 
 ```python
 # Stream processing for real-time responses
-async for chunk in mf.process(
+for chunk in mf.process(
     block_index=0,
     mode=ProcessMode.STREAM,
     variables={'name': 'Bob'}
@@ -122,7 +122,7 @@ user_input = {
     'skills': ['Python', 'JavaScript', 'Go']  # Multi-selection
 }
 
-result = await mf.process(
+result = mf.process(
     block_index=1,  # Process skills interaction
     user_input=user_input,
     mode=ProcessMode.COMPLETE
@@ -148,13 +148,13 @@ class MarkdownFlow:
     def get_all_blocks(self) -> List[Block]: ...
     def extract_variables(self) -> Set[str]: ...
 
-    async def process(
+    def process(
         self,
         block_index: int,
         mode: ProcessMode = ProcessMode.COMPLETE,
         variables: Optional[Dict[str, str]] = None,
         user_input: Optional[str] = None
-    ) -> LLMResult: ...
+    ) -> LLMResult | Generator[LLMResult, None, None]: ...
 ```
 
 **Methods:**
@@ -184,24 +184,19 @@ Processing mode enumeration for different use cases.
 
 ```python
 class ProcessMode(Enum):
-    PROMPT_ONLY = "prompt_only"  # Generate prompts without LLM calls
-    COMPLETE = "complete"        # Non-streaming LLM processing
-    STREAM = "stream"           # Streaming LLM responses
+    COMPLETE = "complete"  # Non-streaming LLM processing
+    STREAM = "stream"      # Streaming LLM responses
 ```
 
 **Usage:**
 
 ```python
-# Generate prompt only
-prompt_result = await mf.process(0, ProcessMode.PROMPT_ONLY)
-print(prompt_result.content)  # Raw prompt text
-
 # Complete response
-complete_result = await mf.process(0, ProcessMode.COMPLETE)
+complete_result = mf.process(0, ProcessMode.COMPLETE)
 print(complete_result.content)  # Full LLM response
 
 # Streaming response
-async for chunk in mf.process(0, ProcessMode.STREAM):
+for chunk in mf.process(0, ProcessMode.STREAM):
     print(chunk.content, end='')
 ```
 
@@ -211,14 +206,14 @@ Abstract base class for implementing LLM providers.
 
 ```python
 from abc import ABC, abstractmethod
-from typing import AsyncGenerator
+from typing import Generator
 
 class LLMProvider(ABC):
     @abstractmethod
-    async def complete(self, prompt: str) -> LLMResult: ...
+    def complete(self, messages: list[dict[str, str]]) -> str: ...
 
     @abstractmethod
-    async def stream(self, prompt: str) -> AsyncGenerator[str, None]: ...
+    def stream(self, messages: list[dict[str, str]]) -> Generator[str, None, None]: ...
 ```
 
 **Custom Implementation:**
@@ -226,25 +221,24 @@ class LLMProvider(ABC):
 ```python
 class OpenAIProvider(LLMProvider):
     def __init__(self, api_key: str):
-        self.client = openai.AsyncOpenAI(api_key=api_key)
+        self.client = openai.OpenAI(api_key=api_key)
 
-    async def complete(self, prompt: str) -> LLMResult:
-        response = await self.client.completions.create(
+    def complete(self, messages: list[dict[str, str]]) -> str:
+        response = self.client.chat.completions.create(
             model="gpt-3.5-turbo",
-            prompt=prompt,
-            max_tokens=500
+            messages=messages
         )
-        return LLMResult(content=response.choices[0].text.strip())
+        return response.choices[0].message.content
 
-    async def stream(self, prompt: str):
-        stream = await self.client.completions.create(
+    def stream(self, messages: list[dict[str, str]]):
+        stream = self.client.chat.completions.create(
             model="gpt-3.5-turbo",
-            prompt=prompt,
+            messages=messages,
             stream=True
         )
-        async for chunk in stream:
-            if chunk.choices[0].text:
-                yield chunk.choices[0].text
+        for chunk in stream:
+            if chunk.choices[0].delta.content:
+                yield chunk.choices[0].delta.content
 ```
 
 ### Block Types
@@ -402,7 +396,7 @@ The new version introduces multi-select interaction support with improvements to
 user_input = "Python"
 
 # Process interaction
-result = await mf.process(
+result = mf.process(
     block_index=1,
     user_input=user_input,
     mode=ProcessMode.COMPLETE
@@ -419,7 +413,7 @@ user_input = {
 }
 
 # Process interaction
-result = await mf.process(
+result = mf.process(
     block_index=1,
     user_input=user_input,
     mode=ProcessMode.COMPLETE
@@ -462,10 +456,10 @@ class CustomAPIProvider(LLMProvider):
     def __init__(self, base_url: str, api_key: str):
         self.base_url = base_url
         self.api_key = api_key
-        self.client = httpx.AsyncClient()
+        self.client = httpx.Client()
 
-    async def complete(self, prompt: str) -> LLMResult:
-        response = await self.client.post(
+    def complete(self, prompt: str) -> LLMResult:
+        response = self.client.post(
             f"{self.base_url}/complete",
             headers={"Authorization": f"Bearer {self.api_key}"},
             json={"prompt": prompt, "max_tokens": 1000}
@@ -473,14 +467,14 @@ class CustomAPIProvider(LLMProvider):
         data = response.json()
         return LLMResult(content=data["text"])
 
-    async def stream(self, prompt: str):
-        async with self.client.stream(
+    def stream(self, prompt: str):
+        with self.client.stream(
             "POST",
             f"{self.base_url}/stream",
             headers={"Authorization": f"Bearer {self.api_key}"},
             json={"prompt": prompt}
         ) as response:
-            async for chunk in response.aiter_text():
+            for chunk in response.iter_text():
                 if chunk.strip():
                     yield chunk
 
@@ -492,7 +486,7 @@ mf = MarkdownFlow(document, llm_provider=provider)
 ### Multi-Block Document Processing
 
 ```python
-async def process_conversation():
+def process_conversation():
     conversation = """
 # AI Assistant
 
@@ -529,7 +523,7 @@ Would you like to start with the basics?
     for i, block in enumerate(blocks):
         if block.block_type == BlockType.CONTENT:
             print(f"\n--- Processing Block {i} ---")
-            result = await mf.process(
+            result = mf.process(
                 block_index=i,
                 mode=ProcessMode.COMPLETE,
                 variables=variables
@@ -544,9 +538,8 @@ Would you like to start with the basics?
 
 ```python
 from markdown_flow import MarkdownFlow, ProcessMode
-import asyncio
 
-async def stream_with_progress():
+def stream_with_progress():
     document = """
 Generate a comprehensive Python tutorial for {{user_name}}
 focusing on {{topic}} with practical examples.
@@ -560,12 +553,12 @@ Include code samples, explanations, and practice exercises.
     content = ""
     chunk_count = 0
 
-    async for chunk in mf.process(
+    for chunk in mf.process(
         block_index=0,
         mode=ProcessMode.STREAM,
         variables={
             'user_name': 'developer',
-            'topic': 'async programming'
+            'topic': 'synchronous programming'
         }
     ):
         content += chunk.content
@@ -599,13 +592,13 @@ class InteractiveDocumentBuilder:
         self.user_responses = {}
         self.current_block = 0
 
-    async def start_interaction(self):
+    def start_interaction(self):
         blocks = self.mf.get_all_blocks()
 
         for i, block in enumerate(blocks):
             if block.block_type == BlockType.CONTENT:
                 # Process content block with current variables
-                result = await self.mf.process(
+                result = self.mf.process(
                     block_index=i,
                     mode=ProcessMode.COMPLETE,
                     variables=self.user_responses
@@ -614,14 +607,14 @@ class InteractiveDocumentBuilder:
 
             elif block.block_type == BlockType.INTERACTION:
                 # Handle user interaction
-                response = await self.handle_interaction(block.content)
+                response = self.handle_interaction(block.content)
                 if response:
                     self.user_responses.update(response)
 
-    async def handle_interaction(self, interaction_content: str):
-        from markdown_flow.utils import InteractionParser
+    def handle_interaction(self, interaction_content: str):
+        from markdown_flow.parser import InteractionParser
 
-        interaction = InteractionParser.parse(interaction_content)
+        interaction = InteractionParser().parse(interaction_content)
         print(f"\n{interaction_content}")
 
         if interaction.name == "BUTTONS_ONLY":
@@ -635,7 +628,7 @@ class InteractiveDocumentBuilder:
                 return {interaction.variable: selected}
             except (ValueError, IndexError):
                 print("Invalid choice")
-                return await self.handle_interaction(interaction_content)
+                return self.handle_interaction(interaction_content)
 
         elif interaction.name == "TEXT_ONLY":
             response = input(f"{interaction.question}: ")
@@ -657,7 +650,7 @@ Great choice, {{name}}! {{subject}} is an excellent field to study.
 """
 
 builder = InteractiveDocumentBuilder(template, your_llm_provider)
-await builder.start_interaction()
+builder.start_interaction()
 ```
 
 ### Variable System Deep Dive

markdown_flow-0.2.26.dist-info/RECORD

@@ -0,0 +1,22 @@
+markdown_flow/__init__.py,sha256=wBE8Q9hyL-5sA6OWPuucQDbJAhKZ2XNlPl9xu-71v4k,2775
+markdown_flow/constants.py,sha256=zHXE8E7E4Axf75xZdCdjkLRPfzXDZ8s9D9PxizncrVA,9653
+markdown_flow/core.py,sha256=g2-KbKnD1kPywgNLe1BR81dgZBn1wYJuDxk2WSuhO9Y,42476
+markdown_flow/enums.py,sha256=Wr41zt0Ce5b3fyLtOTE2erEVp1n92g9OVaBF_BZg_l8,820
+markdown_flow/exceptions.py,sha256=9sUZ-Jd3CPLdSRqG8Pw7eMm7cv_S3VZM6jmjUU8OhIc,976
+markdown_flow/llm.py,sha256=MJRbXKj35AjLCAhWpFhS07s-m3YU2qO1HOFff05HG2I,2239
+markdown_flow/models.py,sha256=8uG4mmyTd53UPZNIoBLy03iwcPPrikuXLY4CKuR_oCM,2894
+markdown_flow/utils.py,sha256=TlQan3rNIcbIzgOa-kpphFKpw9IXblFKhIesac_lu3Y,28769
+markdown_flow/parser/__init__.py,sha256=_mua4f2utEvoB6aGk2ZYhbKCJQIEv4_Nnf7Zkyrx8aM,1035
+markdown_flow/parser/interaction.py,sha256=T4W7iO-iyNJnpM7SmvOH_DRlLuWSDcFyIrN2fH6cv7w,12653
+markdown_flow/parser/json_parser.py,sha256=78GhyyOjlg0l4UmKKNc4zrg-4pSHzrJEt7VKqbz3uyE,1305
+markdown_flow/parser/output.py,sha256=LgxvH6-RINM50p58miQtw_fHER1JEWDGucHk5-sZ-gk,8087
+markdown_flow/parser/validation.py,sha256=dkk8MopUdj1Yj6YIcRqRzcgXxUeM679hBAY2pnOC2DU,4417
+markdown_flow/parser/variable.py,sha256=eJLbVOyZT8uYM5eJNv5kHLqdRoNz5iNlxHhhi2oDW94,2986
+markdown_flow/providers/__init__.py,sha256=3dJWYdzb2W8nwOeQIJ-RWO79JOlHaAB9B0dXn1aP4eQ,318
+markdown_flow/providers/config.py,sha256=KJu7uChBcEUZAOjo1GsXB2Cq9DDIaltbiVCOyAw4BDQ,2120
+markdown_flow/providers/openai.py,sha256=NySSSCHloYmkKXwppk3eeBOTh9dVeHu9z9Ne3VaUU0A,12425
+markdown_flow-0.2.26.dist-info/licenses/LICENSE,sha256=qz3BziejhHPd1xa5eVtYEU5Qp6L2pn4otuj194uGxmc,1069
+markdown_flow-0.2.26.dist-info/METADATA,sha256=AxVoOBt1d32QUf-DHbUkjMHDqpYkTg0LqOfec1_9Ea0,20686
+markdown_flow-0.2.26.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+markdown_flow-0.2.26.dist-info/top_level.txt,sha256=DpigGvQuIt2L0TTLnDU5sylhiTGiZS7MmAMa2hi-AJs,14
+markdown_flow-0.2.26.dist-info/RECORD,,

markdown_flow-0.2.18.dist-info/RECORD

@@ -1,13 +0,0 @@
-markdown_flow/__init__.py,sha256=5TBCmuAdWvPqKJHpP5_R2qVOGf4FFkdaL6oUazBIY7E,2851
-markdown_flow/constants.py,sha256=HI061nHbGG9BeN-n9dMX17GlAT7fmYmsRZ6Cr8OSbXY,8809
-markdown_flow/core.py,sha256=Z0c5SssgPhqbDhbO2HZgHAaX6RpJEccb_r9RoGHVEjI,32565
-markdown_flow/enums.py,sha256=Wr41zt0Ce5b3fyLtOTE2erEVp1n92g9OVaBF_BZg_l8,820
-markdown_flow/exceptions.py,sha256=9sUZ-Jd3CPLdSRqG8Pw7eMm7cv_S3VZM6jmjUU8OhIc,976
-markdown_flow/llm.py,sha256=E2aq-OXwt4rS-alpf_iIJd2K38De_O3pzSZHuEaMeoE,2100
-markdown_flow/models.py,sha256=ENcvXMVXwpFN-RzbeVHhXTjBN0bbmRpJ96K-XS2rizI,2893
-markdown_flow/utils.py,sha256=rJOalKxCGuXYiAJzI3WfD-loLc-7BHQGpac934_uC4c,28504
-markdown_flow-0.2.18.dist-info/licenses/LICENSE,sha256=qz3BziejhHPd1xa5eVtYEU5Qp6L2pn4otuj194uGxmc,1069
-markdown_flow-0.2.18.dist-info/METADATA,sha256=-y3oljzO7iSaHHodM8c4id3SRMDxdP3zhSpihSUYW0I,21010
-markdown_flow-0.2.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-markdown_flow-0.2.18.dist-info/top_level.txt,sha256=DpigGvQuIt2L0TTLnDU5sylhiTGiZS7MmAMa2hi-AJs,14
-markdown_flow-0.2.18.dist-info/RECORD,,