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

notionary/user/notion_user_manager.py

@@ -0,0 +1,173 @@
+from typing import Any, Dict, Optional, List
+from notionary.user.client import NotionUserClient
+from notionary.user.notion_user import NotionUser
+from notionary.user.models import NotionUsersListResponse
+from notionary.util import LoggingMixin
+
+
+class NotionUserManager(LoggingMixin):
+    """
+    Manager for user operations within API limitations.
+
+    Note: The Notion API provides endpoints to list workspace users (excluding guests).
+    This manager provides utility functions for working with individual users and user lists.
+    """
+
+    def __init__(self, token: Optional[str] = None):
+        """Initialize the user manager."""
+        self.client = NotionUserClient(token=token)
+
+    async def get_current_bot_user(self) -> Optional[NotionUser]:
+        """
+        Get the current bot user from the API token.
+        """
+        return await NotionUser.current_bot_user(token=self.client.token)
+
+    async def get_user_by_id(self, user_id: str) -> Optional[NotionUser]:
+        """
+        Get a specific user by their ID.
+        """
+        return await NotionUser.from_user_id(user_id, token=self.client.token)
+
+    async def list_users(
+        self, page_size: int = 100, start_cursor: Optional[str] = None
+    ) -> Optional[NotionUsersListResponse]:
+        """
+        List users in the workspace (paginated).
+
+        Note: Guests are not included in the response.
+        """
+        try:
+            response = await self.client.list_users(page_size, start_cursor)
+            if response is None:
+                self.logger.error("Failed to list users")
+                return None
+
+            self.logger.info(
+                "Retrieved %d users (has_more: %s)",
+                len(response.results),
+                response.has_more,
+            )
+            return response
+
+        except Exception as e:
+            self.logger.error("Error listing users: %s", str(e))
+            return None
+
+    async def get_all_users(self) -> List[NotionUser]:
+        """
+        Get all users in the workspace as NotionUser objects.
+        Automatically handles pagination and converts responses to NotionUser instances.
+        """
+        try:
+            # Get raw user responses
+            user_responses = await self.client.get_all_users()
+
+            # Convert to NotionUser objects
+            notion_users = []
+            for user_response in user_responses:
+                try:
+                    # Use the internal creation method to convert response to NotionUser
+                    notion_user = NotionUser.from_notion_user_response(
+                        user_response, self.client.token
+                    )
+                    notion_users.append(notion_user)
+                except Exception as e:
+                    self.logger.warning(
+                        "Failed to convert user %s to NotionUser: %s",
+                        user_response.id,
+                        str(e),
+                    )
+                    continue
+
+            self.logger.info(
+                "Successfully converted %d users to NotionUser objects",
+                len(notion_users),
+            )
+            return notion_users
+
+        except Exception as e:
+            self.logger.error("Error getting all users: %s", str(e))
+            return []
+
+    async def get_users_by_type(self, user_type: str = "person") -> List[NotionUser]:
+        """
+        Get all users of a specific type (person or bot).
+        """
+        try:
+            all_users = await self.get_all_users()
+            filtered_users = [user for user in all_users if user.user_type == user_type]
+
+            self.logger.info(
+                "Found %d users of type '%s' out of %d total users",
+                len(filtered_users),
+                user_type,
+                len(all_users),
+            )
+            return filtered_users
+
+        except Exception as e:
+            self.logger.error("Error filtering users by type: %s", str(e))
+            return []
+
+    # TODO: Type this
+    async def get_workspace_info(self) -> Optional[Dict[str, Any]]:
+        """
+        Get available workspace information from the bot user.
+        """
+        bot_user = await self.get_current_bot_user()
+        if bot_user is None:
+            self.logger.error("Failed to get bot user for workspace info")
+            return None
+
+        workspace_info = {
+            "workspace_name": bot_user.workspace_name,
+            "bot_user_id": bot_user.id,
+            "bot_user_name": bot_user.name,
+            "bot_user_type": bot_user.user_type,
+        }
+
+        # Add workspace limits if available
+        if bot_user.is_bot:
+            limits = await bot_user.get_workspace_limits()
+            if limits:
+                workspace_info["workspace_limits"] = limits
+
+        # Add user count statistics
+        try:
+            all_users = await self.get_all_users()
+            workspace_info["total_users"] = len(all_users)
+            workspace_info["person_users"] = len([u for u in all_users if u.is_person])
+            workspace_info["bot_users"] = len([u for u in all_users if u.is_bot])
+        except Exception as e:
+            self.logger.warning("Could not get user statistics: %s", str(e))
+
+        return workspace_info
+
+    async def find_users_by_name(self, name_pattern: str) -> List[NotionUser]:
+        """
+        Find users by name pattern (case-insensitive partial match).
+
+        Note: The API doesn't support server-side filtering, so this fetches all users
+        and filters client-side.
+        """
+        try:
+            all_users = await self.get_all_users()
+            pattern_lower = name_pattern.lower()
+
+            matching_users = [
+                user
+                for user in all_users
+                if user.name and pattern_lower in user.name.lower()
+            ]
+
+            self.logger.info(
+                "Found %d users matching pattern '%s'",
+                len(matching_users),
+                name_pattern,
+            )
+            return matching_users
+
+        except Exception as e:
+            self.logger.error("Error finding users by name: %s", str(e))
+            return []

