diaspora-event-sdk 0.4.3__py3-none-any.whl → 0.4.5__py3-none-any.whl

diaspora_event_sdk/__init__.py

@@ -9,10 +9,12 @@ from diaspora_event_sdk.sdk.client import Client
 from diaspora_event_sdk.sdk.kafka_client import (
     KafkaProducer,
     KafkaConsumer,
+    reliable_client_creation,
 )
 
 __all__ = (
     "Client",
     "KafkaProducer",
     "KafkaConsumer",
+    "reliable_client_creation",
 )

diaspora_event_sdk/examples/DiasporaDemoV3.ipynb

@@ -0,0 +1,200 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Setup\n",
+    "%pip install -e '.[kafka-python]'\n",
+    "\n",
+    "import json\n",
+    "import uuid\n",
+    "from datetime import datetime\n",
+    "from diaspora_event_sdk import Client as GlobusClient\n",
+    "from diaspora_event_sdk.sdk.kafka_client import KafkaProducer, KafkaConsumer\n",
+    "\n",
+    "# os.environ[\"DIASPORA_SDK_ENVIRONMENT\"] = \"local\"\n",
+    "c = GlobusClient()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Display current user subject\n",
+    "print(f\"Current user subject: {c.subject_openid}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 1. Create User\n",
+    "user_result = c.create_user()\n",
+    "print(json.dumps(user_result, indent=2, default=str))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Display namespace (automatically computed from subject)\n",
+    "print(f\"Using namespace: {c.namespace}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 2. Create Key\n",
+    "key_result = c.create_key()\n",
+    "print(json.dumps(key_result, indent=2, default=str))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 3. List namespaces\n",
+    "namespaces_result = c.list_namespaces()\n",
+    "print(json.dumps(namespaces_result, indent=2, default=str))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 4. Create Topic\n",
+    "topic_name = f\"topic-{str(uuid.uuid4())[:5]}\"\n",
+    "create_topic_result = c.create_topic(topic_name)\n",
+    "print(json.dumps(create_topic_result, indent=2, default=str))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Kafka topic name format: \"{namespace}.{topic}\"\n",
+    "kafka_topic = f\"{c.namespace}.{topic_name}\"\n",
+    "print(f\"Kafka topic name: {kafka_topic}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 5. Produce Messages\n",
+    "p = KafkaProducer(kafka_topic)\n",
+    "for i in range(3):\n",
+    "    message = {\n",
+    "        \"message_id\": i + 1,\n",
+    "        \"timestamp\": datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\"),\n",
+    "        \"content\": f\"Message {i + 1} from v3 API\",\n",
+    "    }\n",
+    "    future = p.send(kafka_topic, message)\n",
+    "    result = future.get(timeout=30)\n",
+    "    print(f\"Produced message {i + 1}: offset={result.offset}\")\n",
+    "p.close()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 6. Consume Messages\n",
+    "consumer = KafkaConsumer(kafka_topic, auto_offset_reset=\"earliest\")\n",
+    "messages = consumer.poll(timeout_ms=10000)\n",
+    "for tp, msgs in messages.items():\n",
+    "    for message in msgs:\n",
+    "        data = json.loads(message.value.decode(\"utf-8\"))\n",
+    "        print(f\"Consumed: {data}\")\n",
+    "consumer.close()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 7. Recreate Topic\n",
+    "recreate_result = c.recreate_topic(topic_name)\n",
+    "print(json.dumps(recreate_result, indent=2, default=str))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 8. Delete Topic\n",
+    "delete_topic_result = c.delete_topic(topic_name)\n",
+    "print(json.dumps(delete_topic_result, indent=2, default=str))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 9. Delete Key\n",
+    "delete_key_result = c.delete_key()\n",
+    "print(json.dumps(delete_key_result, indent=2, default=str))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 10. Delete User\n",
+    "delete_user_result = c.delete_user()\n",
+    "print(json.dumps(delete_user_result, indent=2, default=str))"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.14.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

diaspora_event_sdk/examples/__init__.py

@@ -0,0 +1,2 @@
+# Example files for diaspora-event-sdk
+# This directory contains example scripts and notebooks demonstrating SDK usage

diaspora_event_sdk/examples/reliable_client_creation_examples.ipynb

