notionary 0.2.13__py3-none-any.whl → 0.2.14__py3-none-any.whl

notionary/page/notion_to_markdown_converter.py

@@ -1,9 +1,6 @@
 from typing import Dict, Any, List, Optional
 
-from notionary.elements.registry.block_registry import BlockRegistry
-from notionary.elements.registry.block_registry_builder import (
-    BlockRegistryBuilder,
-)
+from notionary.blocks import BlockRegistry, BlockRegistryBuilder
 
 
 class NotionToMarkdownConverter:

notionary/page/properites/property_value_extractor.py

@@ -1,64 +0,0 @@
-import asyncio
-from typing import Any, Awaitable, Callable
-
-from notionary.util import LoggingMixin
-
-
-class PropertyValueExtractor(LoggingMixin):
-
-    async def extract(
-        self,
-        property_name: str,
-        prop_data: dict,
-        relation_resolver: Callable[[str], Awaitable[Any]],
-    ) -> Any:
-        prop_type = prop_data.get("type")
-        if not prop_type:
-            return None
-
-        handlers: dict[str, Callable[[], Awaitable[Any] | Any]] = {
-            "title": lambda: "".join(
-                t.get("plain_text", "") for t in prop_data.get("title", [])
-            ),
-            "rich_text": lambda: "".join(
-                t.get("plain_text", "") for t in prop_data.get("rich_text", [])
-            ),
-            "number": lambda: prop_data.get("number"),
-            "select": lambda: (
-                prop_data.get("select", {}).get("name")
-                if prop_data.get("select")
-                else None
-            ),
-            "multi_select": lambda: [
-                o.get("name") for o in prop_data.get("multi_select", [])
-            ],
-            "status": lambda: (
-                prop_data.get("status", {}).get("name")
-                if prop_data.get("status")
-                else None
-            ),
-            "date": lambda: prop_data.get("date"),
-            "checkbox": lambda: prop_data.get("checkbox"),
-            "url": lambda: prop_data.get("url"),
-            "email": lambda: prop_data.get("email"),
-            "phone_number": lambda: prop_data.get("phone_number"),
-            "relation": lambda: relation_resolver(property_name),
-            "people": lambda: [p.get("id") for p in prop_data.get("people", [])],
-            "files": lambda: [
-                (
-                    f.get("external", {}).get("url")
-                    if f.get("type") == "external"
-                    else f.get("name")
-                )
-                for f in prop_data.get("files", [])
-            ],
-        }
-
-        handler = handlers.get(prop_type)
-        if handler is None:
-            if self.logger:
-                self.logger.warning(f"Unsupported property type: {prop_type}")
-            return None
-
-        result = handler()
-        return await result if asyncio.iscoroutine(result) else result

notionary/page/{properites/property_formatter.py → property_formatter.py}

@@ -3,6 +3,7 @@ from typing import Any, Dict, Optional
 from notionary.util import LoggingMixin
 
 
+# TODO: mit dem Utils.py hier im order zusammenfassen
 class NotionPropertyFormatter(LoggingMixin):
     """Class for formatting Notion properties based on their type."""
 
@@ -76,7 +77,9 @@ class NotionPropertyFormatter(LoggingMixin):
             return {"relation": [{"id": item} for item in value]}
         return {"relation": [{"id": str(value)}]}
 
-    def format_value(self, property_type: str, value: Any) -> Optional[Dict[str, Any]]:
+    def format_value(
+        self, property_name, property_type: str, value: Any
+    ) -> Optional[Dict[str, Any]]:
         """
         Formats a value according to the given Notion property type.
 
@@ -89,8 +92,8 @@ class NotionPropertyFormatter(LoggingMixin):
         """
         formatter = self._formatters.get(property_type)
         if not formatter:
-            if self.logger:
-                self.logger.warning("Unknown property type: %s", property_type)
+            self.logger.warning("Unknown property type: %s", property_type)
             return None
 
-        return formatter(value)
+        formatted_property = formatter(value)
+        return {"properties": {property_name: formatted_property}}

