notionhelper 0.2.3__py3-none-any.whl → 0.3.1__py3-none-any.whl

notionhelper/helper.py

@@ -4,6 +4,9 @@ import os
 import requests
 import mimetypes
 import json
+from datetime import datetime
+import numpy as np
+
 
 # NotionHelper can be used in conjunction with the Streamlit APP: (Notion API JSON)[https://notioinapiassistant.streamlit.app]
 
@@ -94,6 +97,7 @@ class NotionHelper:
             response.raise_for_status()  # Raise an exception for HTTP errors
             return response.json()
         except requests.exceptions.HTTPError as http_err:
+            print(f"❌ NOTION API ERROR DETAILS: {response.text}")
             print(f"HTTP error occurred: {http_err}")
             if response is not None:  # Check if response was assigned before accessing .text
                 print(f"Response Body: {response.text}")
@@ -616,3 +620,211 @@ class NotionHelper:
 
         # Attach the file to the page property
         return self.attach_file_to_page_property(page_id, property_name, file_upload_id, file_name)
+
+    def upload_multiple_files_to_property(self, page_id: str, property_name: str, file_paths: List[str]) -> Dict[str, Any]:
+        """Uploads multiple files and attaches them all to a single Notion property."""
+        file_assets = []
+
+        for path in file_paths:
+            if os.path.exists(path):
+                # 1. Upload each file individually
+                upload_resp = self.upload_file(path)
+                file_upload_id = upload_resp["id"]
+
+                # 2. Build the 'files' array for the Notion request
+                file_assets.append({
+                    "type": "file_upload",
+                    "file_upload": {"id": file_upload_id},
+                    "name": os.path.basename(path)
+                })
+
+        # 3. Update the page property with the full list
+        update_url = f"https://api.notion.com/v1/pages/{page_id}"
+        headers = {
+            "Authorization": f"Bearer {self.notion_token}",
+            "Content-Type": "application/json",
+            "Notion-Version": "2025-09-03",
+        }
+        data = {
+            "properties": {
+                property_name: {
+                    "files": file_assets  # This array contains all your files
+                }
+            }
+        }
+        response = requests.patch(update_url, headers=headers, json=data)
+        return response.json()
+
+    def dict_to_notion_schema(self, data: Dict[str, Any], title_key: str) -> Dict[str, Any]:
+        """Converts a dictionary into a Notion property schema for database creation.
+
+        Parameters:
+            data (dict): Dictionary containing sample values to infer types from.
+            title_key (str): The key that should be used as the title property.
+
+        Returns:
+            dict: A dictionary defining the Notion property schema.
+        """
+        properties = {}
+
+        for key, value in data.items():
+            # Handle NumPy types
+            if hasattr(value, "item"):
+                value = value.item()
+
+            # Debug output to help diagnose type issues
+            print(f"DEBUG: key='{key}', value={value}, type={type(value).__name__}, isinstance(bool)={isinstance(value, bool)}, isinstance(int)={isinstance(value, int)}")
+
+            if key == title_key:
+                properties[key] = {"title": {}}
+            # IMPORTANT: Check for bool BEFORE (int, float) because bool is a subclass of int in Python
+            elif isinstance(value, bool):
+                properties[key] = {"checkbox": {}}
+                print(f"  → Assigned as CHECKBOX")
+            elif isinstance(value, (int, float)):
+                properties[key] = {"number": {"format": "number"}}
+                print(f"  → Assigned as NUMBER")
+            else:
+                properties[key] = {"rich_text": {}}
+                print(f"  → Assigned as RICH_TEXT")
+
+        return properties
+
+    def dict_to_notion_props(self, data: Dict[str, Any], title_key: str) -> Dict[str, Any]:
+        """Converts a dictionary into Notion property values for page creation.
+
+        Parameters:
+            data (dict): Dictionary containing the values to convert.
+            title_key (str): The key that should be used as the title property.
+
+        Returns:
+            dict: A dictionary defining the Notion property values.
+        """
+        notion_props = {}
+        for key, value in data.items():
+            # Handle NumPy types
+            if hasattr(value, "item"):
+                value = value.item()
+
+            if key == title_key:
+                ts = datetime.now().strftime("%Y-%m-%d %H:%M")
+                notion_props[key] = {"title": [{"text": {"content": f"{value} ({ts})"}}]}
+
+            # FIX: Handle Booleans
+            elif isinstance(value, bool):
+                # Option A: Map to a Checkbox column in Notion
+                # notion_props[key] = {"checkbox": value}
+
+                # Option B: Map to a Rich Text column as a string (since you added a rich text field)
+                notion_props[key] = {"rich_text": [{"text": {"content": str(value)}}]}
+
+            elif isinstance(value, (int, float)):
+                if pd.isna(value) or np.isinf(value): continue
+                notion_props[key] = {"number": float(value)}
+            else:
+                notion_props[key] = {"rich_text": [{"text": {"content": str(value)}}]}
+        return notion_props
+
+    def log_ml_experiment(
+        self,
+        data_source_id: str,
+        config: Dict,
+        metrics: Dict,
+        plots: List[str] = None,
+        target_metric: str = "sMAPE",      # Re-added these
+        higher_is_better: bool = False,   # to fix the error
+        file_paths: Optional[List[str]] = None, # Changed to list
+        file_property_name: str = "Output Files"
+    ):
+        """Logs ML experiment and compares metrics with multiple file support."""
+        improvement_tag = "Standard Run"
+        new_score = metrics.get(target_metric)
+
+        # 1. Leaderboard Logic (Champions)
+        if new_score is not None:
+            try:
+                df = self.get_data_source_pages_as_dataframe(data_source_id, limit=100)
+                if not df.empty and target_metric in df.columns:
+                    valid_scores = pd.to_numeric(df[target_metric], errors='coerce').dropna()
+                    if not valid_scores.empty:
+                        current_best = valid_scores.max() if higher_is_better else valid_scores.min()
+                        is_improvement = (new_score > current_best) if higher_is_better else (new_score < current_best)
+                        if is_improvement:
+                            improvement_tag = f"🏆 NEW BEST {target_metric} (Prev: {current_best:.2f})"
+                        else:
+                            diff = abs(new_score - current_best)
+                            improvement_tag = f"No Improvement (+{diff:.2f} {target_metric})"
+            except Exception as e:
+                print(f"Leaderboard check skipped: {e}")
+
+        # 2. Prepare Notion Properties
+        data_for_notion = metrics.copy()
+        data_for_notion["Run Status"] = improvement_tag
+        combined_payload = {**config, **data_for_notion}
+        title_key = list(config.keys())[0]
+        properties = self.dict_to_notion_props(combined_payload, title_key)
+
+        try:
+            # 3. Create the row
+            new_page = self.new_page_to_data_source(data_source_id, properties)
+            page_id = new_page["id"]
+
+            # 4. Handle Plots (Body)
+            if plots:
+                for plot_path in plots:
+                    if os.path.exists(plot_path):
+                        self.one_step_image_embed(page_id, plot_path)
+
+            # 5. Handle Multiple File Uploads (Property)
+            if file_paths:
+                file_assets = []
+                for path in file_paths:
+                    if os.path.exists(path):
+                        print(f"Uploading {path}...")
+                        upload_resp = self.upload_file(path)
+                        file_assets.append({
+                            "type": "file_upload",
+                            "file_upload": {"id": upload_resp["id"]},
+                            "name": os.path.basename(path),
+                        })
+
+                if file_assets:
+                    # Attach all files in one request
+                    update_url = f"https://api.notion.com/v1/pages/{page_id}"
+                    file_payload = {"properties": {file_property_name: {"files": file_assets}}}
+                    self._make_request("PATCH", update_url, file_payload)
+                    print(f"✅ {len(file_assets)} files attached to {file_property_name}")
+
+            return page_id
+        except Exception as e:
+            print(f"Log error: {e}")
+            return None
+
+    def create_ml_database(self, parent_page_id: str, db_title: str, config: Dict, metrics: Dict, file_property_name: str = "Output Files") -> str:
+        """
+        Analyzes dicts to create a new Notion Database with the correct schema.
+        Uses dict_to_notion_schema() for universal type conversion.
+        """
+        combined = {**config, **metrics}
+        title_key = list(config.keys())[0]
+
+        # Use the universal dict_to_notion_schema() method
+        properties = self.dict_to_notion_schema(combined, title_key)
+
+        # Add 'Run Status' if not already present
+        if "Run Status" not in properties:
+            properties["Run Status"] = {"rich_text": {}}
+
+        # Add the Multi-file property
+        properties[file_property_name] = {"files": {}}
+
+        print(f"Creating database '{db_title}' with {len(properties)} columns...")
+
+        response = self.create_database(
+            parent_page_id=parent_page_id,
+            database_title=db_title,
+            initial_data_source_properties=properties
+        )
+
+        data_source_id = response.get("initial_data_source", {}).get("id")
+        return data_source_id if data_source_id else response.get("id")

