diaspora-event-sdk 0.4.1__tar.gz → 0.4.4__tar.gz

{diaspora-event-sdk-0.4.1/diaspora_event_sdk.egg-info → diaspora_event_sdk-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: diaspora-event-sdk
-Version: 0.4.1
+Version: 0.4.4
 Summary: Diaspora Event Fabric SDK
 Home-page: https://github.com/globus-labs/diaspora-event-sdk
 License: Apache 2.0
@@ -15,9 +15,27 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: globus-sdk<4,>=3.59.0
 Provides-Extra: kafka-python
+Requires-Dist: kafka-python; extra == "kafka-python"
 Provides-Extra: test
-License-File: LICENSE
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: coverage; extra == "test"
+Requires-Dist: mypy; extra == "test"
+Requires-Dist: tox; extra == "test"
+Requires-Dist: check-manifest; extra == "test"
+Requires-Dist: pre-commit; extra == "test"
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
 
 # Diaspora Event Fabric SDK
 

{diaspora-event-sdk-0.4.1 → diaspora_event_sdk-0.4.4}/diaspora_event_sdk/__init__.py

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

{diaspora-event-sdk-0.4.1 → diaspora_event_sdk-0.4.4}/diaspora_event_sdk/sdk/_environments.py

@@ -13,9 +13,7 @@ def get_web_service_url(envname: Union[str, None] = None) -> str:
     env = envname or _get_envname()
     urls = {
         "production": "https://diaspora-web-service.qpp943wkvr7b2.us-east-1.cs.amazonlightsail.com/",
-        "dev": "https://diaspora-web-service.qpp943wkvr7b2.us-east-1.cs.amazonlightsail.com/",
         "local": "http://localhost:8000",
-        "legacy": "https://diaspora-web-service-dev.ml22sevubfnks.us-east-1.cs.amazonlightsail.com",
     }
 
     return urls.get(env, urls["production"])

diaspora_event_sdk-0.4.4/diaspora_event_sdk/sdk/client.py

@@ -0,0 +1,113 @@
+from typing import Optional
+
+from diaspora_event_sdk.sdk.login_manager import (
+    LoginManager,
+    LoginManagerProtocol,
+    requires_login,
+)
+
+from ._environments import get_web_service_url
+
+
+class Client:
+    def __init__(
+        self,
+        environment: Optional[str] = None,
+        login_manager: Optional[LoginManagerProtocol] = None,
+    ):
+        self.web_service_address = get_web_service_url(environment)
+
+        # if a login manager was passed, no login flow is triggered
+        if login_manager is not None:
+            self.login_manager: LoginManagerProtocol = login_manager
+        # but if login handling is implicit (as when no login manager is passed)
+        # then ensure that the user is logged in
+        else:
+            self.login_manager = LoginManager(environment=environment)
+            self.login_manager.ensure_logged_in()
+
+        self.web_client = self.login_manager.get_web_client(
+            base_url=self.web_service_address
+        )
+        self.auth_client = self.login_manager.get_auth_client()
+        self.subject_openid = self.auth_client.userinfo()["sub"]
+        self.namespace = f"ns-{self.subject_openid.replace('-', '')[-12:]}"
+
+    def logout(self):
+        """Remove credentials from your local system"""
+        self.login_manager.logout()
+
+    @requires_login
+    def create_user(self):
+        """
+        Create an IAM user with policy and namespace for the current user (POST /api/v3/user).
+        Returns status, message, subject, and namespace.
+        """
+        resp = self.web_client.create_user(self.subject_openid)
+        return resp.data if hasattr(resp, "data") else resp
+
+    @requires_login
+    def delete_user(self):
+        """
+        Delete the IAM user and all associated resources for the current user (DELETE /api/v3/user).
+        Returns status and message.
+        """
+        resp = self.web_client.delete_user(self.subject_openid)
+        return resp.data if hasattr(resp, "data") else resp
+
+    @requires_login
+    def create_key(self):
+        """
+        Create a new access key for the current user (POST /api/v3/key).
+        This will replace any existing access key (force refresh).
+        Returns status, message, access_key, secret_key, and create_date.
+        """
+        resp = self.web_client.create_key(self.subject_openid)
+        return resp.data if hasattr(resp, "data") else resp
+
+    @requires_login
+    def delete_key(self):
+        """
+        Delete access keys from IAM and DynamoDB for the current user (DELETE /api/v3/key).
+        Returns status and message.
+        """
+        resp = self.web_client.delete_key(self.subject_openid)
+        return resp.data if hasattr(resp, "data") else resp
+
+    @requires_login
+    def list_namespaces(self):
+        """
+        List all namespaces owned by the current user and their topics (GET /api/v3/namespace).
+        Returns status, message, and namespaces dict (namespace -> list of topics).
+        """
+        resp = self.web_client.list_namespaces(self.subject_openid)
+        return resp.data if hasattr(resp, "data") else resp
+
+    @requires_login
+    def create_topic(self, topic: str):
+        """
+        Create a topic under the user's default namespace (POST /api/v3/{namespace}/{topic}).
+        Returns status, message, and topics list.
+        """
+        resp = self.web_client.create_topic(self.subject_openid, self.namespace, topic)
+        return resp.data if hasattr(resp, "data") else resp
+
+    @requires_login
+    def delete_topic(self, topic: str):
+        """
+        Delete a topic from the user's default namespace (DELETE /api/v3/{namespace}/{topic}).
+        Returns status, message, and topics list.
+        """
+        resp = self.web_client.delete_topic(self.subject_openid, self.namespace, topic)
+        return resp.data if hasattr(resp, "data") else resp
+
+    @requires_login
+    def recreate_topic(self, topic: str):
+        """
+        Recreate a topic in the user's default namespace by deleting and recreating it (PUT /api/v3/{namespace}/{topic}/recreate).
+        Returns status and message.
+        """
+        resp = self.web_client.recreate_topic(
+            self.subject_openid, self.namespace, topic
+        )
+        return resp.data if hasattr(resp, "data") else resp

diaspora_event_sdk-0.4.4/diaspora_event_sdk/sdk/kafka_client.py

@@ -0,0 +1,182 @@
+import json
+import logging
+import time
+import uuid
+import warnings
+from typing import Any, Dict
+
+from .aws_iam_msk import generate_auth_token
+from .client import Client
+
+# File-level logger
+logger = logging.getLogger(__name__)
+
+# If kafka-python is not installed, Kafka functionality is not available through diaspora-event-sdk.
+kafka_available = True
+try:
+    import os
+
+    from kafka import KafkaConsumer as KCons  # type: ignore[import,import-not-found]
+    from kafka import KafkaProducer as KProd  # type: ignore[import,import-not-found]
+    from kafka.errors import KafkaTimeoutError, TopicAuthorizationFailedError  # type: ignore[import,import-not-found]
+    from kafka.sasl.oauth import (
+        AbstractTokenProvider,  # type: ignore[import,import-not-found]
+    )
+
+    class MSKTokenProvider(AbstractTokenProvider):
+        def token(self):
+            token, _ = generate_auth_token("us-east-1")
+            return token
+except Exception:
+    kafka_available = False
+    # Fallback if kafka-python is not available
+    TopicAuthorizationFailedError = Exception
+    KafkaTimeoutError = Exception
+
+
+def get_diaspora_config(extra_configs: Dict[str, Any] = {}) -> Dict[str, Any]:
+    """
+    Retrieve default Diaspora event fabric connection configurations for Kafka clients.
+    Merges default configurations with custom ones provided.
+    """
+
+    try:
+        client = Client()
+        keys = client.create_key()  # create or retrieve key
+        os.environ["OCTOPUS_AWS_ACCESS_KEY_ID"] = keys["access_key"]
+        os.environ["OCTOPUS_AWS_SECRET_ACCESS_KEY"] = keys["secret_key"]
+        os.environ["OCTOPUS_BOOTSTRAP_SERVERS"] = keys["endpoint"]
+
+    except Exception as e:
+        raise RuntimeError("Failed to retrieve Kafka keys") from e
+
+    conf = {
+        "bootstrap_servers": os.environ["OCTOPUS_BOOTSTRAP_SERVERS"],
+        "security_protocol": "SASL_SSL",
+        "sasl_mechanism": "OAUTHBEARER",
+        "api_version": (3, 8, 1),
+        "sasl_oauth_token_provider": MSKTokenProvider(),
+    }
+    conf.update(extra_configs)
+    return conf
+
+
+if kafka_available:
+
+    class KafkaProducer(KProd):
+        """
+        Wrapper around KProd that:
+        - Requires at least one topic
+        - Sets a default JSON serializer
+        - Does NOT block until topics have partition metadata
+        """
+
+        def __init__(self, *topics, **configs):
+            if not topics:
+                raise ValueError("KafkaProducer requires at least one topic")
+            self.topics = topics
+
+            configs.setdefault(
+                "value_serializer",
+                lambda v: json.dumps(v).encode("utf-8"),
+            )
+
+            super().__init__(**get_diaspora_config(configs))
+            # Note: We do NOT block on metadata here
+
+    class KafkaConsumer(KCons):
+        def __init__(self, *topics, **configs):
+            if not topics:
+                raise ValueError("KafkaConsumer requires at least one topic")
+            self.topics = topics
+
+            super().__init__(*topics, **get_diaspora_config(configs))
+            # Note: We do NOT block on metadata here
+
+
+else:
+    # Create dummy classes that issue a warning when instantiated
+    class KafkaProducer:  # type: ignore[no-redef]
+        def __init__(self, *args, **kwargs):
+            warnings.warn(
+                "KafkaProducer is not available. Initialization is a no-op.",
+                RuntimeWarning,
+            )
+
+    class KafkaConsumer:  # type: ignore[no-redef]
+        def __init__(self, *args, **kwargs):
+            warnings.warn(
+                "KafkaConsumer is not available. Initialization is a no-op.",
+                RuntimeWarning,
+            )
+
+
+def reliable_client_creation() -> str:
+    """
+    Reliably create a client and test topic operations with retry logic.
+
+    Returns:
+        str: The full topic name in format "namespace.topic-name"
+    """
+    attempt = 0
+    while True:
+        attempt += 1
+        if attempt > 1:
+            time.sleep(5)
+
+        topic_name = None
+        kafka_topic = None
+        client = None
+        try:
+            client = Client()
+            key_result = client.create_key()
+
+            # If status is not success, throw exception
+            if key_result.get("status") != "success":
+                raise RuntimeError(
+                    f"Failed to create key: {key_result.get('message', 'Unknown error')}"
+                )
+
+            # If key is fresh (just created), wait for IAM policy to propagate
+            if key_result.get("fresh", False):
+                time.sleep(8)
+
+            topic_name = f"topic-{str(uuid.uuid4())[:5]}"
+            kafka_topic = f"{client.namespace}.{topic_name}"
+
+            # If status is not success, throw exception
+            topic_result = client.create_topic(topic_name)
+            if topic_result.get("status") != "success":
+                raise RuntimeError(
+                    f"Failed to create topic: {topic_result.get('message', 'Unknown error')}"
+                )
+            time.sleep(3)  # Wait after topic creation before produce
+
+            producer = KafkaProducer(kafka_topic)
+            for i in range(3):
+                future = producer.send(
+                    kafka_topic, {"message_id": i + 1, "content": f"Message {i + 1}"}
+                )
+                future.get(timeout=30)
+            producer.close()
+            time.sleep(2)  # Wait for the produced messages to be consumed
+
+            consumer = KafkaConsumer(kafka_topic, auto_offset_reset="earliest")
+            consumer.poll(timeout_ms=10000)
+            consumer.close()
+
+            client.delete_topic(topic_name)
+            return kafka_topic
+        except Exception as e:
+            logger.info(f"Error in attempt {attempt}: {type(e).__name__}: {str(e)}")
+            if client:
+                try:
+                    if topic_name:
+                        client.delete_topic(topic_name)
+                except Exception:
+                    pass
+                try:
+                    client.delete_user()
+                except Exception:
+                    pass
+            continue

{diaspora-event-sdk-0.4.1 → diaspora_event_sdk-0.4.4}/diaspora_event_sdk/sdk/login_manager/manager.py

@@ -19,6 +19,61 @@ from .login_flow import do_link_auth_flow
 log = logging.getLogger(__name__)
 
 
+class FilteredClientCredentialsAuthorizer(globus_sdk.ClientCredentialsAuthorizer):
+    """
+    A custom ClientCredentialsAuthorizer that filters token responses to only
+    include tokens for a specific resource server.
+
+    This is needed when client credentials return tokens for multiple resource
+    servers, but ClientCredentialsAuthorizer expects exactly one token.
+    """
+
+    def __init__(
+        self,
+        confidential_client: globus_sdk.ConfidentialAppAuthClient,
+        scopes: list[str],
+        *,
+        resource_server: str,
+        access_token: str | None = None,
+        expires_at: int | None = None,
+        on_refresh: t.Callable[[globus_sdk.OAuthTokenResponse], None] | None = None,
+    ) -> None:
+        self._target_resource_server = resource_server
+        # Store the original on_refresh callback
+        self._original_on_refresh = on_refresh
+        super().__init__(
+            confidential_client=confidential_client,
+            scopes=scopes,
+            access_token=access_token,
+            expires_at=expires_at,
+            on_refresh=self._filtered_on_refresh,
+        )
+
+    def _extract_token_data(
+        self, res: globus_sdk.OAuthClientCredentialsResponse
+    ) -> dict[str, t.Any]:
+        """
+        Extract token data, filtering to only the target resource server.
+        """
+        token_data = res.by_resource_server
+        if self._target_resource_server in token_data:
+            # Return only the token for the target resource server
+            return token_data[self._target_resource_server]
+        else:
+            raise ValueError(
+                f"Token response does not contain token for {self._target_resource_server}"
+            )
+
+    def _filtered_on_refresh(
+        self, token_response: globus_sdk.OAuthTokenResponse
+    ) -> None:
+        """
+        Call the original on_refresh callback with the filtered token response.
+        """
+        if self._original_on_refresh:
+            self._original_on_refresh(token_response)
+
+
 def _get_diaspora_all_scope() -> str:
     return os.getenv(
         "DIASPORA_SCOPE",
@@ -153,9 +208,13 @@ class LoginManager:
                 expires_at = tokens["expires_at_seconds"]
 
             with self._access_lock:
-                return globus_sdk.ClientCredentialsAuthorizer(
+                # Use a custom authorizer that filters token responses to only
+                # the requested resource server, handling cases where client
+                # credentials return tokens for multiple resource servers
+                return FilteredClientCredentialsAuthorizer(
                     confidential_client=get_client_login(),
                     scopes=scopes,
+                    resource_server=resource_server,
                     access_token=access_token,
                     expires_at=expires_at,
                     on_refresh=self._token_storage.on_refresh,

diaspora_event_sdk-0.4.4/diaspora_event_sdk/sdk/web_client.py

@@ -0,0 +1,70 @@
+from typing import Optional
+
+import globus_sdk
+
+from diaspora_event_sdk.sdk.utils.uuid_like import UUID_LIKE_T
+
+from ._environments import get_web_service_url
+
+
+class WebClient(globus_sdk.BaseClient):
+    def __init__(
+        self,
+        *,
+        environment: Optional[str] = None,
+        base_url: Optional[str] = None,
+        app_name: Optional[str] = None,
+        **kwargs,
+    ):
+        if base_url is None:
+            base_url = get_web_service_url(environment)
+
+        super().__init__(environment=environment, base_url=base_url, **kwargs)
+
+        self._user_app_name = None
+        self.user_app_name = app_name
+
+    def create_user(self, subject: UUID_LIKE_T) -> globus_sdk.GlobusHTTPResponse:
+        """Call the v3 create_user endpoint (POST /api/v3/user)."""
+        return self.post("/api/v3/user", headers={"Subject": str(subject)})
+
+    def delete_user(self, subject: UUID_LIKE_T) -> globus_sdk.GlobusHTTPResponse:
+        """Call the v3 delete_user endpoint (DELETE /api/v3/user)."""
+        return self.delete("/api/v3/user", headers={"Subject": str(subject)})
+
+    def create_key(self, subject: UUID_LIKE_T) -> globus_sdk.GlobusHTTPResponse:
+        """Call the v3 create_key endpoint (POST /api/v3/key)."""
+        return self.post("/api/v3/key", headers={"Subject": str(subject)})
+
+    def delete_key(self, subject: UUID_LIKE_T) -> globus_sdk.GlobusHTTPResponse:
+        """Call the v3 delete_key endpoint (DELETE /api/v3/key)."""
+        return self.delete("/api/v3/key", headers={"Subject": str(subject)})
+
+    def list_namespaces(self, subject: UUID_LIKE_T) -> globus_sdk.GlobusHTTPResponse:
+        """Call the v3 list_namespaces endpoint (GET /api/v3/namespace)."""
+        return self.get("/api/v3/namespace", headers={"Subject": str(subject)})
+
+    def create_topic(
+        self, subject: UUID_LIKE_T, namespace: str, topic: str
+    ) -> globus_sdk.GlobusHTTPResponse:
+        """Call the v3 create_topic endpoint (POST /api/v3/{namespace}/{topic})."""
+        return self.post(
+            f"/api/v3/{namespace}/{topic}", headers={"Subject": str(subject)}
+        )
+
+    def delete_topic(
+        self, subject: UUID_LIKE_T, namespace: str, topic: str
+    ) -> globus_sdk.GlobusHTTPResponse:
+        """Call the v3 delete_topic endpoint (DELETE /api/v3/{namespace}/{topic})."""
+        return self.delete(
+            f"/api/v3/{namespace}/{topic}", headers={"Subject": str(subject)}
+        )
+
+    def recreate_topic(
+        self, subject: UUID_LIKE_T, namespace: str, topic: str
+    ) -> globus_sdk.GlobusHTTPResponse:
+        """Call the v3 recreate_topic endpoint (PUT /api/v3/{namespace}/{topic}/recreate)."""
+        return self.put(
+            f"/api/v3/{namespace}/{topic}/recreate",
+            headers={"Subject": str(subject)},
+        )

diaspora_event_sdk-0.4.4/diaspora_event_sdk/version.py

@@ -0,0 +1 @@
+__version__ = "0.4.4"

{diaspora-event-sdk-0.4.1 → diaspora_event_sdk-0.4.4/diaspora_event_sdk.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: diaspora-event-sdk
-Version: 0.4.1
+Version: 0.4.4
 Summary: Diaspora Event Fabric SDK
 Home-page: https://github.com/globus-labs/diaspora-event-sdk
 License: Apache 2.0
@@ -15,9 +15,27 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: globus-sdk<4,>=3.59.0
 Provides-Extra: kafka-python
+Requires-Dist: kafka-python; extra == "kafka-python"
 Provides-Extra: test
-License-File: LICENSE
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: coverage; extra == "test"
+Requires-Dist: mypy; extra == "test"
+Requires-Dist: tox; extra == "test"
+Requires-Dist: check-manifest; extra == "test"
+Requires-Dist: pre-commit; extra == "test"
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
 
 # Diaspora Event Fabric SDK
 

{diaspora-event-sdk-0.4.1 → diaspora_event_sdk-0.4.4}/diaspora_event_sdk.egg-info/SOURCES.txt

@@ -36,5 +36,4 @@ diaspora_event_sdk/sdk/login_manager/tokenstore.py
 diaspora_event_sdk/sdk/utils/__init__.py
 diaspora_event_sdk/sdk/utils/uuid_like.py
 tests/__init__.py
-tests/unit/apis_test.py
-tests/unit/client_test.py
+tests/unit/apis_test.py

{diaspora-event-sdk-0.4.1 → diaspora_event_sdk-0.4.4}/diaspora_event_sdk.egg-info/requires.txt

@@ -1,4 +1,4 @@
-globus-sdk<4,>=3.20.1
+globus-sdk<4,>=3.59.0
 
 [kafka-python]
 kafka-python

{diaspora-event-sdk-0.4.1 → diaspora_event_sdk-0.4.4}/setup.py

@@ -44,7 +44,7 @@ setup(
     license="Apache 2.0",
     url="https://github.com/globus-labs/diaspora-event-sdk",
     install_requires=[
-        "globus-sdk>=3.20.1,<4",
+        "globus-sdk>=3.59.0,<4",
     ],
     extras_require={
         "kafka-python": ["kafka-python"],