@@ -0,0 +1,157 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Install dependencies\n",
+    "%pip install -e '.[kafka-python]'\n",
+    "\n",
+    "# Import the reliable topic creation functions\n",
+    "from diaspora_event_sdk.sdk.kafka_client import (\n",
+    "    reliable_client_creation,\n",
+    "    KafkaProducer,\n",
+    "    KafkaConsumer,\n",
+    ")\n",
+    "from diaspora_event_sdk import Client as GlobusClient\n",
+    "import json\n",
+    "import uuid\n",
+    "import time\n",
+    "from datetime import datetime\n",
+    "\n",
+    "# Initialize client\n",
+    "# os.environ[\"DIASPORA_SDK_ENVIRONMENT\"] = \"local\"\n",
+    "c = GlobusClient()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Run reliable_client_creation to set up client and test basic flow\n",
+    "reliable_client_creation()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Function to randomly create a topic, produce, and consume messages\n",
+    "def random_topic_produce_consume():\n",
+    "    \"\"\"Create a random topic, produce 3 messages, and consume them.\"\"\"\n",
+    "    topic_name = f\"topic-{str(uuid.uuid4())[:5]}\"\n",
+    "    kafka_topic = f\"{c.namespace}.{topic_name}\"\n",
+    "\n",
+    "    print(f\"\\n{'=' * 60}\")\n",
+    "    print(f\"Creating topic: {topic_name}\")\n",
+    "    print(f\"Kafka topic: {kafka_topic}\")\n",
+    "    print(f\"{'=' * 60}\")\n",
+    "\n",
+    "    # Create topic\n",
+    "    topic_result = c.create_topic(topic_name)\n",
+    "    print(f\"Topic creation: {json.dumps(topic_result, indent=2, default=str)}\")\n",
+    "\n",
+    "    if topic_result.get(\"status\") != \"success\":\n",
+    "        print(f\"Failed to create topic: {topic_result}\")\n",
+    "        return None\n",
+    "\n",
+    "    time.sleep(3)  # Wait for topic to be ready\n",
+    "\n",
+    "    # Produce messages\n",
+    "    print(f\"\\nProducing 3 messages to {kafka_topic}...\")\n",
+    "    producer = KafkaProducer(kafka_topic)\n",
+    "    for i in range(3):\n",
+    "        message = {\n",
+    "            \"message_id\": i + 1,\n",
+    "            \"timestamp\": datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\"),\n",
+    "            \"content\": f\"Message {i + 1} from random_topic_produce_consume\",\n",
+    "        }\n",
+    "        future = producer.send(kafka_topic, message)\n",
+    "        result = future.get(timeout=30)\n",
+    "        print(f\"  Produced message {i + 1}: offset={result.offset}\")\n",
+    "    producer.close()\n",
+    "\n",
+    "    time.sleep(2)  # Wait before consuming\n",
+    "\n",
+    "    # Consume messages\n",
+    "    print(f\"\\nConsuming messages from {kafka_topic}...\")\n",
+    "    consumer = KafkaConsumer(kafka_topic, auto_offset_reset=\"earliest\")\n",
+    "    messages = consumer.poll(timeout_ms=10000)\n",
+    "    consumed_count = 0\n",
+    "    for tp, msgs in messages.items():\n",
+    "        for message in msgs:\n",
+    "            data = json.loads(message.value.decode(\"utf-8\"))\n",
+    "            consumed_count += 1\n",
+    "            print(f\"  Consumed message {consumed_count}: {data}\")\n",
+    "    consumer.close()\n",
+    "    print(f\"\\nTotal messages consumed: {consumed_count}\")\n",
+    "\n",
+    "    # Delete topic\n",
+    "    print(f\"\\nDeleting topic {topic_name}...\")\n",
+    "    delete_result = c.delete_topic(topic_name)\n",
+    "    print(f\"Topic deletion: {json.dumps(delete_result, indent=2, default=str)}\")\n",
+    "\n",
+    "    return kafka_topic\n",
+    "\n",
+    "\n",
+    "# Call the function three times\n",
+    "for i in range(5):\n",
+    "    print(f\"\\n\\n{'#' * 60}\")\n",
+    "    print(f\"# Iteration {i + 1} of 5\")\n",
+    "    print(f\"{'#' * 60}\")\n",
+    "    result = random_topic_produce_consume()\n",
+    "    if result:\n",
+    "        print(f\"✓ Successfully completed iteration {i + 1}: {result}\")\n",
+    "    else:\n",
+    "        print(f\"✗ Failed iteration {i + 1}\")\n",
+    "    if i < 2:  # Don't sleep after last iteration\n",
+    "        time.sleep(2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Cleanup: Delete user at the end\n",
+    "print(f\"\\n{'=' * 60}\")\n",
+    "print(\"Cleaning up: Deleting user...\")\n",
+    "print(f\"{'=' * 60}\")\n",
+    "delete_user_result = c.delete_user()\n",
+    "print(f\"User deletion: {json.dumps(delete_user_result, indent=2, default=str)}\")\n",
+    "if delete_user_result.get(\"status\") == \"success\":\n",
+    "    print(\"✓ User successfully deleted\")\n",
+    "else:\n",
+    "    print(f\"✗ Failed to delete user: {delete_user_result}\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.14.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

