notionary 0.2.16__py3-none-any.whl → 0.2.18__py3-none-any.whl

notionary/page/formatting/spacer_rules.py

@@ -1,483 +0,0 @@
-from __future__ import annotations
-
-from typing import Dict, Any, List, Optional, Tuple
-from abc import ABC, abstractmethod
-from dataclasses import dataclass
-from enum import Enum
-import re
-
-SPACER_MARKER = "---spacer---"
-
-
-class LineType(Enum):
-    """Enum for different line types"""
-
-    EMPTY = "empty"
-    HEADING = "heading"
-    DIVIDER = "divider"
-    CODE_BLOCK_MARKER = "code_block_marker"
-    SPACER_MARKER = SPACER_MARKER
-    PIPE_SYNTAX = "pipe_syntax"
-    TODO_ITEM = "todo_item"
-    REGULAR_CONTENT = "regular_content"
-
-
-@dataclass
-class LineContext:
-    """Context of a line for spacer rule application"""
-
-    line: str
-    line_number: int
-    line_type: LineType
-    is_empty: bool
-    content: str
-    in_code_block: bool
-    last_line_was_spacer: bool
-    last_non_empty_was_heading: bool
-    has_content_before: bool
-    processed_lines: List[str]
-
-
-@dataclass
-class SpacerDecision:
-    """Decision about inserting a spacer"""
-
-    should_add_spacer: bool
-    reason: str
-    rule_name: str
-
-
-@dataclass
-class ProcessingResult:
-    """Result of processing a single line"""
-
-    output_lines: List[str]
-    new_state: Dict[str, Any]
-    spacer_added: bool = False
-
-
-class SpacerRule(ABC):
-    """Abstract base class for spacer rules"""
-
-    @property
-    @abstractmethod
-    def name(self) -> str:
-        """Name of the rule for debugging"""
-        pass
-
-    @property
-    @abstractmethod
-    def description(self) -> str:
-        """Description of what the rule does"""
-        pass
-
-    @abstractmethod
-    def applies_to(self, context: LineContext) -> bool:
-        """Checks if this rule is relevant for the context"""
-        pass
-
-    @abstractmethod
-    def should_add_spacer(self, context: LineContext) -> SpacerDecision:
-        """Decides whether a spacer should be added"""
-        pass
-
-
-class HeadingSpacerRule(SpacerRule):
-    """Rule: Add spacer before headings (except after other headings)"""
-
-    @property
-    def name(self) -> str:
-        return "HeadingSpacerRule"
-
-    @property
-    def description(self) -> str:
-        return "Adds spacer before headings, except when the previous line was already a heading"
-
-    def applies_to(self, context: LineContext) -> bool:
-        return context.line_type == LineType.HEADING
-
-    def should_add_spacer(self, context: LineContext) -> SpacerDecision:
-        # Rule: Insert spacer before heading when:
-        # 1. There is content before this heading
-        # 2. The last line was not a spacer
-        # 3. The last non-empty line was not a heading
-
-        if not context.has_content_before:
-            return SpacerDecision(False, "No content before this heading", self.name)
-
-        if context.last_line_was_spacer:
-            return SpacerDecision(
-                False, "Previous line was already a spacer", self.name
-            )
-
-        if context.last_non_empty_was_heading:
-            return SpacerDecision(
-                False,
-                "Previous non-empty line was a heading (consecutive headings)",
-                self.name,
-            )
-
-        return SpacerDecision(
-            True,
-            "Adding spacer before heading to separate from previous content",
-            self.name,
-        )
-
-
-class DividerSpacerRule(SpacerRule):
-    """Rule: Add spacer before dividers"""
-
-    @property
-    def name(self) -> str:
-        return "DividerSpacerRule"
-
-    @property
-    def description(self) -> str:
-        return "Adds spacer before dividers (---) to create visual distance"
-
-    def applies_to(self, context: LineContext) -> bool:
-        return context.line_type == LineType.DIVIDER
-
-    def should_add_spacer(self, context: LineContext) -> SpacerDecision:
-        # Rule: Insert spacer before divider except when last line was already a spacer
-
-        if context.last_line_was_spacer:
-            return SpacerDecision(
-                False, "Previous line was already a spacer", self.name
-            )
-
-        return SpacerDecision(
-            True, "Adding spacer before divider for visual separation", self.name
-        )
-
-
-class ConsecutiveSpacerRule(SpacerRule):
-    """Rule: Prevent consecutive spacers"""
-
-    @property
-    def name(self) -> str:
-        return "ConsecutiveSpacerRule"
-
-    @property
-    def description(self) -> str:
-        return "Prevents consecutive spacer markers"
-
-    def applies_to(self, context: LineContext) -> bool:
-        return context.line_type == LineType.SPACER_MARKER
-
-    def should_add_spacer(self, context: LineContext) -> SpacerDecision:
-        # Rule: Never allow consecutive spacers
-
-        if context.last_line_was_spacer:
-            return SpacerDecision(False, "Preventing consecutive spacers", self.name)
-
-        return SpacerDecision(True, "Adding spacer marker", self.name)
-
-
-class CodeBlockSpacerRule(SpacerRule):
-    """Rule: No spacers inside code blocks"""
-
-    @property
-    def name(self) -> str:
-        return "CodeBlockSpacerRule"
-
-    @property
-    def description(self) -> str:
-        return "Prevents spacer processing inside code blocks"
-
-    def applies_to(self, context: LineContext) -> bool:
-        return context.in_code_block and context.line_type != LineType.CODE_BLOCK_MARKER
-
-    def should_add_spacer(self, context: LineContext) -> SpacerDecision:
-        return SpacerDecision(
-            False, "Inside code block - no spacer processing", self.name
-        )
-
-
-class StateBuilder:
-    """Builder for creating and updating state"""
-
-    def __init__(self, initial_state: Dict[str, Any]):
-        self._state = initial_state.copy()
-
-    def toggle_code_block(self) -> StateBuilder:
-        """Toggle the code block state"""
-        self._state["in_code_block"] = not self._state.get("in_code_block", False)
-        return self
-
-    def set_last_line_was_spacer(self, value: bool) -> StateBuilder:
-        """Set whether the last line was a spacer"""
-        self._state["last_line_was_spacer"] = value
-        return self
-
-    def update_content_tracking(
-        self, line_type: LineType, has_content: bool
-    ) -> StateBuilder:
-        """Update content tracking state"""
-        if has_content:
-            self._state["last_non_empty_was_heading"] = line_type == LineType.HEADING
-            self._state["has_content_before"] = True
-        return self
-
-    def build(self) -> Dict[str, Any]:
-        """Build the final state"""
-        return self._state
-
-
-class LineProcessor(ABC):
-    """Abstract processor for different line types"""
-
-    @abstractmethod
-    def can_process(self, line_type: LineType) -> bool:
-        """Check if this processor can handle the line type"""
-        pass
-
-    @abstractmethod
-    def process(self, context: LineContext, state: Dict[str, Any]) -> ProcessingResult:
-        """Process the line and return the result"""
-        pass
-
-
-class EmptyLineProcessor(LineProcessor):
-    """Processor for empty lines"""
-
-    def can_process(self, line_type: LineType) -> bool:
-        return line_type == LineType.EMPTY
-
-    def process(self, context: LineContext, state: Dict[str, Any]) -> ProcessingResult:
-        new_state = StateBuilder(state).set_last_line_was_spacer(False).build()
-
-        return ProcessingResult(output_lines=[context.line], new_state=new_state)
-
-
-class CodeBlockMarkerProcessor(LineProcessor):
-    """Processor for code block markers"""
-
-    def can_process(self, line_type: LineType) -> bool:
-        return line_type == LineType.CODE_BLOCK_MARKER
-
-    def process(self, context: LineContext, state: Dict[str, Any]) -> ProcessingResult:
-        new_state = (
-            StateBuilder(state)
-            .toggle_code_block()
-            .set_last_line_was_spacer(False)
-            .update_content_tracking(context.line_type, bool(context.content))
-            .build()
-        )
-
-        return ProcessingResult(output_lines=[context.line], new_state=new_state)
-
-
-class SpacerMarkerProcessor(LineProcessor):
-    """Processor for spacer marker lines"""
-
-    def __init__(self, spacer_marker: str, rules: List[SpacerRule]):
-        self.spacer_marker = spacer_marker
-        self.rules = rules
-
-    def can_process(self, line_type: LineType) -> bool:
-        return line_type == LineType.SPACER_MARKER
-
-    def process(self, context: LineContext, state: Dict[str, Any]) -> ProcessingResult:
-        # Apply spacer rules
-        spacer_decision = self._get_spacer_decision(context)
-
-        output_lines = []
-        spacer_added = False
-
-        if spacer_decision.should_add_spacer:
-            output_lines.append(context.line)
-            spacer_added = True
-
-        new_state = StateBuilder(state).set_last_line_was_spacer(spacer_added).build()
-
-        return ProcessingResult(
-            output_lines=output_lines, new_state=new_state, spacer_added=spacer_added
-        )
-
-    def _get_spacer_decision(self, context: LineContext) -> SpacerDecision:
-        """Get spacer decision from rules"""
-        for rule in self.rules:
-            if rule.applies_to(context):
-                return rule.should_add_spacer(context)
-
-        # Default: don't add spacer
-        return SpacerDecision(False, "No applicable rule found", "DefaultRule")
-
-
-class RegularContentProcessor(LineProcessor):
-    """Processor for regular content lines"""
-
-    def __init__(self, spacer_marker: str, rules: List[SpacerRule]):
-        self.spacer_marker = spacer_marker
-        self.rules = rules
-
-    def can_process(self, line_type: LineType) -> bool:
-        return line_type in [
-            LineType.HEADING,
-            LineType.DIVIDER,
-            LineType.TODO_ITEM,
-            LineType.REGULAR_CONTENT,
-            LineType.PIPE_SYNTAX,
-        ]
-
-    def process(self, context: LineContext, state: Dict[str, Any]) -> ProcessingResult:
-        output_lines = []
-        spacer_added = False
-
-        # Check if we should add a spacer before this line
-        spacer_decision = self._get_spacer_decision(context)
-
-        if spacer_decision.should_add_spacer:
-            output_lines.append(self.spacer_marker)
-            spacer_added = True
-
-        # Add the original line
-        output_lines.append(context.line)
-
-        # Build new state
-        new_state = (
-            StateBuilder(state)
-            .set_last_line_was_spacer(spacer_added)
-            .update_content_tracking(context.line_type, bool(context.content))
-            .build()
-        )
-
-        return ProcessingResult(
-            output_lines=output_lines, new_state=new_state, spacer_added=spacer_added
-        )
-
-    def _get_spacer_decision(self, context: LineContext) -> SpacerDecision:
-        """Get spacer decision from rules"""
-        for rule in self.rules:
-            if rule.applies_to(context):
-                return rule.should_add_spacer(context)
-
-        # Default: don't add spacer
-        return SpacerDecision(False, "No applicable rule found", "DefaultRule")
-
-
-class LineProcessorFactory:
-    """Factory for creating line processors"""
-
-    def __init__(self, spacer_marker: str, rules: List[SpacerRule]):
-        self.processors = [
-            EmptyLineProcessor(),
-            CodeBlockMarkerProcessor(),
-            SpacerMarkerProcessor(spacer_marker, rules),
-            RegularContentProcessor(spacer_marker, rules),
-        ]
-
-    def get_processor(self, line_type: LineType) -> Optional[LineProcessor]:
-        """Get appropriate processor for the line type"""
-        for processor in self.processors:
-            if processor.can_process(line_type):
-                return processor
-        return None
-
-
-class ContextFactory:
-    """Factory for creating line contexts"""
-
-    @staticmethod
-    def create_context(
-        line: str, line_number: int, line_type: LineType, state: Dict[str, Any]
-    ) -> LineContext:
-        """Create a LineContext from line and state"""
-        return LineContext(
-            line=line,
-            line_number=line_number,
-            line_type=line_type,
-            is_empty=not line.strip(),
-            content=line.strip(),
-            in_code_block=state.get("in_code_block", False),
-            last_line_was_spacer=state.get("last_line_was_spacer", False),
-            last_non_empty_was_heading=state.get("last_non_empty_was_heading", False),
-            has_content_before=state.get("has_content_before", False),
-            processed_lines=state.get("processed_lines", []),
-        )
-
-
-class SpacerRuleEngine:
-    """Refactored engine with reduced complexity"""
-
-    def __init__(self, rules: Optional[List[SpacerRule]] = None):
-        self.rules = rules or self._get_default_rules()
-        self.SPACER_MARKER = SPACER_MARKER
-
-        # Initialize factories
-        self.processor_factory = LineProcessorFactory(
-            self.SPACER_MARKER,
-            self.rules,
-        )
-        self.context_factory = ContextFactory()
-
-    def process_line(
-        self, line: str, line_number: int, context_state: Dict[str, Any]
-    ) -> Tuple[List[str], Dict[str, Any]]:
-        """
-        Processes a line and returns the resulting lines + new state
-
-        Returns:
-            Tuple[List[str], Dict[str, Any]]: (processed_lines, new_state)
-        """
-        # Step 1: Determine line type (single responsibility)
-        line_type = self._determine_line_type(
-            line, context_state.get("in_code_block", False)
-        )
-
-        # Step 2: Create context (factory pattern)
-        context = self.context_factory.create_context(
-            line, line_number, line_type, context_state
-        )
-
-        # Step 3: Get appropriate processor (strategy pattern)
-        processor = self.processor_factory.get_processor(line_type)
-        if not processor:
-            # Fallback to original line
-            return [line], context_state.copy()
-
-        # Step 4: Process line (delegation)
-        result = processor.process(context, context_state)
-
-        return result.output_lines, result.new_state
-
-    def _get_default_rules(self) -> List[SpacerRule]:
-        """Default rule set"""
-        return [
-            CodeBlockSpacerRule(),  # Highest priority - code blocks
-            ConsecutiveSpacerRule(),  # Prevent duplicate spacers
-            HeadingSpacerRule(),  # Spacer before headings
-            DividerSpacerRule(),  # Spacer before dividers
-        ]
-
-    def _determine_line_type(self, line: str, in_code_block: bool) -> LineType:
-        """Determines the type of a line"""
-        content = line.strip()
-
-        # Guard clauses for early returns
-        if not content:
-            return LineType.EMPTY
-
-        if content.startswith("```"):
-            return LineType.CODE_BLOCK_MARKER
-
-        if in_code_block:
-            return LineType.REGULAR_CONTENT
-
-        if content == self.SPACER_MARKER:
-            return LineType.SPACER_MARKER
-
-        # Pattern matching with early returns
-        patterns = [
-            (r"^\|\s?(.*)$", LineType.PIPE_SYNTAX),
-            (r"^(#{1,6})\s+(.+)$", LineType.HEADING),
-            (r"^-{3,}$", LineType.DIVIDER),
-            (r"^\s*[-*+]\s+\[[ x]\]", LineType.TODO_ITEM),
-        ]
-
-        for pattern, line_type in patterns:
-            if re.match(pattern, content if pattern.startswith("^#{") else line):
-                return line_type
-
-        return LineType.REGULAR_CONTENT