notionary/page/search_filter_builder.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+from typing import Any, Dict, Optional, Literal
+from dataclasses import dataclass
+
+
+@dataclass
+class SearchConfig:
+    """Konfiguration für Notion Search API Filter."""
+
+    query: Optional[str] = None
+    object_type: Optional[Literal["page", "database"]] = None
+    sort_direction: Literal["ascending", "descending"] = "descending"
+    sort_timestamp: Literal["last_edited_time", "created_time"] = "last_edited_time"
+    page_size: int = 100
+    start_cursor: Optional[str] = None
+
+    def to_search_dict(self) -> Dict[str, Any]:
+        """Konvertiert zu einem Notion Search API Dictionary."""
+        search_dict = {}
+
+        if self.query:
+            search_dict["query"] = self.query
+
+        if self.object_type:
+            search_dict["filter"] = {"property": "object", "value": self.object_type}
+
+        search_dict["sort"] = {
+            "direction": self.sort_direction,
+            "timestamp": self.sort_timestamp,
+        }
+
+        search_dict["page_size"] = min(self.page_size, 100)
+
+        if self.start_cursor:
+            search_dict["start_cursor"] = self.start_cursor
+
+        return search_dict
+
+
+class SearchFilterBuilder:
+    """
+    Builder class for creating Notion Search API filters with comprehensive options.
+    """
+
+    def __init__(self, config: SearchConfig = None):
+        self.config = config or SearchConfig()
+
+    def with_query(self, query: str) -> SearchFilterBuilder:
+        """Set the search query string."""
+        self.config.query = query
+        return self
+
+    def with_pages_only(self) -> SearchFilterBuilder:
+        """Filter to only return pages."""
+        self.config.object_type = "page"
+        return self
+
+    def with_databases_only(self) -> SearchFilterBuilder:
+        """Filter to only return databases."""
+        self.config.object_type = "database"
+        return self
+
+    def with_sort_direction(
+        self, direction: Literal["ascending", "descending"]
+    ) -> SearchFilterBuilder:
+        """Set sort direction (ascending or descending)."""
+        self.config.sort_direction = direction
+        return self
+
+    def with_sort_ascending(self) -> SearchFilterBuilder:
+        """Sort results in ascending order."""
+        return self.with_sort_direction("ascending")
+
+    def with_sort_descending(self) -> SearchFilterBuilder:
+        """Sort results in descending order."""
+        return self.with_sort_direction("descending")
+
+    def with_sort_timestamp(
+        self, timestamp: Literal["last_edited_time", "created_time"]
+    ) -> SearchFilterBuilder:
+        """Set the timestamp field to sort by."""
+        self.config.sort_timestamp = timestamp
+        return self
+
+    def with_sort_by_created_time(self) -> SearchFilterBuilder:
+        """Sort by creation time."""
+        return self.with_sort_timestamp("created_time")
+
+    def with_sort_by_last_edited(self) -> SearchFilterBuilder:
+        """Sort by last edited time."""
+        return self.with_sort_timestamp("last_edited_time")
+
+    def with_page_size(self, size: int) -> SearchFilterBuilder:
+        """Set page size for pagination (max 100)."""
+        self.config.page_size = min(size, 100)
+        return self
+
+    def with_cursor(self, cursor: Optional[str]) -> SearchFilterBuilder:
+        """Set start cursor for pagination."""
+        self.config.start_cursor = cursor
+        return self
+
+    def without_cursor(self) -> SearchFilterBuilder:
+        """Remove start cursor (for first page)."""
+        self.config.start_cursor = None
+        return self
+
+    def build(self) -> Dict[str, Any]:
+        """Build the final search filter dictionary. Builder bleibt wiederverwendbar!"""
+        return self.config.to_search_dict()
+
+    def get_config(self) -> SearchConfig:
+        """Get the underlying SearchConfig."""
+        return self.config
+
+    def copy(self) -> SearchFilterBuilder:
+        """Create a copy of the builder."""
+        new_config = SearchConfig(
+            query=self.config.query,
+            object_type=self.config.object_type,
+            sort_direction=self.config.sort_direction,
+            sort_timestamp=self.config.sort_timestamp,
+            page_size=self.config.page_size,
+            start_cursor=self.config.start_cursor,
+        )
+        return SearchFilterBuilder(new_config)
+
+    def reset(self) -> SearchFilterBuilder:
+        """Reset all configurations to defaults."""
+        self.config = SearchConfig()
+        return self