diaspora_event_sdk/examples/reliable_client_creation_examples.py

@@ -0,0 +1,274 @@
+"""
+Reliable Client Creation Examples
+
+This script demonstrates reliable client creation and basic Kafka operations
+including topic creation, message production, and consumption.
+"""
+
+# Install dependencies
+# Run: pip install -e '.[kafka-python]'
+
+# Import the reliable topic creation functions
+from diaspora_event_sdk.sdk.kafka_client import (
+    reliable_client_creation,
+    KafkaProducer,
+    KafkaConsumer,
+)
+from diaspora_event_sdk import Client as GlobusClient
+from kafka.errors import KafkaTimeoutError
+import uuid
+import time
+import argparse
+import traceback
+import os
+from datetime import datetime
+
+# Configure logging to show INFO level messages from kafka_client
+# logging.basicConfig(
+#     level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+# )
+
+
+def reliable_produce(namespace, topic, num_messages=3, max_retries=3):
+    """Produce messages to a topic with retry logic for timeout errors.
+
+    Args:
+        namespace: The namespace for the topic
+        topic: The topic name (without namespace prefix)
+        num_messages: Number of messages to produce (default: 3)
+        max_retries: Maximum number of retries on timeout (default: 3)
+
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    kafka_topic = f"{namespace}.{topic}"
+
+    for attempt in range(max_retries):
+        producer = None
+        try:
+            if attempt > 0:
+                print(f"    Retry {attempt + 1}/{max_retries}")
+            producer = KafkaProducer(kafka_topic)
+            for i in range(num_messages):
+                message = {
+                    "message_id": i + 1,
+                    "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                    "content": f"Message {i + 1} from reliable_produce",
+                }
+                future = producer.send(kafka_topic, message)
+                print(f"    Sending message {i + 1}/{num_messages}...")
+                future.get(timeout=30)
+            return True
+        except KafkaTimeoutError:
+            if attempt < max_retries - 1:
+                time.sleep(2)  # Wait before retry
+            else:
+                print(f"✗ Produce failed after {max_retries} attempts")
+                return False
+        except Exception as e:
+            print(f"✗ Produce error: {e}")
+            return False
+        finally:
+            if producer is not None:
+                try:
+                    producer.close(timeout=1)
+                except Exception:
+                    # Ignore errors during cleanup to avoid "Exception ignored" warnings
+                    pass
+
+    return False
+
+
+def reliable_consume(namespace, topic, max_retries=3):
+    """Consume messages from a topic with retry logic for timeout errors.
+
+    Args:
+        namespace: The namespace for the topic
+        topic: The topic name (without namespace prefix)
+        max_retries: Maximum number of retries on timeout (default: 3)
+
+    Returns:
+        tuple: (success: bool, consumed_count: int)
+    """
+    kafka_topic = f"{namespace}.{topic}"
+
+    for attempt in range(max_retries):
+        consumer = None
+        try:
+            if attempt > 0:
+                print(f"    Retry {attempt + 1}/{max_retries}")
+            print("    Polling for messages...")
+            consumer = KafkaConsumer(kafka_topic, auto_offset_reset="earliest")
+            messages = consumer.poll(timeout_ms=10000)
+            consumed_count = 0
+            for tp, msgs in messages.items():
+                for message in msgs:
+                    consumed_count += 1
+            return True, consumed_count
+        except KafkaTimeoutError:
+            if attempt < max_retries - 1:
+                time.sleep(2)  # Wait before retry
+            else:
+                print(f"✗ Consume failed after {max_retries} attempts")
+                return False, 0
+        except Exception as e:
+            print(f"✗ Consume error: {e}")
+            return False, 0
+        finally:
+            if consumer is not None:
+                try:
+                    consumer.close()
+                except Exception:
+                    # Ignore errors during cleanup to avoid "Exception ignored" warnings
+                    pass
+
+    return False, 0
+
+
+def run_produce_consume_cycle(produce_consumer_per_iteration=1):
+    """Run the reliable client creation examples with produce/consume cycles.
+
+    Args:
+        produce_consumer_per_iteration: Number of times to run the topic produce/consume cycle
+
+    Returns:
+        tuple: (success: bool, log_file: str or None)
+    """
+    try:
+        # Initialize client
+        # os.environ["DIASPORA_SDK_ENVIRONMENT"] = "local"
+        c = GlobusClient()
+
+        # Run reliable_client_creation to set up client and test basic flow
+        print("  → reliable_client_creation()")
+        reliable_client_creation()
+
+        # Run produce/consume cycles
+        for i in range(produce_consumer_per_iteration):
+            print(f"Iteration {i + 1}/{produce_consumer_per_iteration}")
+
+            # Create topic
+            topic_name = f"topic-{str(uuid.uuid4())[:5]}"
+            print("  → create_topic()")
+            topic_result = c.create_topic(topic_name)
+
+            if topic_result.get("status") != "success":
+                print("✗ Failed to create topic")
+                continue
+
+            time.sleep(3)  # Wait for topic to be ready
+
+            # Produce messages with retry logic
+            print("  → reliable_produce()")
+            produce_success = reliable_produce(c.namespace, topic_name)
+
+            time.sleep(2)  # Wait before consuming
+
+            # Consume messages with retry logic
+            print("  → reliable_consume()")
+            consume_success, consumed_count = reliable_consume(c.namespace, topic_name)
+
+            # Delete topic
+            print("  → delete_topic()")
+            c.delete_topic(topic_name)
+
+            if produce_success and consume_success:
+                print(f"✓ Iteration {i + 1} completed")
+            else:
+                print(f"✗ Iteration {i + 1} failed")
+
+            if (
+                i < produce_consumer_per_iteration - 1
+            ):  # Don't sleep after last iteration
+                time.sleep(2)
+
+        # Cleanup: Delete user at the end
+        print("  → delete_user()")
+        delete_user_result = c.delete_user()
+        if delete_user_result.get("status") != "success":
+            print("✗ Failed to delete user")
+
+        return True, None
+    except Exception as e:
+        # Get the script directory for log file
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        log_filename = os.path.join(
+            script_dir, f"error_log_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
+        )
+
+        # Get full traceback
+        full_traceback = traceback.format_exc()
+
+        # Write to log file
+        with open(log_filename, "w") as log_file:
+            log_file.write(
+                f"Exception occurred at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
+            )
+            log_file.write(f"{'=' * 80}\n")
+            log_file.write(f"Exception type: {type(e).__name__}\n")
+            log_file.write(f"Exception message: {str(e)}\n")
+            log_file.write(f"{'=' * 80}\n")
+            log_file.write("Full traceback:\n")
+            log_file.write(full_traceback)
+
+        print(f"✗ Exception: {type(e).__name__}: {str(e)}")
+        print(f"Log: {log_filename}")
+
+        return False, log_filename
+
+
+def main():
+    """Main entry point for the script."""
+    parser = argparse.ArgumentParser(
+        description="Reliable client creation examples with configurable iterations"
+    )
+    parser.add_argument(
+        "--produce-consumer-per-iteration",
+        type=int,
+        default=1,
+        help="Number of topic produce/consume cycles to run per main() call (default: 1)",
+    )
+    parser.add_argument(
+        "--iterations",
+        type=int,
+        default=3,
+        help="Number of times to call main() (default: 3)",
+    )
+    args = parser.parse_args()
+
+    # Track statistics
+    successful_runs = 0
+    failed_runs = 0
+    log_files = []
+
+    try:
+        for i in range(args.iterations):
+            print(f"\nRun {i + 1}/{args.iterations}")
+            success, log_file = run_produce_consume_cycle(
+                produce_consumer_per_iteration=args.produce_consumer_per_iteration
+            )
+            if success:
+                successful_runs += 1
+            else:
+                failed_runs += 1
+                if log_file:
+                    log_files.append(log_file)
+            if i < args.iterations - 1:  # Don't sleep after last iteration
+                time.sleep(1)
+    except KeyboardInterrupt:
+        print(f"\n\nInterrupted by user after {successful_runs + failed_runs} runs")
+
+    # Print final statistics
+    print("\nFINAL STATISTICS")
+    print(f"Successfully completed runs: {successful_runs}")
+    print(f"Failed runs: {failed_runs}")
+    print(f"Total runs: {successful_runs + failed_runs}")
+
+    if log_files:
+        print(f"\nError log files ({len(log_files)}):")
+        for log_file in log_files:
+            print(f"  {log_file}")
+
+
+if __name__ == "__main__":
+    main()

diaspora_event_sdk/version.py

@@ -1 +1 @@
-__version__ = "0.4.3"
+__version__ = "0.4.5"

{diaspora_event_sdk-0.4.3.dist-info → diaspora_event_sdk-0.4.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diaspora-event-sdk
-Version: 0.4.3
+Version: 0.4.5
 Summary: Diaspora Event Fabric SDK
 Home-page: https://github.com/globus-labs/diaspora-event-sdk
 License: Apache 2.0

{diaspora_event_sdk-0.4.3.dist-info → diaspora_event_sdk-0.4.5.dist-info}/RECORD

@@ -1,5 +1,9 @@
-diaspora_event_sdk/__init__.py,sha256=Tayc-lBVFUjkbs-Qvxg_J6vBM0Mhl4yhef53cdkUoPI,426
-diaspora_event_sdk/version.py,sha256=Nyg0pmk5ea9-SLCAFEIF96ByFx4-TJFtrqYPN-Zn6g4,22
+diaspora_event_sdk/__init__.py,sha256=cG6QpFi8zovqhNJpAxGapvpsAkqDSgsZp6UvdJEf9-o,488
+diaspora_event_sdk/version.py,sha256=ErkLkI2TDBX1OIqi2GGa20CPeu4ZculEi-XffRbLU6M,22
+diaspora_event_sdk/examples/DiasporaDemoV3.ipynb,sha256=8neyMEHmmnsQiZ9bg4D8rppjO5ySL10MGN6RrhV--bM,4933
+diaspora_event_sdk/examples/__init__.py,sha256=YvOs49nXFDTfksweZMUFso-o7vzBuYlOP7aH1OFKn1o,119
+diaspora_event_sdk/examples/reliable_client_creation_examples.ipynb,sha256=8zxo2YKzDM18wuzGvxTinD7Rj8xfOaKTVmMaucSagxU,5288
+diaspora_event_sdk/examples/reliable_client_creation_examples.py,sha256=TId8n6OMdpDq90Dtp9NvP_t_3X4loczcE-uaxd1AT8M,9245
 diaspora_event_sdk/sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 diaspora_event_sdk/sdk/_environments.py,sha256=zuvyoMtGsUA3J0GI92NBn-z_1J4GbiE7WaUgKe8-dpI,501
 diaspora_event_sdk/sdk/aws_iam_msk.py,sha256=9fPH7lgdfZhxKohdZE7shGPYIA4-X-XRbA5KdY-Agjo,3933
@@ -24,10 +28,10 @@ diaspora_event_sdk/sdk/login_manager/protocol.py,sha256=ipAOUi7GYF5YfU-az1LWUbU_
 diaspora_event_sdk/sdk/login_manager/tokenstore.py,sha256=ImncC8EIxoAuGtDiZIwdtUgOD2fWo8oBP22G-fiZ5L4,2036
 diaspora_event_sdk/sdk/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 diaspora_event_sdk/sdk/utils/uuid_like.py,sha256=xbxf0YXpDhdii16lwPLWRN21qFekHrNrqODSToMPtCg,470
-diaspora_event_sdk-0.4.3.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+diaspora_event_sdk-0.4.5.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/unit/apis_test.py,sha256=x9Pd8Ss2COtXk7nKez4wHw0-Xp7GDeJT9bIWXJ1K5GQ,9140
-diaspora_event_sdk-0.4.3.dist-info/METADATA,sha256=xbh2IbvzvA9GzImKof6slxSVw2E0OGe524Tcf1hEbI8,3828
-diaspora_event_sdk-0.4.3.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-diaspora_event_sdk-0.4.3.dist-info/top_level.txt,sha256=OVun-67t3fkLFEIwvJuNINgFFvAc--bClYhXjLhMmvs,25
-diaspora_event_sdk-0.4.3.dist-info/RECORD,,
+diaspora_event_sdk-0.4.5.dist-info/METADATA,sha256=ClPsc9oyLw_ZcxsBwICSY43-lmRC_PWu0VZb_WJXVCI,3828
+diaspora_event_sdk-0.4.5.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+diaspora_event_sdk-0.4.5.dist-info/top_level.txt,sha256=OVun-67t3fkLFEIwvJuNINgFFvAc--bClYhXjLhMmvs,25
+diaspora_event_sdk-0.4.5.dist-info/RECORD,,