notionary/user/notion_user_provider.py

@@ -0,0 +1 @@
+# for caching shit

notionary/util/__init__.py

@@ -1,15 +1,13 @@
 from .logging_mixin import LoggingMixin
-from .singleton_decorator import singleton
+from .singleton import singleton
 from .page_id_utils import format_uuid
-from .fuzzy_matcher import FuzzyMatcher
-from .factory_decorator import factory_only
+from .factory_only import factory_only
 from .singleton_metaclass import SingletonMetaClass
 
 __all__ = [
     "LoggingMixin",
-    "singleton_decorator",
+    "singleton",
     "format_uuid",
-    "FuzzyMatcher",
     "factory_only",
     "singleton",
     "SingletonMetaClass",

notionary/util/{factory_decorator.py → factory_only.py}

@@ -1,10 +1,11 @@
 import functools
 import inspect
+import warnings
 
 
 def factory_only(*allowed_factories):
     """
-    Decorator that ensures __init__ is only called from allowed factory methods.
+    Decorator that warns when __init__ is not called from allowed factory methods.
 
     Args:
         *allowed_factories: Names of allowed factory methods (e.g. 'from_database_id')
@@ -21,10 +22,13 @@ def factory_only(*allowed_factories):
                 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)}"
-                    )
+
+                warnings.warn(
+                    f"Direct instantiation not recommended! Consider using one of: {', '.join(allowed_factories)}",
+                    UserWarning,
+                    stacklevel=3,
+                )
+                return init_method(self, *args, **kwargs)
             finally:
                 del frame
 

notionary/util/fuzzy.py

@@ -0,0 +1,74 @@
+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
+
+
+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()
+
+
+def find_best_matches(
+    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 = 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
+
+
+def find_best_match(
+    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 = find_best_matches(query, items, text_extractor, min_similarity, limit=1)
+    return matches[0] if matches else None

notionary/util/logging_mixin.py

@@ -1,14 +1,24 @@
 import logging
-import inspect
 from typing import Optional, ClassVar
 
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
 
 def setup_logging():
+    """
+    Sets up logging configuration for the application.
+    """
+    log_level = os.getenv("LOG_LEVEL", "WARNING").upper()
     logging.basicConfig(
-        level=logging.INFO,
+        level=getattr(logging, log_level),
         format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
     )
 
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+
 
 setup_logging()
 
@@ -32,16 +42,6 @@ class LoggingMixin:
             self._logger = logging.getLogger(self.__class__.__name__)
         return self._logger
 
-    @staticmethod
-    def static_logger() -> logging.Logger:
-        """Static logger - for static methods"""
-        stack = inspect.stack()
-        for frame_info in stack[1:]:
-            class_name = LoggingMixin._get_class_name_from_frame(frame_info.frame)
-            if class_name:
-                return logging.getLogger(class_name)
-        return logging.getLogger("UnknownStaticContext")
-
     @staticmethod
     def _get_class_name_from_frame(frame) -> Optional[str]:
         local_vars = frame.f_locals

notionary/workspace.py

@@ -3,20 +3,25 @@ from typing import Optional, List
 from notionary import NotionPage, NotionDatabase
 from notionary.database.client import NotionDatabaseClient
 from notionary.page.client import NotionPageClient
+from notionary.user import NotionUser, NotionUserManager
 from notionary.util import LoggingMixin
 
 
 class NotionWorkspace(LoggingMixin):
     """
-    Represents a Notion workspace, providing methods to interact with databases and pages.
+    Represents a Notion workspace, providing methods to interact with databases, pages, and limited user operations.
+
+    Note: Due to Notion API limitations, bulk user operations (listing all users) are not supported.
+    Only individual user queries and bot user information are available.
     """
 
     def __init__(self, token: Optional[str] = None):
         """
-        Initialize the workspace with a Notion database_client.
+        Initialize the workspace with Notion clients.
         """
         self.database_client = NotionDatabaseClient(token=token)
         self.page_client = NotionPageClient(token=token)
+        self.user_manager = NotionUserManager(token=token)
 
     async def search_pages(self, query: str, limit=100) -> List[NotionPage]:
         """
@@ -66,4 +71,35 @@ class NotionWorkspace(LoggingMixin):
             for database in database_results.results
         ]
 