notionary/page/utils.py

@@ -0,0 +1,60 @@
+from typing import Any
+
+
+def extract_property_value(prop_data: dict) -> Any:
+    """
+    Extract the value of a Notion property from its data dict.
+    Supports all common Notion property types.
+
+    Args:
+        prop_data: The property data dictionary from Notion API
+
+    Returns:
+        The extracted value based on property type
+    """
+    prop_type = prop_data.get("type")
+    if not prop_type:
+        return None
+
+    # Handler dictionary for different property types
+    handlers = {
+        "title": lambda: "".join(
+            t.get("plain_text", "") for t in prop_data.get("title", [])
+        ),
+        "rich_text": lambda: "".join(
+            t.get("plain_text", "") for t in prop_data.get("rich_text", [])
+        ),
+        "number": lambda: prop_data.get("number"),
+        "select": lambda: (
+            prop_data.get("select", {}).get("name") if prop_data.get("select") else None
+        ),
+        "multi_select": lambda: [
+            o.get("name") for o in prop_data.get("multi_select", [])
+        ],
+        "status": lambda: (
+            prop_data.get("status", {}).get("name") if prop_data.get("status") else None
+        ),
+        "date": lambda: prop_data.get("date"),
+        "checkbox": lambda: prop_data.get("checkbox"),
+        "url": lambda: prop_data.get("url"),
+        "email": lambda: prop_data.get("email"),
+        "phone_number": lambda: prop_data.get("phone_number"),
+        "people": lambda: [p.get("id") for p in prop_data.get("people", [])],
+        "files": lambda: [
+            (
+                f.get("external", {}).get("url")
+                if f.get("type") == "external"
+                else f.get("name")
+            )
+            for f in prop_data.get("files", [])
+        ],
+    }
+
+    handler = handlers.get(prop_type)
+    if handler is None:
+        return prop_data  # Return raw data if type unknown
+
+    try:
+        return handler()
+    except Exception:
+        return None  # Return None if extraction fails

notionary/util/__init__.py

@@ -1,5 +1,14 @@
 from .logging_mixin import LoggingMixin
-from .singleton import singleton
-from .page_id_utils import format_uuid, extract_and_validate_page_id
+from .singleton_decorator import singleton
+from .page_id_utils import format_uuid
+from .fuzzy_matcher import FuzzyMatcher
+from .factory_decorator import factory_only
 
-__all__ = ["LoggingMixin", "singleton", "format_uuid", "extract_and_validate_page_id"]
+__all__ = [
+    "LoggingMixin",
+    "singleton_decorator",
+    "format_uuid",
+    "FuzzyMatcher",
+    "factory_only",
+    "singleton",
+]

notionary/util/factory_decorator.py

@@ -0,0 +1,33 @@
+import functools
+import inspect
+
+
+def factory_only(*allowed_factories):
+    """
+    Decorator that ensures __init__ is only called from allowed factory methods.
+
+    Args:
+        *allowed_factories: Names of allowed factory methods (e.g. 'from_database_id')
+    """
+
+    def decorator(init_method):
+        @functools.wraps(init_method)
+        def wrapper(self, *args, **kwargs):
+            frame = inspect.currentframe()
+            try:
+                caller_frame = frame.f_back.f_back
+                if not caller_frame:
+                    return init_method(self, *args, **kwargs)
+                caller_name = caller_frame.f_code.co_name
+                if caller_name in allowed_factories or caller_name.startswith("_"):
+                    return init_method(self, *args, **kwargs)
+                else:
+                    raise RuntimeError(
+                        f"Direct instantiation not allowed! Use one of: {', '.join(allowed_factories)}"
+                    )
+            finally:
+                del frame
+
+        return wrapper
+
+    return decorator

notionary/util/fuzzy_matcher.py

@@ -0,0 +1,82 @@
+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/util/page_id_utils.py

