notionary 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

notionary/core/page/meta_data/metadata_editor.py

@@ -0,0 +1,37 @@
+from typing import Any, Dict, Optional
+from notionary.core.notion_client import NotionClient
+from notionary.util.logging_mixin import LoggingMixin
+
+
+class MetadataEditor(LoggingMixin):
+    def __init__(self, page_id: str, client: NotionClient):
+        self.page_id = page_id
+        self._client = client
+
+    async def set_title(self, title: str) -> Optional[Dict[str, Any]]:
+        return await self._client.patch(
+            f"pages/{self.page_id}",
+            {
+                "properties": {
+                    "title": {"title": [{"type": "text", "text": {"content": title}}]}
+                }
+            },
+        )
+
+    async def set_icon(
+        self, emoji: Optional[str] = None, external_url: Optional[str] = None
+    ) -> Optional[Dict[str, Any]]:
+        if emoji:
+            icon = {"type": "emoji", "emoji": emoji}
+        elif external_url:
+            icon = {"type": "external", "external": {"url": external_url}}
+        else:
+            return None
+
+        return await self._client.patch(f"pages/{self.page_id}", {"icon": icon})
+
+    async def set_cover(self, external_url: str) -> Optional[Dict[str, Any]]:
+        return await self._client.patch(
+            f"pages/{self.page_id}",
+            {"cover": {"type": "external", "external": {"url": external_url}}},
+        )

notionary/core/page/notion_page_manager.py

@@ -0,0 +1,110 @@
+from typing import Any, Dict, List, Optional
+from notionary.core.converters.registry.block_element_registry import (
+    BlockElementRegistry,
+)
+from notionary.core.converters.registry.block_element_registry_builder import (
+    BlockElementRegistryBuilder,
+)
+from notionary.core.notion_client import NotionClient
+from notionary.core.page.page_content_manager import PageContentManager
+from notionary.util.logging_mixin import LoggingMixin
+from notionary.core.page.meta_data.metadata_editor import MetadataEditor
+from notionary.util.uuid_utils import extract_uuid, format_uuid, is_valid_uuid
+
+
+class NotionPageManager(LoggingMixin):
+    """
+    High-Level Fassade zur Verwaltung von Inhalten und Metadaten einer Notion-Seite.
+    """
+
+    def __init__(
+        self,
+        page_id: Optional[str] = None,
+        title: Optional[str] = None,
+        url: Optional[str] = None,
+        token: Optional[str] = None,
+    ):
+        if not page_id and not url:
+            raise ValueError("Either page_id or url must be provided")
+
+        if not page_id and url:
+            page_id = extract_uuid(url)
+            if not page_id:
+                raise ValueError(f"Could not extract a valid UUID from the URL: {url}")
+
+        page_id = format_uuid(page_id)
+        if not page_id or not is_valid_uuid(page_id):
+            raise ValueError(f"Invalid UUID format: {page_id}")
+
+        self._page_id = page_id
+        self.url = url
+        self._title = title
+
+        self._client = NotionClient(token=token)
+
+        self._block_element_registry = (
+            BlockElementRegistryBuilder.create_standard_registry()
+        )
+
+        self._page_content_manager = PageContentManager(
+            page_id=page_id,
+            client=self._client,
+            block_registry=self._block_element_registry,
+        )
+        self._metadata = MetadataEditor(page_id, self._client)
+
+    @property
+    def page_id(self) -> Optional[str]:
+        """Get the title of the page."""
+        return self._page_id
+
+    @property
+    def title(self) -> Optional[str]:
+        return self._title
+
+    @property
+    def block_registry(self) -> BlockElementRegistry:
+        return self._block_element_registry
+
+    @block_registry.setter
+    def block_registry(self, block_registry: BlockElementRegistry) -> None:
+        """Set the block element registry for the page content manager."""
+
+        self._block_element_registry = block_registry
+
+        self._page_content_manager = PageContentManager(
+            page_id=self._page_id, client=self._client, block_registry=block_registry
+        )
+
+    async def append_markdown(self, markdown: str) -> str:
+        return await self._page_content_manager.append_markdown(markdown)
+
+    async def clear(self) -> str:
+        return await self._page_content_manager.clear()
+
+    async def replace_content(self, markdown: str) -> str:
+        await self._page_content_manager.clear()
+        return await self._page_content_manager.append_markdown(markdown)
+
+    async def get_blocks(self) -> List[Dict[str, Any]]:
+        return await self._page_content_manager.get_blocks()
+
+    async def get_block_children(self, block_id: str) -> List[Dict[str, Any]]:
+        return await self._page_content_manager.get_block_children(block_id)
+
+    async def get_page_blocks_with_children(self) -> List[Dict[str, Any]]:
+        return await self._page_content_manager.get_page_blocks_with_children()
+
+    async def get_text(self) -> str:
+        return await self._page_content_manager.get_text()
+
+    async def set_title(self, title: str) -> Optional[Dict[str, Any]]:
+        return await self._metadata.set_title(title)
+
+    async def set_page_icon(
+        self, emoji: Optional[str] = None, external_url: Optional[str] = None
+    ) -> Optional[Dict[str, Any]]:
+        return await self._metadata.set_icon(emoji, external_url)
+
+    async def set_page_cover(self, external_url: str) -> Optional[Dict[str, Any]]:
+        return await self._metadata.set_cover(external_url)