notionary/util/fuzzy_matcher.py

@@ -1,82 +0,0 @@
-from __future__ import annotations
-import difflib
-from typing import List, Any, TypeVar, Callable, Optional
-from dataclasses import dataclass
-
-T = TypeVar("T")
-
-
-@dataclass
-class MatchResult:
-    """Result of a fuzzy match operation."""
-
-    item: Any
-    similarity: float
-    matched_text: str
-
-
-class FuzzyMatcher:
-    """Utility class for fuzzy string matching operations."""
-
-    @staticmethod
-    def calculate_similarity(query: str, target: str) -> float:
-        """Calculate similarity between two strings using difflib."""
-        return difflib.SequenceMatcher(
-            None, query.lower().strip(), target.lower().strip()
-        ).ratio()
-
-    @classmethod
-    def find_best_matches(
-        cls,
-        query: str,
-        items: List[T],
-        text_extractor: Callable[[T], str],
-        min_similarity: float = 0.0,
-        limit: Optional[int] = None,
-    ) -> List[MatchResult[T]]:
-        """
-        Find best fuzzy matches from a list of items.
-
-        Args:
-            query: The search query
-            items: List of items to search through
-            text_extractor: Function to extract text from each item
-            min_similarity: Minimum similarity threshold (0.0 to 1.0)
-            limit: Maximum number of results to return
-
-        Returns:
-            List of MatchResult objects sorted by similarity (highest first)
-        """
-        results = []
-
-        for item in items:
-            text = text_extractor(item)
-            similarity = cls.calculate_similarity(query, text)
-
-            if similarity >= min_similarity:
-                results.append(
-                    MatchResult(item=item, similarity=similarity, matched_text=text)
-                )
-
-        # Sort by similarity (highest first)
-        results.sort(key=lambda x: x.similarity, reverse=True)
-
-        # Apply limit if specified
-        if limit:
-            results = results[:limit]
-
-        return results
-
-    @classmethod
-    def find_best_match(
-        cls,
-        query: str,
-        items: List[T],
-        text_extractor: Callable[[T], str],
-        min_similarity: float = 0.0,
-    ) -> Optional[MatchResult[T]]:
-        """Find the single best fuzzy match."""
-        matches = cls.find_best_matches(
-            query, items, text_extractor, min_similarity, limit=1
-        )
-        return matches[0] if matches else None