@@ -25,24 +25,3 @@ def format_uuid(value: str) -> Optional[str]:
     if is_valid_uuid(value):
         return value
     return extract_uuid(value)
-
-
-def extract_and_validate_page_id(
-    page_id: Optional[str] = None, url: Optional[str] = None
-) -> str:
-    if not page_id and not url:
-        raise ValueError("Either page_id or url must be provided")
-
-    candidate = page_id or url
-
-    if is_valid_uuid(candidate):
-        return candidate
-
-    extracted_id = extract_uuid(candidate)
-    if not extracted_id:
-        raise ValueError(f"Could not extract a valid UUID from: {candidate}")
-
-    formatted = format_uuid(extracted_id)
-    if not formatted or not is_valid_uuid(formatted):
-        raise ValueError(f"Invalid UUID format: {formatted}")
-    return formatted

notionary/util/singleton_metaclass.py

@@ -0,0 +1,22 @@
+from typing import TypeVar, Dict, Any, Type, cast
+
+T = TypeVar("T")
+
+
+class SingletonMetaClass(type):
+    """
+    A metaclass that ensures a class has only a single instance.
+    Provides a get_instance() method with proper type hinting.
+    """
+
+    _instances: Dict[Type, Any] = {}
+
+    def __call__(cls: Type[T], *args: Any, **kwargs: Any) -> T:
+        """Called when the class is instantiated (e.g., MyClass())."""
+        if cls not in cls._instances:
+            cls._instances[cls] = super().__call__(*args, **kwargs)
+        return cast(T, cls._instances[cls])
+
+    def get_instance(cls: Type[T], *args: Any, **kwargs: Any) -> T:
+        """Explicit method to retrieve the singleton instance with correct return type."""
+        return cls(*args, **kwargs)  # Triggers __call__

notionary/workspace.py

@@ -0,0 +1,69 @@
+import asyncio
+from typing import Optional, List
+from notionary import NotionPage, NotionDatabase
+from notionary.database.client import NotionDatabaseClient
+from notionary.page.client import NotionPageClient
+from notionary.util import LoggingMixin
+
+
+class NotionWorkspace(LoggingMixin):
+    """
+    Represents a Notion workspace, providing methods to interact with databases and pages.
+    """
+
+    def __init__(self, token: Optional[str] = None):
+        """
+        Initialize the workspace with a Notion database_client.
+        """
+        self.database_client = NotionDatabaseClient(token=token)
+        self.page_client = NotionPageClient(token=token)
+
+    async def search_pages(self, query: str, limit=100) -> List[NotionPage]:
+        """
+        Search for pages globally across Notion workspace.
+        """
+        response = await self.page_client.search_pages(query, limit=limit)
+        # Parallelisiere die Erzeugung der NotionPage-Instanzen
+        return await asyncio.gather(
+            *(NotionPage.from_page_id(page.id) for page in response.results)
+        )
+
+    async def search_databases(
+        self, query: str, limit: int = 100
+    ) -> List[NotionDatabase]:
+        """
+        Search for databases globally across the Notion workspace.
+        """
+        response = await self.database_client.search_databases(query=query, limit=limit)
+        return await asyncio.gather(
+            *(
+                NotionDatabase.from_database_id(database.id)
+                for database in response.results
+            )
+        )
+
+    async def get_database_by_name(
+        self, database_name: str
+    ) -> Optional[NotionDatabase]:
+        """
+        Get a Notion database by its name.
+        Uses Notion's search API and returns the first matching database.
+        """
+        databases = await self.search_databases(query=database_name, limit=1)
+
+        return databases[0] if databases else None
+
+    async def list_all_databases(self, limit: int = 100) -> List[NotionDatabase]:
+        """
+        List all databases in the workspace.
+        Returns a list of NotionDatabase instances.
+        """
+        database_results = await self.database_client.search_databases(
+            query="", limit=limit
+        )
+        return [
+            await NotionDatabase.from_database_id(database.id)
+            for database in database_results.results
+        ]
+
+    # TODO: Create database would be nice here