notionary/core/page/page_content_manager.py

@@ -0,0 +1,85 @@
+from typing import Any, Dict, List, Optional
+
+from notionary.core.converters.markdown_to_notion_converter import (
+    MarkdownToNotionConverter,
+)
+from notionary.core.converters.notion_to_markdown_converter import (
+    NotionToMarkdownConverter,
+)
+from notionary.core.converters.registry.block_element_registry import (
+    BlockElementRegistry,
+)
+from notionary.core.notion_client import NotionClient
+from notionary.util.logging_mixin import LoggingMixin
+
+
+class PageContentManager(LoggingMixin):
+    def __init__(
+        self,
+        page_id: str,
+        client: NotionClient,
+        block_registry: Optional[BlockElementRegistry] = None,
+    ):
+        self.page_id = page_id
+        self._client = client
+        self._markdown_to_notion_converter = MarkdownToNotionConverter(
+            block_registry=block_registry
+        )
+        self._notion_to_markdown_converter = NotionToMarkdownConverter(
+            block_registry=block_registry
+        )
+
+    async def append_markdown(self, markdown_text: str) -> str:
+        blocks = self._markdown_to_notion_converter.convert(markdown_text)
+        result = await self._client.patch(
+            f"blocks/{self.page_id}/children", {"children": blocks}
+        )
+        return (
+            "Successfully added text to the page." if result else "Failed to add text."
+        )
+
+    async def clear(self) -> str:
+        blocks = await self._client.get(f"blocks/{self.page_id}/children")
+        if not blocks:
+            return "No content to delete."
+
+        results = blocks.get("results", [])
+        if not results:
+            return "No content to delete."
+
+        deleted = 0
+        for b in results:
+            if await self._client.delete(f"blocks/{b['id']}"):
+                deleted += 1
+
+        return f"Deleted {deleted}/{len(results)} blocks."
+
+    # Methods from PageContentReader
+    async def get_blocks(self) -> List[Dict[str, Any]]:
+        result = await self._client.get(f"blocks/{self.page_id}/children")
+        if not result:
+            self.logger.error("Error retrieving page content: %s", result.error)
+            return []
+        return result.data.get("results", [])
+
+    async def get_block_children(self, block_id: str) -> List[Dict[str, Any]]:
+        result = await self._client.get(f"blocks/{block_id}/children")
+        if not result:
+            self.logger.error("Error retrieving block children: %s", result.error)
+            return []
+        return result.data.get("results", [])
+
+    async def get_page_blocks_with_children(self) -> List[Dict[str, Any]]:
+        blocks = await self.get_blocks()
+        for block in blocks:
+            if block.get("has_children"):
+                block_id = block.get("id")
+                if block_id:
+                    children = await self.get_block_children(block_id)
+                    if children:
+                        block["children"] = children
+        return blocks
+
+    async def get_text(self) -> str:
+        blocks = await self.get_page_blocks_with_children()
+        return self._notion_to_markdown_converter.convert(blocks)

notionary/core/page/property_formatter.py