{notionhelper-0.2.3.dist-info → notionhelper-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: notionhelper
-Version: 0.2.3
+Version: 0.3.1
 Summary: NotionHelper is a Python library that simplifies interactions with the Notion API, enabling easy management of databases, pages, and files within Notion workspaces.
 Author-email: Jan du Plessis <drjanduplessis@icloud.com>
 Requires-Python: >=3.10
@@ -27,7 +27,7 @@ Description-Content-Type: text/markdown
 
 # NotionHelper
 
-![NotionHelper](https://github.com/janduplessis883/notionhelper/blob/master/images/helper_logo.png?raw=true)
+![NotionHelper](https://github.com/janduplessis883/notionhelper/blob/master/images/notionh3.png?raw=true)
 
 `NotionHelper` is a Python library that provides a convenient interface for interacting with the Notion API, specifically designed to leverage the **Notion API Version 2025-09-03**. It simplifies common tasks such as managing databases, data sources, pages, and file uploads, allowing you to integrate Notion's powerful features into your applications with ease.
 
@@ -288,6 +288,170 @@ print(f"Successfully attached file to property: {response}")
 
 These methods handle all the intermediate steps automatically, making file operations with Notion much simpler.
 
+### Machine Learning Experiment Tracking
+
+NotionHelper includes specialized functions for tracking machine learning experiments, making it easy to log configurations, metrics, plots, and output files to Notion databases. These functions automatically handle leaderboard tracking and provide a structured way to organize ML workflows.
+
+#### create_ml_database()
+Creates a new Notion database specifically designed for ML experiment tracking by analyzing your config and metrics dictionaries to automatically generate the appropriate schema.
+
+```python
+# Define your typical experiment configuration and metrics
+config = {
+    "Experiment Name": "LSTM Forecast v1",
+    "model_type": "LSTM",
+    "learning_rate": 0.001,
+    "batch_size": 32
+}
+
+metrics = {
+    "sMAPE": 12.5,
+    "MAE": 0.85,
+    "training_time": 45.2
+}
+
+# Create a new ML tracking database
+parent_page_id = "your_parent_page_id"
+data_source_id = helper.create_ml_database(
+    parent_page_id=parent_page_id,
+    db_title="ML Experiments - Time Series",
+    config=config,
+    metrics=metrics,
+    file_property_name="Output Files"  # Optional, defaults to "Output Files"
+)
+print(f"Created ML database with data source ID: {data_source_id}")
+```
+
+The function automatically:
+- Maps numeric values to Number properties
+- Maps booleans to Checkbox properties
+- Maps strings to Rich Text properties
+- Uses the first config key as the Title property
+- Adds a "Run Status" property for tracking improvements
+- Adds a Files & Media property for attaching output files
+
+#### log_ml_experiment()
+Logs a complete ML experiment run including configuration, metrics, plots, and output files. It automatically compares metrics against previous runs to identify improvements and track the best performing models.
+
+```python
+# Experiment configuration
+config = {
+    "Experiment Name": "LSTM Forecast v2",
+    "model_type": "LSTM",
+    "layers": 3,
+    "learning_rate": 0.001,
+    "dropout": 0.2
+}
+
+# Training metrics
+metrics = {
+    "sMAPE": 11.8,
+    "MAE": 0.78,
+    "RMSE": 1.23,
+    "training_time": 52.1
+}
+
+# Paths to plots and output files
+plots = [
+    "path/to/training_loss.png",
+    "path/to/predictions.png"
+]
+
+output_files = [
+    "path/to/model.h5",
+    "path/to/scaler.pkl",
+    "path/to/results.csv"
+]
+
+# Log the experiment
+page_id = helper.log_ml_experiment(
+    data_source_id=data_source_id,
+    config=config,
+    metrics=metrics,
+    plots=plots,  # Will be embedded in page body
+    target_metric="sMAPE",  # Metric to track for improvements
+    higher_is_better=False,  # Lower sMAPE is better
+    file_paths=output_files,  # Will be attached to Files & Media property
+    file_property_name="Output Files"
+)
+print(f"Logged experiment to page: {page_id}")
+```
+
+**Features:**
+- **Automatic Leaderboard Tracking**: Compares new results against previous runs
+- **Champion Detection**: Automatically tags new best scores with 🏆
+- **Performance Comparison**: Shows delta from current best when not improving
+- **Plot Embedding**: Embeds visualization plots directly in the page body
+- **File Attachments**: Attaches model files, scalers, and other outputs
+- **Timestamp Tracking**: Automatically adds timestamps to experiment names
+
+**Run Status Examples:**
+- `🏆 NEW BEST sMAPE (Prev: 12.50)` - New champion found
+- `No Improvement (+0.70 sMAPE)` - Score wasn't better
+- `Standard Run` - First run or metric tracking disabled
+
+#### upload_multiple_files_to_property()
+Uploads multiple files and attaches them all to a single Files & Media property on a page.
+
+```python
+page_id = "your_page_id"
+property_name = "Output Files"
+file_paths = [
+    "path/to/model.h5",
+    "path/to/scaler.pkl",
+    "path/to/predictions.csv"
+]
+
+response = helper.upload_multiple_files_to_property(page_id, property_name, file_paths)
+print(f"Successfully attached {len(file_paths)} files to property")
+```
+
+#### dict_to_notion_props()
+Converts a Python dictionary to Notion property format, handling type conversions automatically.
+
+```python
+data = {
+    "Experiment Name": "Model v1",
+    "accuracy": 0.95,
+    "epochs": 100,
+    "is_best": True
+}
+
+properties = helper.dict_to_notion_props(data, title_key="Experiment Name")
+# Properties are now formatted for Notion API
+```
+
+**Example ML Workflow:**
+
+```python
+# 1. Create ML tracking database (one-time setup)
+data_source_id = helper.create_ml_database(
+    parent_page_id="parent_page_id",
+    db_title="Computer Vision Experiments",
+    config={"Model Name": "ResNet50", "dataset": "ImageNet"},
+    metrics={"accuracy": 0.0, "f1_score": 0.0}
+)
+
+# 2. Run multiple experiments
+for lr in [0.001, 0.01, 0.1]:
+    # Train your model
+    model, metrics, plots = train_model(learning_rate=lr)
+
+    # Log to Notion
+    helper.log_ml_experiment(
+        data_source_id=data_source_id,
+        config={"Model Name": f"ResNet50_lr{lr}", "learning_rate": lr},
+        metrics=metrics,
+        plots=plots,
+        target_metric="accuracy",
+        higher_is_better=True
+    )
+
+# 3. Review results in Notion
+df = helper.get_data_source_pages_as_dataframe(data_source_id)
+print(df[["Model Name", "accuracy", "Run Status"]].sort_values("accuracy", ascending=False))
+```
+
 ## Code Quality
 
 The NotionHelper library includes several quality improvements:
@@ -329,6 +493,12 @@ The `NotionHelper` class provides the following methods:
 - **`one_step_file_to_page(page_id, file_path)`** - Uploads and attaches a file to a page in one operation
 - **`one_step_file_to_page_property(page_id, property_name, file_path, file_name)`** - Uploads and attaches a file to a page property in one operation
 
+### Machine Learning Experiment Tracking
+- **`create_ml_database(parent_page_id, db_title, config, metrics, file_property_name="Output Files")`** - Creates a new Notion database specifically designed for ML experiment tracking with automatic schema generation
+- **`log_ml_experiment(data_source_id, config, metrics, plots=None, target_metric="sMAPE", higher_is_better=False, file_paths=None, file_property_name="Output Files")`** - Logs a complete ML experiment run including configuration, metrics, plots, and output files with automatic leaderboard tracking
+- **`upload_multiple_files_to_property(page_id, property_name, file_paths)`** - Uploads multiple files and attaches them all to a single Files & Media property
+- **`dict_to_notion_props(data, title_key)`** - Converts a Python dictionary to Notion property format with automatic type handling
+
 ## Requirements
 
 - Python 3.10+

notionhelper-0.3.1.dist-info/RECORD

@@ -0,0 +1,5 @@
+notionhelper/__init__.py,sha256=_ShvAiiI4rspEoAjP71AHLPL1wrmcIlDBn0YUSqSMi8,61
+notionhelper/helper.py,sha256=NJdthOSNIqp1ESaDkV-V1Kb2x35LcQlAfG-KTyDnEl8,36279
+notionhelper-0.3.1.dist-info/METADATA,sha256=NcMT0DgyLX096LdLa5UGlUOg184bmGuWT2eiJkwxkGo,19906
+notionhelper-0.3.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+notionhelper-0.3.1.dist-info/RECORD,,

{notionhelper-0.2.3.dist-info → notionhelper-0.3.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

notionhelper/helper1.8.py

@@ -1,546 +0,0 @@
-from typing import Optional, Dict, List, Any
-from notion_client import Client
-import pandas as pd
-import os
-import requests
-import mimetypes
-
-# NotionHelper can be used in conjunction with the Streamlit APP: (Notion API JSON)[https://notioinapiassistant.streamlit.app]
-
-
-class NotionHelper:
-    """
-    A helper class to interact with the Notion API.
-
-    Methods
-    -------
-    __init__():
-        Initializes the NotionHelper instance and authenticates with the Notion API.
-
-    authenticate():
-        Authenticates with the Notion API using a token from environment variables.
-
-    get_database(database_id):
-        Fetches the schema of a Notion database given its database_id.
-
-    notion_search_db(database_id, query=""):
-        Searches for pages in a Notion database that contain the specified query in their title.
-
-    notion_get_page(page_id):
-        Returns the JSON of the page properties and an array of blocks on a Notion page given its page_id.
-
-    create_database(parent_page_id, database_title, properties):
-        Creates a new database in Notion under the specified parent page with the given title and properties.
-
-    new_page_to_db(database_id, page_properties):
-        Adds a new page to a Notion database with the specified properties.
-
-    append_page_body(page_id, blocks):
-        Appends blocks of text to the body of a Notion page.
-
-    get_all_page_ids(database_id):
-        Returns the IDs of all pages in a given Notion database.
-
-    get_all_pages_as_json(database_id, limit=None):
-        Returns a list of JSON objects representing all pages in the given database, with all properties.
-
-    get_all_pages_as_dataframe(database_id, limit=None):
-        Returns a Pandas DataFrame representing all pages in the given database, with selected properties.
-
-    upload_file(file_path):
-        Uploads a file to Notion and returns the file upload object.
-
-    attach_file_to_page(page_id, file_upload_id):
-        Attaches an uploaded file to a specific page.
-
-    embed_image_to_page(page_id, file_upload_id):
-        Embeds an uploaded image to a specific page.
-
-    attach_file_to_page_property(page_id, property_name, file_upload_id, file_name):
-        Attaches a file to a Files & Media property on a specific page.
-    """
-
-    def __init__(self, notion_token: str):
-        """Initializes the NotionHelper instance and authenticates with the Notion API
-        using the provided token."""
-        self.notion_token = notion_token
-        self.notion = Client(auth=self.notion_token)
-
-    def get_database(self, database_id: str) -> Dict[str, Any]:
-        """Retrieves the schema of a Notion database given its database_id.
-
-        Parameters
-        ----------
-        database_id : str
-            The unique identifier of the Notion database.
-
-        Returns
-        -------
-        dict
-            A dictionary representing the database schema.
-        """
-        try:
-            response = self.notion.databases.retrieve(database_id=database_id)
-            return response
-        except Exception as e:
-            raise Exception(f"Failed to retrieve database {database_id}: {str(e)}")
-
-    def notion_search_db(
-        self, database_id: str, query: str = ""
-    ) -> None:
-        """Searches for pages in a Notion database that contain the specified query in their title."""
-        my_pages = self.notion.databases.query(
-            database_id=database_id,
-            filter={
-                "property": "title",
-                "rich_text": {"contains": query},
-            },
-        )
-
-        page_title = my_pages["results"][0]["properties"]["Code / Notebook Description"]["title"][0]["plain_text"]
-        page_url = my_pages["results"][0]["url"]
-
-        page_list = my_pages["results"]
-        count = 1
-        for page in page_list:
-            try:
-                print(
-                    count,
-                    page["properties"]["Code / Notebook Description"]["title"][0]["plain_text"],
-                )
-            except IndexError:
-                print("No results found.")
-
-            print(page["url"])
-            print()
-            count += 1
-
-        # pprint.pprint(page)
-
-    def notion_get_page(self, page_id: str) -> Dict[str, Any]:
-        """Retrieves the JSON of the page properties and an array of blocks on a Notion page given its page_id."""
-
-        # Retrieve the page and block data
-        page = self.notion.pages.retrieve(page_id)
-        blocks = self.notion.blocks.children.list(page_id)
-
-        # Extract all properties as a JSON object
-        properties = page.get("properties", {})
-        content = [block for block in blocks["results"]]
-
-        # Print the full JSON of the properties
-        print(properties)
-
-        # Return the properties JSON and blocks content
-        return {"properties": properties, "content": content}
-
-    def create_database(self, parent_page_id: str, database_title: str, properties: Dict[str, Any]) -> Dict[str, Any]:
-        """Creates a new database in Notion.
-
-        This method creates a new database under a specified parent page with the provided title and property definitions.
-
-        Parameters:
-            parent_page_id (str): The unique identifier of the parent page.
-            database_title (str): The title for the new database.
-            properties (dict): A dictionary defining the property schema for the database.
-
-        Returns:
-            dict: The JSON response from the Notion API containing details about the created database.
-        """
-
-        # Define the properties for the database
-        new_database = {
-            "parent": {"type": "page_id", "page_id": parent_page_id},
-            "title": [{"type": "text", "text": {"content": database_title}}],
-            "properties": properties,
-        }
-
-        response = self.notion.databases.create(**new_database)
-        return response
-
-    def new_page_to_db(self, database_id: str, page_properties: Dict[str, Any]) -> Dict[str, Any]:
-        """Adds a new page to a Notion database."""
-
-        new_page = {
-            "parent": {"database_id": database_id},
-            "properties": page_properties,
-        }
-
-        response = self.notion.pages.create(**new_page)
-        return response
-
-    def append_page_body(self, page_id: str, blocks: List[Dict[str, Any]]) -> Dict[str, Any]:
-        """Appends blocks of text to the body of a Notion page."""
-
-        new_blocks = {"children": blocks}
-
-        response = self.notion.blocks.children.append(block_id=page_id, **new_blocks)
-        return response
-
-    def get_all_page_ids(self, database_id: str) -> List[str]:
-        """Returns the IDs of all pages in a given database."""
-
-        my_pages = self.notion.databases.query(database_id=database_id)
-        page_ids = [page["id"] for page in my_pages["results"]]
-        return page_ids
-
-    def get_all_pages_as_json(self, database_id: str, limit: Optional[int] = None) -> List[Dict[str, Any]]:
-        """Returns a list of JSON objects representing all pages in the given database, with all properties.
-        You can specify the number of entries to be loaded using the `limit` parameter.
-        """
-
-        # Use pagination to remove any limits on number of entries, optionally limited by `limit` argument
-        pages_json = []
-        has_more = True
-        start_cursor = None
-        count = 0
-
-        while has_more:
-            my_pages = self.notion.databases.query(
-                **{
-                    "database_id": database_id,
-                    "start_cursor": start_cursor,
-                }
-            )
-            pages_json.extend([page["properties"] for page in my_pages["results"]])
-            has_more = my_pages.get("has_more", False)
-            start_cursor = my_pages.get("next_cursor", None)
-            count += len(my_pages["results"])
-
-            if limit is not None and count >= limit:
-                pages_json = pages_json[:limit]
-                break
-
-        return pages_json
-
-    def get_all_pages_as_dataframe(self, database_id: str, limit: Optional[int] = None, include_page_ids: bool = True) -> pd.DataFrame:
-        """Retrieves all pages from a Notion database and returns them as a Pandas DataFrame.
-
-        This method collects pages from the specified Notion database, optionally including the page IDs,
-        and extracts a predefined set of allowed properties from each page to form a structured DataFrame.
-        Numeric values are formatted to avoid scientific notation.
-
-        Parameters:
-            database_id (str): The identifier of the Notion database.
-            limit (int, optional): Maximum number of page entries to include. If None, all pages are retrieved.
-            include_page_ids (bool, optional): If True, includes an additional column 'notion_page_id' in the DataFrame.
-                                               Defaults to True.
-
-        Returns:
-            pandas.DataFrame: A DataFrame where each row represents a page with columns corresponding to page properties.
-                              If include_page_ids is True, an additional column 'notion_page_id' is included.
-        """
-        # Retrieve pages with or without page IDs based on the flag
-        if include_page_ids:
-            pages_json = []
-            has_more = True
-            start_cursor = None
-            count = 0
-            # Retrieve pages with pagination including the page ID in properties
-            while has_more:
-                my_pages = self.notion.databases.query(
-                    database_id=database_id,
-                    start_cursor=start_cursor,
-                )
-                for page in my_pages["results"]:
-                    props = page["properties"]
-                    props["notion_page_id"] = page.get("id", "")
-                    pages_json.append(props)
-                has_more = my_pages.get("has_more", False)
-                start_cursor = my_pages.get("next_cursor", None)
-                count += len(my_pages["results"])
-                if limit is not None and count >= limit:
-                    pages_json = pages_json[:limit]
-                    break
-        else:
-            pages_json = self.get_all_pages_as_json(database_id, limit=limit)
-
-        data = []
-        # Define the list of allowed property types that we want to extract
-        allowed_properties = [
-            "title",
-            "status",
-            "number",
-            "date",
-            "url",
-            "checkbox",
-            "rich_text",
-            "email",
-            "select",
-            "people",
-            "phone_number",
-            "multi_select",
-            "created_time",
-            "created_by",
-            "rollup",
-            "relation",
-            "last_edited_by",
-            "last_edited_time",
-            "formula",
-            "file",
-        ]
-        if include_page_ids:
-            allowed_properties.append("notion_page_id")
-
-        for page in pages_json:
-            row = {}
-            for key, value in page.items():
-                if key == "notion_page_id":
-                    row[key] = value
-                    continue
-                property_type = value.get("type", "")
-                if property_type in allowed_properties:
-                    if property_type == "title":
-                        row[key] = value.get("title", [{}])[0].get("plain_text", "")
-                    elif property_type == "status":
-                        row[key] = value.get("status", {}).get("name", "")
-                    elif property_type == "number":
-                        number_value = value.get("number", None)
-                        row[key] = float(number_value) if isinstance(number_value, (int, float)) else None
-                    elif property_type == "date":
-                        date_field = value.get("date", {})
-                        row[key] = date_field.get("start", "") if date_field else ""
-                    elif property_type == "url":
-                        row[key] = value.get("url", "")
-                    elif property_type == "checkbox":
-                        row[key] = value.get("checkbox", False)
-                    elif property_type == "rich_text":
-                        rich_text_field = value.get("rich_text", [])
-                        row[key] = rich_text_field[0].get("plain_text", "") if rich_text_field else ""
-                    elif property_type == "email":
-                        row[key] = value.get("email", "")
-                    elif property_type == "select":
-                        select_field = value.get("select", {})
-                        row[key] = select_field.get("name", "") if select_field else ""
-                    elif property_type == "people":
-                        people_list = value.get("people", [])
-                        if people_list:
-                            person = people_list[0]
-                            row[key] = {"name": person.get("name", ""), "email": person.get("person", {}).get("email", "")}
-                    elif property_type == "phone_number":
-                        row[key] = value.get("phone_number", "")
-                    elif property_type == "multi_select":
-                        multi_select_field = value.get("multi_select", [])
-                        row[key] = [item.get("name", "") for item in multi_select_field]
-                    elif property_type == "created_time":
-                        row[key] = value.get("created_time", "")
-                    elif property_type == "created_by":
-                        created_by = value.get("created_by", {})
-                        row[key] = created_by.get("name", "")
-                    elif property_type == "rollup":
-                        rollup_field = value.get("rollup", {}).get("array", [])
-                        row[key] = [item.get("date", {}).get("start", "") for item in rollup_field]
-                    elif property_type == "relation":
-                        relation_list = value.get("relation", [])
-                        row[key] = [relation.get("id", "") for relation in relation_list]
-                    elif property_type == "last_edited_by":
-                        last_edited_by = value.get("last_edited_by", {})
-                        row[key] = last_edited_by.get("name", "")
-                    elif property_type == "last_edited_time":
-                        row[key] = value.get("last_edited_time", "")
-                    elif property_type == "formula":
-                        formula_value = value.get("formula", {})
-                        row[key] = formula_value.get(formula_value.get("type", ""), "")
-                    elif property_type == "file":
-                        files = value.get("files", [])
-                        row[key] = [file.get("name", "") for file in files]
-            data.append(row)
-
-        df = pd.DataFrame(data)
-        pd.options.display.float_format = "{:.3f}".format
-        return df
-
-    def upload_file(self, file_path: str) -> Dict[str, Any]:
-        """Uploads a file to Notion and returns the file upload object."""
-        if not os.path.exists(file_path):
-            raise FileNotFoundError(f"File not found: {file_path}")
-
-        try:
-            # Step 1: Create a File Upload object
-            create_upload_url = "https://api.notion.com/v1/file_uploads"
-            headers = {
-                "Authorization": f"Bearer {self.notion_token}",
-                "Content-Type": "application/json",
-                "Notion-Version": "2022-06-28",
-            }
-            response = requests.post(create_upload_url, headers=headers, json={})
-            response.raise_for_status()
-            upload_data = response.json()
-            upload_url = upload_data["upload_url"]
-
-            # Step 2: Upload file contents
-            with open(file_path, "rb") as f:
-                upload_headers = {
-                    "Authorization": f"Bearer {self.notion_token}",
-                    "Notion-Version": "2022-06-28",
-                }
-                files = {'file': (os.path.basename(file_path), f, mimetypes.guess_type(file_path)[0] or 'application/octet-stream')}
-                upload_response = requests.post(upload_url, headers=upload_headers, files=files)
-                upload_response.raise_for_status()
-
-            return upload_response.json()
-        except requests.RequestException as e:
-            raise Exception(f"Failed to upload file {file_path}: {str(e)}")
-        except Exception as e:
-            raise Exception(f"Error uploading file {file_path}: {str(e)}")
-
-    def attach_file_to_page(self, page_id: str, file_upload_id: str) -> Dict[str, Any]:
-        """Attaches an uploaded file to a specific page."""
-        attach_url = f"https://api.notion.com/v1/blocks/{page_id}/children"
-        headers = {
-            "Authorization": f"Bearer {self.notion_token}",
-            "Content-Type": "application/json",
-            "Notion-Version": "2022-06-28",
-        }
-        data = {
-            "children": [
-                {
-                    "type": "file",
-                    "file": {
-                        "type": "file_upload",
-                        "file_upload": {
-                            "id": file_upload_id
-                        }
-                    }
-                }
-            ]
-        }
-        response = requests.patch(attach_url, headers=headers, json=data)
-        return response.json()
-
-    def embed_image_to_page(self, page_id: str, file_upload_id: str) -> Dict[str, Any]:
-        """Embeds an uploaded image to a specific page."""
-        attach_url = f"https://api.notion.com/v1/blocks/{page_id}/children"
-        headers = {
-            "Authorization": f"Bearer {self.notion_token}",
-            "Content-Type": "application/json",
-            "Notion-Version": "2022-06-28",
-        }
-        data = {
-            "children": [
-                {
-                    "type": "image",
-                    "image": {
-                        "type": "file_upload",
-                        "file_upload": {
-                            "id": file_upload_id
-                        }
-                    }
-                }
-            ]
-        }
-        response = requests.patch(attach_url, headers=headers, json=data)
-        return response.json()
-
-    def attach_file_to_page_property(
-        self, page_id: str, property_name: str, file_upload_id: str, file_name: str
-    ) -> Dict[str, Any]:
-        """Attaches a file to a Files & Media property on a specific page."""
-        update_url = f"https://api.notion.com/v1/pages/{page_id}"
-        headers = {
-            "Authorization": f"Bearer {self.notion_token}",
-            "Content-Type": "application/json",
-            "Notion-Version": "2022-06-28",
-        }
-        data = {
-            "properties": {
-                property_name: {
-                    "files": [
-                        {
-                            "type": "file_upload",
-                            "file_upload": {"id": file_upload_id},
-                            "name": file_name,
-                        }
-                    ]
-                }
-            }
-        }
-        response = requests.patch(update_url, headers=headers, json=data)
-        return response.json()
-
-    def one_step_image_embed(self, page_id: str, file_path: str) -> Dict[str, Any]:
-        """Uploads an image and embeds it in a Notion page in one step."""
-
-        # Upload the file
-        file_upload = self.upload_file(file_path)
-        file_upload_id = file_upload["id"]
-
-        # Embed the image in the page
-        return self.embed_image_to_page(page_id, file_upload_id)
-
-    def one_step_file_to_page(self, page_id: str, file_path: str) -> Dict[str, Any]:
-        """Uploads a file and attaches it to a Notion page in one step."""
-
-        # Upload the file
-        file_upload = self.upload_file(file_path)
-        file_upload_id = file_upload["id"]
-
-        # Attach the file to the page
-        return self.attach_file_to_page(page_id, file_upload_id)
-
-    def one_step_file_to_page_property(self, page_id: str, property_name: str, file_path: str, file_name: str) -> Dict[str, Any]:
-        """Uploads a file and attaches it to a Notion page property in one step."""
-
-        # Upload the file
-        file_upload = self.upload_file(file_path)
-        file_upload_id = file_upload["id"]
-
-        # Attach the file to the page property
-        return self.attach_file_to_page_property(page_id, property_name, file_upload_id, file_name)
-
-    def info(self) -> Optional[Any]:
-        """Displays comprehensive library information in a Jupyter notebook.
-
-        Shows:
-        - Library name and description
-        - Complete list of all available methods with descriptions
-        - Version information
-        - Optional logo display (if available)
-
-        Returns:
-            IPython.display.HTML: An HTML display object or None if IPython is not available.
-        """
-        try:
-            from IPython.display import HTML
-            import base64
-            import inspect
-
-            # Get logo image data
-            logo_path = os.path.join(os.path.dirname(__file__), '../images/helper_logo.png')
-            if os.path.exists(logo_path):
-                with open(logo_path, "rb") as image_file:
-                    encoded_logo = base64.b64encode(image_file.read()).decode('utf-8')
-            else:
-                encoded_logo = ""
-
-            # Get all methods and their docstrings
-            methods = []
-            for name, method in inspect.getmembers(self, predicate=inspect.ismethod):
-                if not name.startswith('_'):
-                    doc = inspect.getdoc(method) or "No description available"
-                    methods.append(f"<li><code>{name}()</code>: {doc.splitlines()[0]}</li>")
-
-            # Create HTML content
-            html_content = f"""
-            <div style="font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif; max-width: 800px; margin: 0 auto; color: #1e293b;">
-                <h1 style="color: #1e293b;">NotionHelper Library</h1>
-                {f'<img src="data:image/png;base64,{encoded_logo}" style="max-width: 200px; margin: 20px 0; display: block;">' if encoded_logo else ''}
-                <p style="font-size: 1.1rem;">A Python helper class for interacting with the Notion API.</p>
-                <h3 style="color: #1e293b;">All Available Methods:</h3>
-                <ul style="list-style-type: none; padding-left: 0;">
-                    {''.join(methods)}
-                </ul>
-                <h3 style="color: #1e293b;">Features:</h3>
-                <ul style="list-style-type: none; padding-left: 0;">
-                    <li style="margin-bottom: 8px;">Database querying and manipulation</li>
-                    <li style="margin-bottom: 8px;">Page creation and editing</li>
-                    <li style="margin-bottom: 8px;">File uploads and attachments</li>
-                    <li style="margin-bottom: 8px;">Data conversion to Pandas DataFrames</li>
-                </ul>
-                <p style="font-size: 0.9rem; color: #64748b;">Version: {getattr(self, '__version__', '1.0.0')}</p>
-            </div>
-            """
-            return HTML(html_content)
-        except ImportError:
-            print("IPython is required for this functionality. Please install it with: pip install ipython")
-            return None

notionhelper-0.2.3.dist-info/RECORD

@@ -1,6 +0,0 @@
-notionhelper/__init__.py,sha256=_ShvAiiI4rspEoAjP71AHLPL1wrmcIlDBn0YUSqSMi8,61
-notionhelper/helper.py,sha256=WwiyRk3rvrcUg9w0HMIXHm5AKQBwh6yhlVx6wueiv_o,27181
-notionhelper/helper1.8.py,sha256=ubR55j97JDduxVipe3yBqHMWfVO9EKhe48ZWCPOq938,23456
-notionhelper-0.2.3.dist-info/METADATA,sha256=tizGtzPAzxQIcsJx5K6eUzamHsWh1QF8wMaEXa3_lnI,13892
-notionhelper-0.2.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-notionhelper-0.2.3.dist-info/RECORD,,