{notionary-0.2.13.dist-info → notionary-0.2.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: notionary
-Version: 0.2.13
+Version: 0.2.14
 Summary: A toolkit to convert between Markdown and Notion blocks
 Home-page: https://github.com/mathisarends/notionary
 Author: Mathis Arends
@@ -15,6 +15,9 @@ Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: pydantic>=2.11.4
 Requires-Dist: posthog>=3.0.0
 Requires-Dist: click>=8.0.0
+Requires-Dist: openai>=1.30.1
+Requires-Dist: langchain>=0.2.0
+Requires-Dist: tiktoken>=0.6.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

notionary-0.2.14.dist-info/RECORD

@@ -0,0 +1,72 @@
+notionary/__init__.py,sha256=4eO6Jx57VRR_Ejo9w7IJeET8SZOvxFl_1lOB39o39No,250
+notionary/base_notion_client.py,sha256=bqQu9uEdDmZhMAGGv6e_B8mBLOAWLWjoP8s9L6UaQks,6714
+notionary/workspace.py,sha256=kW9fbVUSECivlvABBwnks2nALfk09V6g6Oc2Eq_pK5U,2511
+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/qoute_element.py,sha256=pkeT6N7PZrepIod8WLrY1DMe2DW6fM98Y4zXiiACenw,6059
+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/blocks/prompts/element_prompt_builder.py,sha256=rYMKPmpEFyk26JFZlwcTzMHATpvHnn4Dn284vewFog0,2953
+notionary/blocks/prompts/element_prompt_content.py,sha256=ItnhGwKsHGnnY9E_LGgZZeTCT9ZfnkJY8xad4wFViWk,1567
+notionary/blocks/registry/block_registry.py,sha256=hEBa8PdFn1CeevFBqKbcFX7yuBjulwGASUMKoHRsm9s,4305
+notionary/blocks/registry/block_registry_builder.py,sha256=FA_0WOajaeVaqdphNh8EyN0p_7ItzFqEufYa6YVBLeY,8731
+notionary/cli/main.py,sha256=-rQoDGvDrFIOvoWzJIIrXQQz4H12D3TkwdNdEF9SEGQ,12883
+notionary/cli/onboarding.py,sha256=KQornxGBxsyXa0PfVqt4KPq-3B3Ry1sLd5DB3boAB04,3350
+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/notion_database.py,sha256=fM6lmL673bKQPfDDj6tyj8K7yO0gSi8veEiUIE5enF8,15497
+notionary/database/notion_database_provider.py,sha256=2zaRycrbnceV_EbZugdNM_YF9iCGBen-A6E4jvZe2mU,9119
+notionary/database/models/page_result.py,sha256=Vmm5_oYpYAkIIJVoTd1ZZGloeC3cmFLMYP255mAmtaw,233
+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/markdown_syntax_prompt_generator.py,sha256=uHCPNV9aQi3GzLVimyUKwza29hfxu6DTMVIa_QevJbk,4987
+notionary/page/notion_page.py,sha256=xxvXJz3wg1TCUyjN6-U6na9zps4fsLlwoVAj3ylBLLA,19151
+notionary/page/notion_to_markdown_converter.py,sha256=_MJWWwsBvgZ3a8tLZ23ZCIA_G9Qfvt2JG1FqVTlRxHs,6308
+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/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/properites/property_value_extractor.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+notionary/util/__init__.py,sha256=EzAmP2uEFfazWapb41BY9kAua1ZEiuLRPaBMtw_cOYg,358
+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-0.2.14.dist-info/licenses/LICENSE,sha256=zOm3cRT1qD49eg7vgw95MI79rpUAZa1kRBFwL2FkAr8,1120
+notionary-0.2.14.dist-info/METADATA,sha256=R94Tb7hWlk_LhA7bKSbgyLe6K9GgcZstI0WAfaNw1qU,7678
+notionary-0.2.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+notionary-0.2.14.dist-info/entry_points.txt,sha256=V7X21u3QNm7h7p6Cx0Sx2SO3mtmA7gVwXM8lNYnv9fk,54
+notionary-0.2.14.dist-info/top_level.txt,sha256=fhONa6BMHQXqthx5PanWGbPL0b8rdFqhrJKVLf_adSs,10
+notionary-0.2.14.dist-info/RECORD,,