@@ -0,0 +1,97 @@
+from typing import Any, Dict, Optional
+
+from notionary.util.logging_mixin import LoggingMixin
+
+
+class NotionPropertyFormatter(LoggingMixin):
+    """Klasse zur Formatierung von Notion-Eigenschaften nach Typ."""
+
+    def __init__(self):
+        # Mapping von Typen zu Formatierungsmethoden
+        self._formatters = {
+            "title": self.format_title,
+            "rich_text": self.format_rich_text,
+            "url": self.format_url,
+            "email": self.format_email,
+            "phone_number": self.format_phone_number,
+            "number": self.format_number,
+            "checkbox": self.format_checkbox,
+            "select": self.format_select,
+            "multi_select": self.format_multi_select,
+            "date": self.format_date,
+            "status": self.format_status,
+            "relation": self.format_relation,
+        }
+
+    def format_title(self, value: Any) -> Dict[str, Any]:
+        """Formatiert einen Titel-Wert."""
+        return {"title": [{"type": "text", "text": {"content": str(value)}}]}
+
+    def format_rich_text(self, value: Any) -> Dict[str, Any]:
+        """Formatiert einen Rich-Text-Wert."""
+        return {"rich_text": [{"type": "text", "text": {"content": str(value)}}]}
+
+    def format_url(self, value: str) -> Dict[str, Any]:
+        """Formatiert eine URL."""
+        return {"url": value}
+
+    def format_email(self, value: str) -> Dict[str, Any]:
+        """Formatiert eine E-Mail-Adresse."""
+        return {"email": value}
+
+    def format_phone_number(self, value: str) -> Dict[str, Any]:
+        """Formatiert eine Telefonnummer."""
+        return {"phone_number": value}
+
+    def format_number(self, value: Any) -> Dict[str, Any]:
+        """Formatiert eine Zahl."""
+        return {"number": float(value)}
+
+    def format_checkbox(self, value: Any) -> Dict[str, Any]:
+        """Formatiert einen Checkbox-Wert."""
+        return {"checkbox": bool(value)}
+
+    def format_select(self, value: str) -> Dict[str, Any]:
+        """Formatiert einen Select-Wert."""
+        return {"select": {"name": str(value)}}
+
+    def format_multi_select(self, value: Any) -> Dict[str, Any]:
+        """Formatiert einen Multi-Select-Wert."""
+        if isinstance(value, list):
+            return {"multi_select": [{"name": item} for item in value]}
+        return {"multi_select": [{"name": str(value)}]}
+
+    def format_date(self, value: Any) -> Dict[str, Any]:
+        """Formatiert ein Datum."""
+        if isinstance(value, dict) and "start" in value:
+            return {"date": value}
+        return {"date": {"start": str(value)}}
+
+    def format_status(self, value: str) -> Dict[str, Any]:
+        """Formatiert einen Status-Wert."""
+        return {"status": {"name": str(value)}}
+
+    def format_relation(self, value: Any) -> Dict[str, Any]:
+        """Formatiert einen Relations-Wert."""
+        if isinstance(value, list):
+            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]]:
+        """
+        Formatiert einen Wert entsprechend des angegebenen Eigenschaftstyps.
+
+        Args:
+            property_type: Notion-Eigenschaftstyp (z.B. "title", "rich_text", "status")
+            value: Der zu formatierende Wert
+
+        Returns:
+            Formatierter Wert als Dictionary oder None bei unbekanntem Typ
+        """
+        formatter = self._formatters.get(property_type)
+        if not formatter:
+            if self.logger:
+                self.logger.warning("Unbekannter Eigenschaftstyp: %s", property_type)
+            return None
+
+        return formatter(value)

notionary/exceptions/database_exceptions.py