+    # User-related methods (limited due to API constraints)
+    async def get_current_bot_user(self) -> Optional[NotionUser]:
+        """
+        Get the current bot user from the API token.
+
+        Returns:
+            Optional[NotionUser]: Current bot user or None if failed
+        """
+        return await self.user_manager.get_current_bot_user()
+
+    async def get_user_by_id(self, user_id: str) -> Optional[NotionUser]:
+        """
+        Get a specific user by their ID.
+
+        Args:
+            user_id: The ID of the user to retrieve
+
+        Returns:
+            Optional[NotionUser]: The user or None if not found/failed
+        """
+        return await self.user_manager.get_user_by_id(user_id)
+
+    async def get_workspace_info(self) -> Optional[dict]:
+        """
+        Get available workspace information including bot details.
+
+        Returns:
+            Optional[dict]: Workspace information or None if failed to get bot user
+        """
+        return await self.user_manager.get_workspace_info()
+
     # TODO: Create database would be nice here

{notionary-0.2.16.dist-info → notionary-0.2.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: notionary
-Version: 0.2.16
+Version: 0.2.17
 Summary: Python library for programmatic Notion workspace management - databases, pages, and content with advanced Markdown support
 License: MIT
 Author: Mathis Arends
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: aiofiles (>=24.1.0,<25.0.0)
 Requires-Dist: httpx (>=0.28.0)
 Requires-Dist: posthog (>=6.3.1,<7.0.0)
 Requires-Dist: pydantic (>=2.11.4)

{notionary-0.2.16.dist-info → notionary-0.2.17.dist-info}/RECORD

@@ -1,6 +1,6 @@
-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/__init__.py,sha256=oVZiZglID0yNOWB6VjIpN9HMpsROBDRraWJjUp43qvQ,511
+notionary/base_notion_client.py,sha256=WIAIKZeGCeAwtHWnL4Kfcmzv2TBlxvz7cfGF26i89y0,7067
+notionary/blocks/__init__.py,sha256=-Za7ipQtuHtYplx9yYuA4Smt0c1JxU0ymOWw1EFEfMs,2090
 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
@@ -8,6 +8,7 @@ notionary/blocks/callout_element.py,sha256=Cya-1HIRBiCiyMgQq6PqXU4_iGj2O3qAPirht
 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/document_element.py,sha256=VgICkBrSLKzQ_kuyzMiaJg__ccCiM6x1hqGj5lfwANQ,7035
 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
@@ -27,15 +28,20 @@ notionary/blocks/todo_element.py,sha256=6ndhgGJNiy7eb-Ll--Va7zEqQySxFAFYpzY4PWJb
 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/__init__.py,sha256=4tdML0fBzkOCpiWT6q-L--5NELFLbTPD0IUA_E8yZno,155
 notionary/database/client.py,sha256=ZcfydeYlpgGJt6wV1ib33KeXUiL-cGNJ1qraQZ4RVRc,4775
-notionary/database/database_exceptions.py,sha256=jwFdxoIQHLO3mO3p5t890--1FjbTX60fNyqBAe-sszo,452
+notionary/database/database.py,sha256=7KBe6DWbtsakPvjUO45eCphD2sq0ZKuYHY3kXJsk4P8,16582
+notionary/database/database_filter_builder.py,sha256=PCnq3M9REt-NHRgBIfSrTCIPykUqBs5RqZK13WOAHKA,5950
+notionary/database/database_provider.py,sha256=MveBSMkYG8nLUzKTS7KjbFVH8H-vLdH0t6yGArs-vPQ,8976
+notionary/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/database/notion_database.py,sha256=wSqPfVtOnDL-aKRrE9BSMP1cpHe0_8RYyfCMxrlJSNo,16746
 notionary/elements/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+notionary/file_upload/__init__.py,sha256=7TNyiIgLMD_IGRXTwRiAmStokF3rLoG4zXPwNb9KQqk,168
+notionary/file_upload/client.py,sha256=qlxgu7_Ia0wbBflInoGki4mR8Po_RZgfLjO2wa279jY,8581
+notionary/file_upload/models.py,sha256=0mYtuGkZ_eh_YmX0uxqye5vg3wWgqWuwOupAmLJXMUY,1625
+notionary/file_upload/notion_file_upload.py,sha256=DZHRyKtGcLubgNE6yg5Nibs7mpWxp18YFBGJBBxSjsk,13163
 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
@@ -48,7 +54,7 @@ notionary/page/content/page_content_writer.py,sha256=VVvK-Z8NvyIhi7Crcm9mZQuuD_L
 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_page.py,sha256=4KXPtDORuk7-8bJ5NV_x9RplLTgNHl72ngECc_M32xA,19126
 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
@@ -56,16 +62,24 @@ notionary/page/search_filter_builder.py,sha256=wZpW_KHmPXql3sNIyQd9EzZ2-ERy2i0vY
 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/telemetry/views.py,sha256=FgFZGYaxP7pRYx-9wg18skMh_MJAwf4W3rCfe9JOZe4,1796
+notionary/user/__init__.py,sha256=D8r_WtQimdT-l3P1wd8O9Iki5JXF7jg2KV_hOgzWraw,281
+notionary/user/base_notion_user.py,sha256=QB1701CfQTeu1ZNWOHYnGvTSHZuiritr6xYNMqyVg_U,1500
+notionary/user/client.py,sha256=v8-lpyKzY_gSWPdWkBEjqxEPSg1WCy9AYSAJLXRrfKA,4563
+notionary/user/models.py,sha256=3WPUysO96hMZUZYUWoCH5cdqNvnWgdiw5Qd7QKOv2UY,2063
+notionary/user/notion_bot_user.py,sha256=cwrwmfst5RbAgppIjoFMJjExms1epfRM9VBd-S-3y5Q,7784
+notionary/user/notion_user.py,sha256=l0GOMakk_xzsUUt7SsDJ5j-3dbtX64cUyyQPxn0r0Zc,8512
+notionary/user/notion_user_manager.py,sha256=JQddAvbKJiLCLCn0mfxmvoi5uLW95vHhMWEYZD_F9zk,6339
+notionary/user/notion_user_provider.py,sha256=7ImQ7T76g88W4YyHGOoO0aUJQfdGlhbh1fMT9PzR1mU,19
+notionary/util/__init__.py,sha256=Bu2yGFd3xPasBrMRMk-6DcmMXfkdXn-KfFRETApBcP8,351
+notionary/util/factory_only.py,sha256=q-ZXUEvQ8lsuD1JQwx-ai6e9Lhie65waRE1BcRhCR_4,1235
+notionary/util/fuzzy.py,sha256=lTlWuYEs0lhLa7QIRre3GVJ8-biIV_NmcJnMzBYFF5U,2061
+notionary/util/logging_mixin.py,sha256=t08dx3nhSJq2-6_N8G39aydPEkQ76D4MlRfymxCsCVM,1690
 notionary/util/page_id_utils.py,sha256=AA00kRO-g3Cc50tf_XW_tb5RBuPKLuBxRa0D8LYhLXg,736
-notionary/util/singleton_decorator.py,sha256=CKAvykndwPRZsA3n3MAY_XdCR59MBjjKP0vtm2BcvF0,428
+notionary/util/singleton.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,,
+notionary/workspace.py,sha256=W3YybEUI7Kwp1sa7DRI-kc7ViMBLRs1kIkum2G8bqqM,3878
+notionary-0.2.17.dist-info/LICENSE,sha256=zOm3cRT1qD49eg7vgw95MI79rpUAZa1kRBFwL2FkAr8,1120
+notionary-0.2.17.dist-info/METADATA,sha256=b9HAyv9WytOyw5-OnObrvTs1FOfAuho1-gCCzeQ9frk,6867
+notionary-0.2.17.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+notionary-0.2.17.dist-info/RECORD,,

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