notionary-0.2.16.dist-info/RECORD

@@ -1,71 +0,0 @@
-notionary/__init__.py,sha256=4eO6Jx57VRR_Ejo9w7IJeET8SZOvxFl_1lOB39o39No,250
-notionary/base_notion_client.py,sha256=hJnN8CZe7CUunMBljGdKKN44xMlJQAIAhQyT-3WEIK8,6722
-notionary/blocks/__init__.py,sha256=MFBxK3zZ28tV_u8XT20Q6HY39KENCfJDfDflLTYVt4E,2019
-notionary/blocks/audio_element.py,sha256=rQbWz8akbobci8CFvnFuuHoDNJCG7mcuSXdB8hHjqLU,5355
-notionary/blocks/bookmark_element.py,sha256=gW6uKCkuWFpHEzq-g1CbvKvma6hyTMUH2XMczI0U-5M,8080
-notionary/blocks/bulleted_list_element.py,sha256=Uv_ohhF0MTwQ29w_RUX91NFuz57Dtr4vQpV8seRAgy0,2599
-notionary/blocks/callout_element.py,sha256=Cya-1HIRBiCiyMgQq6PqXU4_iGj2O3qAPirhtC2QrTY,4446
-notionary/blocks/code_block_element.py,sha256=w0AN5m1qEFEEMDZ5dicCUhh4RwQpjByzDW3PuHgvgt0,7466
-notionary/blocks/column_element.py,sha256=qzbrTcWWOhGts2fAWHTwQUW8Ca6yoQEMZol9ZxUDCCI,12669
-notionary/blocks/divider_element.py,sha256=eCX2OupttnjGUaIaF59RhULKqh8R6d8KPnpctMMaXJs,2267
-notionary/blocks/embed_element.py,sha256=MFHh3ZFNntvaJ1NiEs0bzpbmJTRm0Axqdtf5oputbi0,4516
-notionary/blocks/heading_element.py,sha256=aALMpclbPTvKfJOICJdgP0y-y7w5jhv7rUQl04TQpeg,3051
-notionary/blocks/image_element.py,sha256=SEZ31_uDBRy6_lpn8E_GMX5uzI7-c-pJB9idUGZiTrE,4695
-notionary/blocks/mention_element.py,sha256=G04nnc54YzUP8qu_aAx4-z56fspVrqCc4IHqSw4C5fk,8122
-notionary/blocks/notion_block_client.py,sha256=mLkJ9mbfTZB7oml2hjXxxmr9XUCfM3u_8xjwKDi77oA,911
-notionary/blocks/notion_block_element.py,sha256=r27KYICQvdmOg3AyzHE6ouWjX8WuJmX1bERCgkBdaGE,1263
-notionary/blocks/numbered_list_element.py,sha256=BL_mui9vJ0usOFbRrNZRP_IY8QLG3vGFRYiPPsq_OJw,2596
-notionary/blocks/paragraph_element.py,sha256=-zCwJOanOVjv07DRArD13yRYaxfL8sCob6oN3PKvzNc,3188
-notionary/blocks/prompts/element_prompt_builder.py,sha256=rYMKPmpEFyk26JFZlwcTzMHATpvHnn4Dn284vewFog0,2953
-notionary/blocks/prompts/element_prompt_content.py,sha256=ItnhGwKsHGnnY9E_LGgZZeTCT9ZfnkJY8xad4wFViWk,1567
-notionary/blocks/qoute_element.py,sha256=pkeT6N7PZrepIod8WLrY1DMe2DW6fM98Y4zXiiACenw,6059
-notionary/blocks/registry/block_registry.py,sha256=fEKe03bJYkzy19cbkeO2d30nvSThG6TWHXHxf_-aUbg,4961
-notionary/blocks/registry/block_registry_builder.py,sha256=FA_0WOajaeVaqdphNh8EyN0p_7ItzFqEufYa6YVBLeY,8731
-notionary/blocks/table_element.py,sha256=DzXbSVm3KwTfnLF2cp765gj-VC50zWvj_0RU_WcQDJw,11184
-notionary/blocks/text_inline_formatter.py,sha256=aKnaR1LvmbBkRdJVId8xtMkrbw1xaw6e4ZLUH97XLfU,8583
-notionary/blocks/todo_element.py,sha256=6ndhgGJNiy7eb-Ll--Va7zEqQySxFAFYpzY4PWJbGUQ,4059
-notionary/blocks/toggle_element.py,sha256=2gofKL4ndVkRxkuH-iYVx0YFUc649gpQQbZtwh2BpY8,11017
-notionary/blocks/toggleable_heading_element.py,sha256=fkXvKtgCg6PuHqrHq7LupmqzpasJ1IyVf2RBLYTiVIo,9893
-notionary/blocks/video_element.py,sha256=C19XxFRyAUEbhhC9xvhAAGN8YBYP6ON1vm_x7b_gUrY,5664
-notionary/database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-notionary/database/client.py,sha256=ZcfydeYlpgGJt6wV1ib33KeXUiL-cGNJ1qraQZ4RVRc,4775
-notionary/database/database_exceptions.py,sha256=jwFdxoIQHLO3mO3p5t890--1FjbTX60fNyqBAe-sszo,452
-notionary/database/factory.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-notionary/database/filter_builder.py,sha256=4EJnWUF73l5oi-HnvMu-mI1OncLzEs2o2mr_xG75quk,6315
-notionary/database/models/page_result.py,sha256=Vmm5_oYpYAkIIJVoTd1ZZGloeC3cmFLMYP255mAmtaw,233
-notionary/database/notion_database.py,sha256=jA3_x-pMJdcI6-ZDiSrx43ywaFaw0MLRW8wYb7DOlvQ,15755
-notionary/database/notion_database_provider.py,sha256=GVfS8fgf5RhX15y8gpvRjBkQbv--8WFgKBkI_Z5LRaU,9009
-notionary/elements/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-notionary/models/notion_block_response.py,sha256=gzL4C6K9QPcaMS6NbAZaRceSEnMbNwYBVVzxysza5VU,6002
-notionary/models/notion_database_response.py,sha256=3kvADIP1dSxgITSK4n8Ex3QpF8n_Lxnu_IXbPVGcq4o,7648
-notionary/models/notion_page_response.py,sha256=7ZwDYhlyK-avix_joQpGuNQZopjlQFI8jS3nvNNumoc,1544
-notionary/models/search_response.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-notionary/page/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-notionary/page/client.py,sha256=XQ72lOEwn-gO8fmhKSKHqSHs3hRmoKH0TkJ3TtblcAg,4030
-notionary/page/content/notion_page_content_chunker.py,sha256=kWJnV9GLU5YLgSVPKOjwMBbG_CMAmVRkuDtwJYb_UAA,3316
-notionary/page/content/page_content_retriever.py,sha256=iNazSf0uv_gi0J816-SZn4Lw4qbAxRHG90k9Jy_qw2Q,1587
-notionary/page/content/page_content_writer.py,sha256=VVvK-Z8NvyIhi7Crcm9mZQuuD_L72NsqSQg9gf33Zwk,7369
-notionary/page/formatting/markdown_to_notion_converter.py,sha256=9RyGON8VrJv6XifdQdOt5zKgKT3irc974zcbGDBhmLY,17328
-notionary/page/formatting/spacer_rules.py,sha256=j2RHvdXT3HxXPVBEuCtulyy9cPxsEcOmj71pJqV-D3M,15677
-notionary/page/markdown_syntax_prompt_generator.py,sha256=uHCPNV9aQi3GzLVimyUKwza29hfxu6DTMVIa_QevJbk,4987
-notionary/page/notion_page.py,sha256=PAwixEuzn5mnkIU4AtOKHiaaG98fmVqFhPe4Mjnb9bA,19110
-notionary/page/notion_to_markdown_converter.py,sha256=_MJWWwsBvgZ3a8tLZ23ZCIA_G9Qfvt2JG1FqVTlRxHs,6308
-notionary/page/properites/property_value_extractor.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-notionary/page/property_formatter.py,sha256=_978ViH83gfcr-XtDscWTfyBI2srGW2hzC-gzgp5NR8,3788
-notionary/page/search_filter_builder.py,sha256=wZpW_KHmPXql3sNIyQd9EzZ2-ERy2i0vYNdoLkoBUfc,4597
-notionary/page/utils.py,sha256=2nfBrWeczBdPH13R3q8dKP4OY4MwEdfKbcs2UJ9kg1o,2041
-notionary/telemetry/__init__.py,sha256=Y7KyXeN4PiA6GtzV3NnwoH4hJnPwdjikWP22ckPYuHM,511
-notionary/telemetry/service.py,sha256=DD7RbkSN0HWRK2YpOJTgFD7PeXGhSe9KrLkhiVIaC7Y,4763
-notionary/telemetry/views.py,sha256=BXVa25h0A4leGaz5U9F-T5ebShkojD-DvYElWkrP6U4,1762
-notionary/util/__init__.py,sha256=JAOxIchioEx4h_KcRs8mqgBjPveoNmzqkNzdQZnokNk,438
-notionary/util/factory_decorator.py,sha256=3SD63EPxXMmKQ8iF7sF88xUFMG8dy14L2DJZ7XdcYm4,1110
-notionary/util/fuzzy_matcher.py,sha256=RYR86hMTp8lrWl3PeOa3RpDpzh04HJ30qrIlrq6_qDo,2442
-notionary/util/logging_mixin.py,sha256=d5sRSmUtgQeuckdNBkO025IXPGe4oOb-7ueVAIP8amU,1846
-notionary/util/page_id_utils.py,sha256=AA00kRO-g3Cc50tf_XW_tb5RBuPKLuBxRa0D8LYhLXg,736
-notionary/util/singleton_decorator.py,sha256=CKAvykndwPRZsA3n3MAY_XdCR59MBjjKP0vtm2BcvF0,428
-notionary/util/singleton_metaclass.py,sha256=uNeHiqS6TwhljvG1RE4NflIp2HyMuMmrCg2xI-vxmHE,809
-notionary/workspace.py,sha256=kW9fbVUSECivlvABBwnks2nALfk09V6g6Oc2Eq_pK5U,2511
-notionary-0.2.16.dist-info/LICENSE,sha256=zOm3cRT1qD49eg7vgw95MI79rpUAZa1kRBFwL2FkAr8,1120
-notionary-0.2.16.dist-info/METADATA,sha256=qy_xKJWjzGlY0zZcJ4T2hZtFgjMmgZhRSEqaQc8Hlqo,6824
-notionary-0.2.16.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-notionary-0.2.16.dist-info/RECORD,,