@@ -0,0 +1,76 @@
+from typing import Optional
+
+
+class NotionDatabaseException(Exception):
+    """Base exception for all Notion database operations."""
+
+    pass
+
+
+class DatabaseNotFoundException(NotionDatabaseException):
+    """Exception raised when a database is not found."""
+
+    def __init__(self, identifier: str, message: str = None):
+        self.identifier = identifier
+        self.message = message or f"Database not found: {identifier}"
+        super().__init__(self.message)
+
+
+class DatabaseInitializationError(NotionDatabaseException):
+    """Exception raised when a database manager fails to initialize."""
+
+    def __init__(self, database_id: str, message: str = None):
+        self.database_id = database_id
+        self.message = (
+            message or f"Failed to initialize database manager for ID: {database_id}"
+        )
+        super().__init__(self.message)
+
+
+class DatabaseConnectionError(NotionDatabaseException):
+    """Exception raised when there's an error connecting to Notion API."""
+
+    def __init__(self, message: str = None):
+        self.message = message or "Error connecting to Notion API"
+        super().__init__(self.message)
+
+
+class DatabaseParsingError(NotionDatabaseException):
+    """Exception raised when there's an error parsing database data."""
+
+    def __init__(self, message: str = None):
+        self.message = message or "Error parsing database data"
+        super().__init__(self.message)
+
+
+class PageNotFoundException(NotionDatabaseException):
+    """Raised when a page is not found or cannot be accessed."""
+
+    def __init__(self, page_id: str, message: Optional[str] = None):
+        self.page_id = page_id
+        self.message = message or f"Page not found: {page_id}"
+        super().__init__(self.message)
+
+
+class PageOperationError(NotionDatabaseException):
+    """Raised when an operation on a page fails."""
+
+    def __init__(self, page_id: str, operation: str, message: Optional[str] = None):
+        self.page_id = page_id
+        self.operation = operation
+        self.message = message or f"Failed to {operation} page {page_id}"
+        super().__init__(self.message)
+
+
+class PropertyError(NotionDatabaseException):
+    """Raised when there's an error with database properties."""
+
+    def __init__(
+        self, property_name: Optional[str] = None, message: Optional[str] = None
+    ):
+        self.property_name = property_name
+        self.message = (
+            message
+            or f"Error with property{' ' + property_name if property_name else ''}"
+        )
+        super().__init__(self.message)

notionary/exceptions/page_creation_exception.py

@@ -0,0 +1,9 @@
+from typing import Optional
+
+
+class PageCreationException(Exception):
+    """Exception raised when page creation in Notion fails."""
+
+    def __init__(self, message: str, response: Optional[dict] = None):
+        super().__init__(message)
+        self.response = response

notionary/util/logging_mixin.py

@@ -0,0 +1,47 @@
+import logging
+import inspect
+
+
+def setup_logging():
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    )
+
+
+class LoggingMixin:
+    @property
+    def logger(self):
+        if not hasattr(self, "_logger"):
+            self._logger = logging.getLogger(self.__class__.__name__)
+        return self._logger
+
+    @classmethod
+    def class_logger(cls):
+        """Class logger - für Klassenmethoden"""
+        return logging.getLogger(cls.__name__)
+
+    @staticmethod
+    def static_logger():
+        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):
+        local_vars = frame.f_locals
+        if "self" in local_vars:
+            return local_vars["self"].__class__.__name__
+
+        if "cls" in local_vars:
+            return local_vars["cls"].__name__
+
+        if "__qualname__" in frame.f_code.co_names:
+            qualname = frame.f_code.co_qualname
+            if "." in qualname:
+                return qualname.split(".")[0]
+
+        return None

notionary/util/singleton_decorator.py

@@ -0,0 +1,20 @@
+from typing import TypeVar
+from functools import wraps
+
+T = TypeVar("T")
+
+
+def singleton(cls: T) -> T:
+    """
+    Decorator zur Implementierung des Singleton-Musters.
+    Stellt sicher, dass nur eine Instanz der Klasse existiert.
+    """
+    instances = {}
+
+    @wraps(cls)
+    def get_instance(*args, **kwargs):
+        if cls not in instances:
+            instances[cls] = cls(*args, **kwargs)
+        return instances[cls]
+
+    return get_instance

notionary/util/uuid_utils.py

@@ -0,0 +1,24 @@
+import re
+from typing import Optional
+
+UUID_PATTERN = r"^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$"
+UUID_RAW_PATTERN = r"([a-f0-9]{32})"
+
+
+def extract_uuid(source: str) -> Optional[str]:
+    match = re.search(UUID_RAW_PATTERN, source.lower())
+    if not match:
+        return None
+
+    uuid_raw = match.group(1)
+    return f"{uuid_raw[0:8]}-{uuid_raw[8:12]}-{uuid_raw[12:16]}-{uuid_raw[16:20]}-{uuid_raw[20:32]}"
+
+
+def is_valid_uuid(uuid: str) -> bool:
+    return bool(re.match(UUID_PATTERN, uuid.lower()))
+
+
+def format_uuid(value: str) -> Optional[str]:
+    if is_valid_uuid(value):
+        return value
+    return extract_uuid(value)

{notionary-0.1.1.dist-info → notionary-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: notionary
-Version: 0.1.1
+Version: 0.1.3
 Summary: A toolkit to convert between Markdown and Notion blocks
 Home-page: https://github.com/mathisarends/notionary
 Author: Mathis Arends

notionary-0.1.3.dist-info/RECORD

@@ -0,0 +1,49 @@
+notionary/__init__.py,sha256=5T16clJlSHFsopcPUnkGrEo8spNDUQ0i-O00UEF7nR8,320
+notionary/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+notionary/core/notion_client.py,sha256=AKxQcXkQ9OsvFBBJEvMYfXipos8ttOMf_LtT09aR41M,4646
+notionary/core/converters/__init__.py,sha256=GOUehJbe4BKHtec1MqL1YGu3AX8zFtkwSZfhYkY5-P0,1798
+notionary/core/converters/markdown_to_notion_converter.py,sha256=PGtg4v5lUvkXXl1Y8E6a3Mf8hEfxfhBrslPs_H_Lq_E,16564
+notionary/core/converters/notion_to_markdown_converter.py,sha256=c8GyWX8-UrNfRDk7OOBKbSEb5qOwljUCwI6g5risO2c,1287
+notionary/core/converters/elements/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+notionary/core/converters/elements/bookmark_element.py,sha256=bpHobkGnyBGDAJK5vY9R3Ntl4GiRSF-EyyA31aq2O3E,8593
+notionary/core/converters/elements/callout_element.py,sha256=rkDoXikjIl-zU3GLawSXgRunBJGLnEvin9zIlCgW4TY,5964
+notionary/core/converters/elements/code_block_element.py,sha256=G1iGMsGSK5KPSk-tA8TsPs9XNU9ydjYfOVnjIvdZG74,5189
+notionary/core/converters/elements/column_element.py,sha256=ZwQsLBEownVJnzyv-GfNjvzJhAfKz9ncggqZUmZHF5A,10722
+notionary/core/converters/elements/divider_element.py,sha256=Ul0wXHY96qWL72iAvttRQMOoAGuASgwFwPraGnpUkX0,2792
+notionary/core/converters/elements/heading_element.py,sha256=BCBcpEO_UX92nzCclVHAjlOLFJ5zu9wDlAGbphesaOQ,2788
+notionary/core/converters/elements/image_element.py,sha256=uU3bY26LvJwD_CAXN11tqYt5Ed84gjUeHWnJmxvH07Y,4861
+notionary/core/converters/elements/list_element.py,sha256=lM9nVGVG3VtmjMkqxrBj71wiJITuRypwxORu4zghqAM,4878
+notionary/core/converters/elements/notion_block_element.py,sha256=lLRBDXhBeRaRzkbvdpYpr-U9nbkd62oVtqdSe-svT4c,1746
+notionary/core/converters/elements/paragraph_element.py,sha256=5YGZjcgs0QCvQZ2kF8WCtImbyq5BeMywmME1m3-NDdo,2766
+notionary/core/converters/elements/qoute_element.py,sha256=CZD1Fe_Lhxsv4mdAM_dr4tlWDjmZCU_5aSpLOFrxDcc,9057
+notionary/core/converters/elements/table_element.py,sha256=3V9bnNBdsslXZivQ0vpF4_rzrdyI3SWt3aYR814mOzA,11254
+notionary/core/converters/elements/text_inline_formatter.py,sha256=FE_Sq2cozpu5RVtMbnPq21gD06UjH3LMRYr3s16JKYo,10606
+notionary/core/converters/elements/todo_lists.py,sha256=wgY6YejURBQ5ESdVLZVIy9QKchS-x8odrmS8X4cC5Kc,4265
+notionary/core/converters/elements/toggle_element.py,sha256=Xv4MuuOyoamvT3IEJX4mynvLEycgtZ9LWt6Nm764KXE,6980
+notionary/core/converters/elements/video_element.py,sha256=xrBLY3e_SgKNamItZkfPNMbNEh37Ftp4jWIV6nwV-ds,6047
+notionary/core/converters/registry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+notionary/core/converters/registry/block_element_registry.py,sha256=0dpRFMM67UVmXRMP4-Ubc_uCZCVVmRKgxPpueCeknjw,8619
+notionary/core/converters/registry/block_element_registry_builder.py,sha256=yTV1GPKAN7o65r9jHIqPeBCw0ICdaUZnRC5JKNwpRq4,9227
+notionary/core/database/database_info_service.py,sha256=58k7om0UXP8w0jCJHewccG5UbOvELMBAbQvXOm7F1OM,1341
+notionary/core/database/database_query_service.py,sha256=ggD-Sx9GdRTeKn9ytGBxijQw6euYgV__iTpObT24ebo,2442
+notionary/core/database/database_schema_service.py,sha256=aVyguzw8YjgQ632TDyRCDfWWCsIok3vJ4Sx3dnG9pss,1869
+notionary/core/database/notion_database_manager.py,sha256=E3qUxPYEJ1drurmtZaqepskH84Iw-4RN3MyXv8cb8zQ,11443
+notionary/core/database/notion_database_manager_factory.py,sha256=jYQeoWV4VKyfCkbxCMVf0aeShfXDvE2EVTs3Jr--Ro8,8285
+notionary/core/database/notion_database_schema.py,sha256=DpZPkrR15u24PGd8jhTrqngu__5LviEsU-VBZgRzrHM,12486
+notionary/core/database/notion_database_writer.py,sha256=qpKOSDLI89GWL1kDnzLKSY5GVIzQHVYAWUl12_n-nwU,13651
+notionary/core/database/page_service.py,sha256=NzKCU2G-mnmqOitNWCJ6jOr0HSv1vPi1-ScSruvFdqg,5190
+notionary/core/database/models/page_result.py,sha256=Vmm5_oYpYAkIIJVoTd1ZZGloeC3cmFLMYP255mAmtaw,233
+notionary/core/page/notion_page_manager.py,sha256=iatr-ERpjdpdRRYH0w097YGVKbtor7GWWFqa421wOO8,4109
+notionary/core/page/page_content_manager.py,sha256=wx-2bW4znIaBVZeFwtoVrmlGUwHMLBPOLkQCZDIV3sA,3180
+notionary/core/page/property_formatter.py,sha256=X70Yfg0Y8HYLrFH7Y_BZVhhc_6b369jjn02bc5IZBBI,3780
+notionary/core/page/meta_data/metadata_editor.py,sha256=FpB7BA5cicWmEictwdn7EuRBMX7bGvSxbdM5Grs-jLI,1347
+notionary/exceptions/database_exceptions.py,sha256=I-Tx6bYRLpi5pjGPtbT-Mqxvz3BFgYTiuZxknJeLxtI,2638
+notionary/exceptions/page_creation_exception.py,sha256=4v7IuZD6GsQLrqhDLriGjuG3ML638gAO53zDCrLePuU,281
+notionary/util/logging_mixin.py,sha256=fKsx9t90bwvL74ZX3dU-sXdC4TZCQyO6qU9I8txkw_U,1369
+notionary/util/singleton_decorator.py,sha256=GTNMfIlVNRUVMw_c88xqd12-DcqZJjmyidN54yqiNVw,472
+notionary/util/uuid_utils.py,sha256=qS2tdJSqw_gLyQxVIqlIdmkzGa7b9bJ-vw88RiQ-oGc,680
+notionary-0.1.3.dist-info/licenses/LICENSE,sha256=zOm3cRT1qD49eg7vgw95MI79rpUAZa1kRBFwL2FkAr8,1120
+notionary-0.1.3.dist-info/METADATA,sha256=CCgL4-_K2WKIjzW5CFeOpDvcHxqe92xjTc1YeWJ_hbM,6153
+notionary-0.1.3.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+notionary-0.1.3.dist-info/top_level.txt,sha256=fhONa6BMHQXqthx5PanWGbPL0b8rdFqhrJKVLf_adSs,10
+notionary-0.1.3.dist-info/RECORD,,

notionary-0.1.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+notionary

notionary-0.1.1.dist-info/RECORD

@@ -1,5 +0,0 @@
-notionary-0.1.1.dist-info/licenses/LICENSE,sha256=zOm3cRT1qD49eg7vgw95MI79rpUAZa1kRBFwL2FkAr8,1120
-notionary-0.1.1.dist-info/METADATA,sha256=dfNzwMTI_-JHQAIOgKb-NOM2nbC_u2zzBukjiTzQTAg,6153
-notionary-0.1.1.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-notionary-0.1.1.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-notionary-0.1.1.dist-info/RECORD,,

notionary-0.1.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-