diaspora-event-sdk 0.0.3__tar.gz → 0.0.5__tar.gz

diaspora-event-sdk-0.0.5/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.1
+Name: diaspora-event-sdk
+Version: 0.0.5
+Summary: SDK of Diaspora Event Fabric: Resilience-enabling services for science from HPC to edge
+Home-page: https://github.com/globus-labs/diaspora-event-sdk
+License: LICENSE
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Diaspora Event Fabric: Resilience-enabling services for science from HPC to edge
+
+### Install
+```bash
+pip install diaspora-event-sdk
+```
+
+## Use kafka-python
+
+### Register Topic (create topic ACLs)
+
+Before you can create, describe, and delete topics we need to set the appropriate ACLs in ZooKeeper. Here we use the Client to register ACLs for the desired topic name.
+
+```python
+from diaspora_event_sdk import Client as GlobusClient
+c = GlobusClient()
+topic = "topic-" + c.subject_openid[-12:]
+print(c.register_topic(topic))
+print(c.list_topics())
+```
+
+### Create Topic
+
+Now use the KafkaAdmin to create the topic.
+
+```python
+from diaspora_event_sdk import KafkaAdmin, NewTopic 
+admin = KafkaAdmin()
+print(admin.create_topics(new_topics=[
+      NewTopic(name=topic, num_partitions=1, replication_factor=1)]))
+```
+
+### Start Producer
+
+Once the topic is created we can publish to it. The KafkaProducer wraps the [Python KafkaProducer](https://kafka-python.readthedocs.io/en/master/apidoc/KafkaProducer.html) Event publication can be either synchronous or asynchronous. Below demonstrates the synchronous approach. 
+
+```python
+from diaspora_event_sdk import KafkaProducer
+producer = KafkaProducer()
+future = producer.send(
+    topic, {'message': 'Synchronous message from Diaspora SDK'})
+result = future.get(timeout=10)
+print(result)
+```
+
+### Start Consumer
+
+A consumer can be configured to monitor the topic and act on events as they are published. The KafkaConsumer wraps the [Python KafkaConsumer](https://kafka-python.readthedocs.io/en/master/apidoc/KafkaConsumer.html). Here we use the `auto_offset_reset` to consume from the first event published to the topic. Removing this field will have the consumer act only on new events.
+
+```python
+from diaspora_event_sdk import KafkaConsumer
+consumer = KafkaConsumer(topic, auto_offset_reset='earliest')
+for msg in consumer:
+    print(msg)
+```
+
+### Delete Topic
+```python
+from diaspora_event_sdk import KafkaAdmin
+admin = KafkaAdmin()
+res = admin.delete_topics(topics=[topic])
+print(res)
+```
+
+### Unregister Topic (remove topic ACLs)
+```python
+from diaspora_event_sdk import Client as GlobusClient
+c = GlobusClient()
+topic = "topic-" + c.subject_openid[-12:]
+print(c.unregister_topic(topic))
+print(c.list_topics())
+```
+
+## Use other Kafka libraries
+```python
+from diaspora_event_sdk import Client as GlobusClient
+c = GlobusClient()
+print(c.retrieve_key())
+```
+For other Kafka clients, select SASL/SCRAM authentication, and use `username` and `password` as authentication credential. Other connection parameters see [here](). 

{diaspora-event-sdk-0.0.3 → diaspora-event-sdk-0.0.5}/diaspora_event_sdk/__init__.py

@@ -7,7 +7,8 @@ __author__ = "The Diaspora Event Team"
 __version__ = _version
 
 from diaspora_event_sdk.sdk.client import Client  # Globus client
-from diaspora_event_sdk.sdk.kafka_client import Producer, Consumer, KafkaAdmin, NewTopic
+from diaspora_event_sdk.sdk.kafka_client import KafkaProducer, KafkaConsumer, KafkaAdmin, NewTopic
 
 
-__all__ = ("Client", "Producer", "Consumer", "KafkaAdmin", "NewTopic")
+__all__ = ("Client", "KafkaProducer",
+           "KafkaConsumer", "KafkaAdmin", "NewTopic")

{diaspora-event-sdk-0.0.3 → diaspora-event-sdk-0.0.5}/diaspora_event_sdk/sdk/_environments.py

@@ -1,4 +1,11 @@
+import os
+
+
 TOKEN_EXCHANGE = "http://3.220.110.101"
 DIASPORA_RESOURCE_SERVER = '2b9d2f5c-fa32-45b5-875b-b24cd343b917'
 MSK_SCRAM_ENDPOINT = "b-1-public.diaspora.k6i387.c21.kafka.us-east-1.amazonaws.com:9196,b-2-public.diaspora.k6i387.c21.kafka.us-east-1.amazonaws.com:9196"
 MSK_IAM_ENDPOINT = "b-1-public.diaspora.k6i387.c21.kafka.us-east-1.amazonaws.com:9198,b-2-public.diaspora.k6i387.c21.kafka.us-east-1.amazonaws.com:9198"
+
+
+def _get_envname():
+    return os.getenv("DIASPORA_SDK_ENVIRONMENT", "production")

{diaspora-event-sdk-0.0.3 → diaspora-event-sdk-0.0.5}/diaspora_event_sdk/sdk/client.py

@@ -1,8 +1,6 @@
 import json
 
-from diaspora_event_sdk.sdk.login_manager.manager import LoginManager
-from diaspora_event_sdk.sdk.login_manager import requires_login
-from globus_compute_sdk.sdk.login_manager import LoginManagerProtocol
+from diaspora_event_sdk.sdk.login_manager import LoginManager, LoginManagerProtocol, requires_login
 
 from ._environments import TOKEN_EXCHANGE, DIASPORA_RESOURCE_SERVER
 
@@ -35,6 +33,9 @@ class Client:
 
     @requires_login
     def create_key(self):
+        """
+        Invalidate previous keys (if any) and generate a new one
+        """
         resp = self.web_client.create_key(self.subject_openid)
         if resp["status"] == "error":
             raise Exception("should not happen")
@@ -53,28 +54,27 @@ class Client:
                 ],
             )
             self.login_manager._token_storage._connection.commit()
-        return resp
+        return {"username": self.subject_openid, "password": tokens['secret_key']}
 
     @requires_login
-    def retrieve_or_create_key(self):
+    def retrieve_key(self):
+        """
+        Attempt to retrieve the key from local token storage, call create_key if not found
+        """
         tokens = self.login_manager._token_storage.get_token_data(
             DIASPORA_RESOURCE_SERVER)
         if "access_key" in tokens and "secret_key" in tokens:
-            return {
-                "status": "succeed", "username": self.subject_openid,
-                "access_key": tokens['access_key'],
-                "secret_key": tokens['secret_key']
-            }
-        return self.create_key()
+            return {"username": self.subject_openid, "password": tokens['secret_key']}
+        return self.retrieve_key()
 
     @requires_login
-    def acl_list(self):
-        return self.web_client.acl_list(self.subject_openid)
+    def list_topics(self):
+        return self.web_client.list_topics(self.subject_openid)
 
     @requires_login
-    def acl_add(self, topic):
-        return self.web_client.acl_add(self.subject_openid, topic)
+    def register_topic(self, topic):
+        return self.web_client.register_topic(self.subject_openid, topic)
 
     @requires_login
-    def acl_remove(self, topic):
-        return self.web_client.acl_remove(self.subject_openid, topic)
+    def unregister_topic(self, topic):
+        return self.web_client.unregister_topic(self.subject_openid, topic)

diaspora-event-sdk-0.0.5/diaspora_event_sdk/sdk/kafka_client.py

@@ -0,0 +1,46 @@
+import json
+from kafka import KafkaProducer, KafkaConsumer, KafkaAdminClient
+from kafka.admin import NewTopic
+from typing import Dict, Any
+
+from .client import Client
+from ._environments import MSK_SCRAM_ENDPOINT
+
+
+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:
+        keys = Client().retrieve_key()
+    except Exception as e:
+        raise RuntimeError("Failed to retrieve Kafka keys") from e
+
+    conf = {
+        "bootstrap_servers":  MSK_SCRAM_ENDPOINT,
+        "security_protocol": "SASL_SSL",
+        "sasl_mechanism": "SCRAM-SHA-512",
+        "api_version": (3, 5, 1),
+        "sasl_plain_username": keys["username"],
+        "sasl_plain_password": keys["password"],
+    }
+    conf.update(extra_configs)
+    return conf
+
+
+class KafkaAdmin(KafkaAdminClient):
+    def __init__(self, **configs):
+        super().__init__(**get_diaspora_config(configs))
+
+
+class KafkaProducer(KafkaProducer):
+    def __init__(self, **configs):
+        configs.setdefault("value_serializer",
+                           lambda v: json.dumps(v).encode('utf-8'))
+        super().__init__(**get_diaspora_config(configs))
+
+
+class KafkaConsumer(KafkaConsumer):
+    def __init__(self, *topics, **configs):
+        super().__init__(*topics, **get_diaspora_config(configs))

{diaspora-event-sdk-0.0.3 → diaspora-event-sdk-0.0.5}/diaspora_event_sdk/sdk/login_manager/__init__.py

@@ -1,7 +1,10 @@
 from .decorators import requires_login
 from .manager import DiasporaScopes, LoginManager
+from .protocol import LoginManagerProtocol
 
 __all__ = (
     "LoginManager",
     "DiasporaScopes",
-)
+    "LoginManagerProtocol",
+    "requires_login",
+)

{diaspora-event-sdk-0.0.3 → diaspora-event-sdk-0.0.5}/diaspora_event_sdk/sdk/login_manager/manager.py

@@ -8,7 +8,7 @@ import typing as t
 
 import globus_sdk
 from globus_sdk.scopes import AuthScopes, ScopeBuilder
-from globus_compute_sdk.sdk.login_manager.tokenstore import get_token_storage_adapter
+from diaspora_event_sdk.sdk.login_manager.tokenstore import get_token_storage_adapter
 
 from .._environments import DIASPORA_RESOURCE_SERVER
 from ..web_client import WebClient

diaspora-event-sdk-0.0.5/diaspora_event_sdk/sdk/login_manager/protocol.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import sys
+
+import globus_sdk
+
+from ..web_client import WebClient
+
+# these were added to stdlib typing in 3.8, so the import must be conditional
+# mypy and other tools expect and document a sys.version_info check
+if sys.version_info >= (3, 8):
+    from typing import Protocol, runtime_checkable
+else:
+    from typing_extensions import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class LoginManagerProtocol(Protocol):
+    def ensure_logged_in(self) -> None:
+        ...
+
+    def logout(self) -> bool:
+        ...
+
+    def get_auth_client(self) -> globus_sdk.AuthClient:
+        ...
+
+    def get_web_client(self, *, base_url: str | None = None) -> WebClient:
+        ...

diaspora-event-sdk-0.0.5/diaspora_event_sdk/sdk/login_manager/tokenstore.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import json
+import os
+import pathlib
+
+from globus_sdk.tokenstorage import SQLiteAdapter
+
+from .._environments import _get_envname
+from .client_login import get_client_login, is_client_login
+from .globus_auth import internal_auth_client
+
+
+def _home() -> pathlib.Path:
+    # this is a hook point for tests to patch over
+    # it just returns `pathlib.Path.home()`
+    # replace this with a mock to return some test directory
+    return pathlib.Path.home()
+
+
+def invalidate_old_config() -> None:
+    token_file = _home() / ".funcx" / "credentials" / "funcx_sdk_tokens.json"
+
+    if token_file.exists():
+        try:
+            auth_client = internal_auth_client()
+            with open(token_file) as fp:
+                data = json.load(fp)
+            for token_data in data.values():
+                if "access_token" in token_data:
+                    auth_client.oauth2_revoke_token(token_data["access_token"])
+                if "refresh_token" in token_data:
+                    auth_client.oauth2_revoke_token(
+                        token_data["refresh_token"])
+        finally:
+            os.remove(token_file)
+
+
+def ensure_compute_dir() -> pathlib.Path:
+    legacy_dirname = _home() / ".funcx"
+    dirname = _home() / ".globus_compute"
+
+    user_dir = os.getenv("GLOBUS_COMPUTE_USER_DIR")
+    if user_dir:
+        dirname = pathlib.Path(user_dir)
+
+    if dirname.is_dir():
+        pass
+    elif dirname.is_file():
+        raise FileExistsError(
+            f"Error creating directory {dirname}, "
+            "please remove or rename the conflicting file"
+        )
+    elif legacy_dirname.is_dir() and not user_dir:
+        legacy_dirname.replace(dirname)
+        legacy_dirname.symlink_to(dirname, target_is_directory=True)
+    else:
+        dirname.mkdir(mode=0o700, parents=True, exist_ok=True)
+
+    return dirname
+
+
+def _get_storage_filename():
+    datadir = ensure_compute_dir()
+    return os.path.join(datadir, "storage.db")
+
+
+def _resolve_namespace(environment: str | None) -> str:
+    """
+    Return the namespace used to save tokens. This will check
+    if a client login is being used and return either:
+      user/<envname>
+    or
+      clientprofile/<envname>/<clientid>
+
+    e.g.
+
+      user/production
+    """
+    env = environment if environment is not None else _get_envname()
+
+    if is_client_login():
+        client_id = get_client_login().client_id
+        return f"clientprofile/{env}/{client_id}"
+
+    return f"user/{env}"
+
+
+def get_token_storage_adapter(*, environment: str | None = None) -> SQLiteAdapter:
+    # when initializing the token storage adapter, check if the storage file exists
+    # if it does not, then use this as a flag to clean the old config
+    fname = _get_storage_filename()
+    if not os.path.exists(fname):
+        invalidate_old_config()
+    # namespace is equal to the current environment
+    return SQLiteAdapter(
+        fname,
+        namespace=_resolve_namespace(environment),
+        connect_params={"check_same_thread": False},
+    )

diaspora-event-sdk-0.0.5/diaspora_event_sdk/sdk/utils/uuid_like.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+import typing as t
+import uuid
+
+# older pythons don't like aliases using |, even with a __future__ import
+UUID_LIKE_T = t.Union[uuid.UUID, str]
+
+
+def as_uuid(uuid_like: UUID_LIKE_T) -> uuid.UUID:
+    return uuid_like if isinstance(uuid_like, uuid.UUID) else uuid.UUID(uuid_like)
+
+
+def as_optional_uuid(optional_uuid_like: UUID_LIKE_T | None) -> uuid.UUID | None:
+    return as_uuid(optional_uuid_like) if optional_uuid_like else None

diaspora-event-sdk-0.0.5/diaspora_event_sdk/sdk/web_client.py

@@ -0,0 +1,39 @@
+
+import typing as t
+
+import globus_sdk
+from globus_sdk.exc.api import GlobusAPIError
+from diaspora_event_sdk.sdk.utils.uuid_like import UUID_LIKE_T
+
+from ._environments import TOKEN_EXCHANGE
+
+
+class WebClient(globus_sdk.BaseClient):
+
+    def __init__(
+        self,
+        *,
+        environment: t.Optional[str] = None,
+        base_url: t.Optional[str] = None,
+        app_name: t.Optional[str] = None,
+        **kwargs,
+    ):
+        if base_url is None:
+            base_url = TOKEN_EXCHANGE
+
+        super().__init__(environment=environment, base_url=base_url, **kwargs)
+
+        self._user_app_name = None
+        self.user_app_name = app_name
+
+    def create_key(self, subject: UUID_LIKE_T) -> globus_sdk.GlobusHTTPResponse:
+        return self.post("/v1/create_key", headers={"Subject": subject})
+
+    def list_topics(self, subject: UUID_LIKE_T) -> globus_sdk.GlobusHTTPResponse:
+        return self.get("/v1/list_topics", headers={"Subject": subject})
+
+    def register_topic(self, subject: UUID_LIKE_T, topic: str) -> globus_sdk.GlobusHTTPResponse:
+        return self.post("/v1/register_topic", headers={"Subject": subject, "Topic": topic})
+
+    def unregister_topic(self, subject: UUID_LIKE_T, topic: str) -> globus_sdk.GlobusHTTPResponse:
+        return self.post("/v1/unregister_topic", headers={"Subject": subject, "Topic": topic})

diaspora-event-sdk-0.0.5/diaspora_event_sdk/version.py

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

diaspora-event-sdk-0.0.5/diaspora_event_sdk.egg-info/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.1
+Name: diaspora-event-sdk
+Version: 0.0.5
+Summary: SDK of Diaspora Event Fabric: Resilience-enabling services for science from HPC to edge
+Home-page: https://github.com/globus-labs/diaspora-event-sdk
+License: LICENSE
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Diaspora Event Fabric: Resilience-enabling services for science from HPC to edge
+
+### Install
+```bash
+pip install diaspora-event-sdk
+```
+
+## Use kafka-python
+
+### Register Topic (create topic ACLs)
+
+Before you can create, describe, and delete topics we need to set the appropriate ACLs in ZooKeeper. Here we use the Client to register ACLs for the desired topic name.
+
+```python
+from diaspora_event_sdk import Client as GlobusClient
+c = GlobusClient()
+topic = "topic-" + c.subject_openid[-12:]
+print(c.register_topic(topic))
+print(c.list_topics())
+```
+
+### Create Topic
+
+Now use the KafkaAdmin to create the topic.
+
+```python
+from diaspora_event_sdk import KafkaAdmin, NewTopic 
+admin = KafkaAdmin()
+print(admin.create_topics(new_topics=[
+      NewTopic(name=topic, num_partitions=1, replication_factor=1)]))
+```
+
+### Start Producer
+
+Once the topic is created we can publish to it. The KafkaProducer wraps the [Python KafkaProducer](https://kafka-python.readthedocs.io/en/master/apidoc/KafkaProducer.html) Event publication can be either synchronous or asynchronous. Below demonstrates the synchronous approach. 
+
+```python
+from diaspora_event_sdk import KafkaProducer
+producer = KafkaProducer()
+future = producer.send(
+    topic, {'message': 'Synchronous message from Diaspora SDK'})
+result = future.get(timeout=10)
+print(result)
+```
+
+### Start Consumer
+
+A consumer can be configured to monitor the topic and act on events as they are published. The KafkaConsumer wraps the [Python KafkaConsumer](https://kafka-python.readthedocs.io/en/master/apidoc/KafkaConsumer.html). Here we use the `auto_offset_reset` to consume from the first event published to the topic. Removing this field will have the consumer act only on new events.
+
+```python
+from diaspora_event_sdk import KafkaConsumer
+consumer = KafkaConsumer(topic, auto_offset_reset='earliest')
+for msg in consumer:
+    print(msg)
+```
+
+### Delete Topic
+```python
+from diaspora_event_sdk import KafkaAdmin
+admin = KafkaAdmin()
+res = admin.delete_topics(topics=[topic])
+print(res)
+```
+
+### Unregister Topic (remove topic ACLs)
+```python
+from diaspora_event_sdk import Client as GlobusClient
+c = GlobusClient()
+topic = "topic-" + c.subject_openid[-12:]
+print(c.unregister_topic(topic))
+print(c.list_topics())
+```
+
+## Use other Kafka libraries
+```python
+from diaspora_event_sdk import Client as GlobusClient
+c = GlobusClient()
+print(c.retrieve_key())
+```
+For other Kafka clients, select SASL/SCRAM authentication, and use `username` and `password` as authentication credential. Other connection parameters see [here](). 

{diaspora-event-sdk-0.0.3 → diaspora-event-sdk-0.0.5}/diaspora_event_sdk.egg-info/SOURCES.txt

@@ -1,5 +1,4 @@
 LICENSE
-README.md
 setup.py
 diaspora_event_sdk/__init__.py
 diaspora_event_sdk/version.py
@@ -19,4 +18,8 @@ diaspora_event_sdk/sdk/login_manager/client_login.py
 diaspora_event_sdk/sdk/login_manager/decorators.py
 diaspora_event_sdk/sdk/login_manager/globus_auth.py
 diaspora_event_sdk/sdk/login_manager/login_flow.py
-diaspora_event_sdk/sdk/login_manager/manager.py
+diaspora_event_sdk/sdk/login_manager/manager.py
+diaspora_event_sdk/sdk/login_manager/protocol.py
+diaspora_event_sdk/sdk/login_manager/tokenstore.py
+diaspora_event_sdk/sdk/utils/__init__.py
+diaspora_event_sdk/sdk/utils/uuid_like.py

diaspora-event-sdk-0.0.5/diaspora_event_sdk.egg-info/requires.txt

@@ -0,0 +1,2 @@
+globus-sdk
+kafka-python

{diaspora-event-sdk-0.0.3 → diaspora-event-sdk-0.0.5}/setup.py

@@ -14,7 +14,7 @@ setup(
     license='LICENSE',  # Specify the path to your LICENSE file
     url='https://github.com/globus-labs/diaspora-event-sdk',
     install_requires=[
-        'globus-compute-sdk',
+        'globus-sdk',
         'kafka-python',
     ],
 )

diaspora-event-sdk-0.0.3/PKG-INFO

@@ -1,76 +0,0 @@
-Metadata-Version: 2.1
-Name: diaspora-event-sdk
-Version: 0.0.3
-Summary: SDK of Diaspora Event Fabric: Resilience-enabling services for science from HPC to edge
-Home-page: https://github.com/globus-labs/diaspora-event-sdk
-License: LICENSE
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# Diaspora Event Fabric: Resilience-enabling services for science from HPC to edge
-
-### Install
-```bash
-pip install diaspora-event-sdk
-```
-
-## Use kafka-python
-
-### Claim Topic Ownership
-```python
-from diaspora_event_sdk import Client as GlobusClient
-c = GlobusClient()
-topic = f"topic-of-{c.subject_openid}" # or any unclaimed topic
-print(c.acl_add(topic))
-print(c.acl_list())
-```
-
-### Create Topic
-```python
-from diaspora_event_sdk import KafkaAdmin, NewTopic 
-admin = KafkaAdmin()
-res = admin.create_topics(new_topics=[NewTopic(name=topic, num_partitions=2, replication_factor=2)])
-print(res)
-```
-
-### Start Producer
-```python
-from diaspora_event_sdk import Producer
-future = producer.send(
-    topic, {'message': 'Synchronous message from Diaspora SDK'})
-result = future.get(timeout=10)
-print(result)
-```
-### Start Consumer
-```python
-from diaspora_event_sdk import Consumer  # Kafka producer
-consumer = Consumer(topic)
-for msg in consumer:
-    print(msg)
-```
-### Delete Topic
-```python
-from diaspora_event_sdk import KafkaAdmin
-admin = KafkaAdmin()
-res = admin.delete_topics(topics=[topic])
-print(res)
-
-```
-
-### Release Topic Ownership
-```python
-from diaspora_event_sdk import Client as GlobusClient
-c = GlobusClient()
-topic = f"topic-of-{c.subject_openid}" # or any topic you claimed
-print(c.acl_remove(topic))
-print(c.acl_list())
-```
-
-## Use other Kafka libraries
-```python
-from diaspora_event_sdk import Client as GlobusClient
-c = GlobusClient()
-c.retrieve_or_create_key()
-```
-For SASL/SCRAM authentication, use `username` and `secret_key` as authentication credential;
-For AWS_MSK_IAM authentication, use `access_key` and `secret_key` as authentication credential.

diaspora-event-sdk-0.0.3/README.md

@@ -1,67 +0,0 @@
-# Diaspora Event Fabric: Resilience-enabling services for science from HPC to edge
-
-### Install
-```bash
-pip install diaspora-event-sdk
-```
-
-## Use kafka-python
-
-### Claim Topic Ownership
-```python
-from diaspora_event_sdk import Client as GlobusClient
-c = GlobusClient()
-topic = f"topic-of-{c.subject_openid}" # or any unclaimed topic
-print(c.acl_add(topic))
-print(c.acl_list())
-```
-
-### Create Topic
-```python
-from diaspora_event_sdk import KafkaAdmin, NewTopic 
-admin = KafkaAdmin()
-res = admin.create_topics(new_topics=[NewTopic(name=topic, num_partitions=2, replication_factor=2)])
-print(res)
-```
-
-### Start Producer
-```python
-from diaspora_event_sdk import Producer
-future = producer.send(
-    topic, {'message': 'Synchronous message from Diaspora SDK'})
-result = future.get(timeout=10)
-print(result)
-```
-### Start Consumer
-```python
-from diaspora_event_sdk import Consumer  # Kafka producer
-consumer = Consumer(topic)
-for msg in consumer:
-    print(msg)
-```
-### Delete Topic
-```python
-from diaspora_event_sdk import KafkaAdmin
-admin = KafkaAdmin()
-res = admin.delete_topics(topics=[topic])
-print(res)
-
-```
-
-### Release Topic Ownership
-```python
-from diaspora_event_sdk import Client as GlobusClient
-c = GlobusClient()
-topic = f"topic-of-{c.subject_openid}" # or any topic you claimed
-print(c.acl_remove(topic))
-print(c.acl_list())
-```
-
-## Use other Kafka libraries
-```python
-from diaspora_event_sdk import Client as GlobusClient
-c = GlobusClient()
-c.retrieve_or_create_key()
-```
-For SASL/SCRAM authentication, use `username` and `secret_key` as authentication credential;
-For AWS_MSK_IAM authentication, use `access_key` and `secret_key` as authentication credential.

diaspora-event-sdk-0.0.3/diaspora_event_sdk/sdk/kafka_client.py

@@ -1,46 +0,0 @@
-import json
-
-from kafka import KafkaProducer, KafkaConsumer, KafkaAdminClient
-from kafka.admin import NewTopic
-
-from .client import Client
-from ._environments import MSK_SCRAM_ENDPOINT
-
-DEFAULT_CONFIGS = {
-    "bootstrap_servers":  MSK_SCRAM_ENDPOINT,
-    "security_protocol": "SASL_SSL",
-    "sasl_mechanism": "SCRAM-SHA-512",
-    "api_version": (3, 5, 1)
-}
-
-
-class KafkaAdmin(KafkaAdminClient):
-    def __init__(self, **configs):
-        keys = Client().retrieve_or_create_key()
-        conf = DEFAULT_CONFIGS.copy()
-        conf["sasl_plain_username"] = keys["username"]
-        conf["sasl_plain_password"] = keys["secret_key"]
-        conf.update(configs)
-        super().__init__(**conf)
-
-
-class Producer(KafkaProducer):
-    def __init__(self, **configs):
-        keys = Client().retrieve_or_create_key()
-        conf = DEFAULT_CONFIGS.copy()
-        conf["sasl_plain_username"] = keys["username"]
-        conf["sasl_plain_password"] = keys["secret_key"]
-        conf["value_serializer"] = lambda v: json.dumps(
-            v).encode('utf-8')
-        conf.update(configs)
-        super().__init__(**conf)
-
-
-class Consumer(KafkaConsumer):
-    def __init__(self, *topics, **configs):
-        keys = Client().retrieve_or_create_key()
-        conf = DEFAULT_CONFIGS.copy()
-        conf["sasl_plain_username"] = keys["username"]
-        conf["sasl_plain_password"] = keys["secret_key"]
-        conf.update(configs)
-        super().__init__(*topics, **conf)

diaspora-event-sdk-0.0.3/diaspora_event_sdk/sdk/web_client.py

@@ -1,39 +0,0 @@
-
-import typing as t
-
-import globus_sdk
-from globus_compute_sdk.sdk.utils.uuid_like import UUID_LIKE_T
-from globus_sdk.exc.api import GlobusAPIError
-
-from ._environments import TOKEN_EXCHANGE
-
-
-class WebClient(globus_sdk.BaseClient):
-
-    def __init__(
-        self,
-        *,
-        environment: t.Optional[str] = None,
-        base_url: t.Optional[str] = None,
-        app_name: t.Optional[str] = None,
-        **kwargs,
-    ):
-        if base_url is None:
-            base_url = TOKEN_EXCHANGE
-
-        super().__init__(environment=environment, base_url=base_url, **kwargs)
-
-        self._user_app_name = None
-        self.user_app_name = app_name
-
-    def create_key(self, subject: UUID_LIKE_T) -> globus_sdk.GlobusHTTPResponse:
-        return self.post("/create_key", headers={"Subject": subject})
-
-    def acl_list(self, subject: UUID_LIKE_T) -> globus_sdk.GlobusHTTPResponse:
-        return self.get("/acl_list", headers={"Subject": subject})
-
-    def acl_add(self, subject: UUID_LIKE_T, topic: str) -> globus_sdk.GlobusHTTPResponse:
-        return self.post("/acl_add", headers={"Subject": subject, "Topic": topic})
-
-    def acl_remove(self, subject: UUID_LIKE_T, topic: str) -> globus_sdk.GlobusHTTPResponse:
-        return self.post("/acl_remove", headers={"Subject": subject, "Topic": topic})

diaspora-event-sdk-0.0.3/diaspora_event_sdk/version.py

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

diaspora-event-sdk-0.0.3/diaspora_event_sdk.egg-info/PKG-INFO

@@ -1,76 +0,0 @@
-Metadata-Version: 2.1
-Name: diaspora-event-sdk
-Version: 0.0.3
-Summary: SDK of Diaspora Event Fabric: Resilience-enabling services for science from HPC to edge
-Home-page: https://github.com/globus-labs/diaspora-event-sdk
-License: LICENSE
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# Diaspora Event Fabric: Resilience-enabling services for science from HPC to edge
-
-### Install
-```bash
-pip install diaspora-event-sdk
-```
-
-## Use kafka-python
-
-### Claim Topic Ownership
-```python
-from diaspora_event_sdk import Client as GlobusClient
-c = GlobusClient()
-topic = f"topic-of-{c.subject_openid}" # or any unclaimed topic
-print(c.acl_add(topic))
-print(c.acl_list())
-```
-
-### Create Topic
-```python
-from diaspora_event_sdk import KafkaAdmin, NewTopic 
-admin = KafkaAdmin()
-res = admin.create_topics(new_topics=[NewTopic(name=topic, num_partitions=2, replication_factor=2)])
-print(res)
-```
-
-### Start Producer
-```python
-from diaspora_event_sdk import Producer
-future = producer.send(
-    topic, {'message': 'Synchronous message from Diaspora SDK'})
-result = future.get(timeout=10)
-print(result)
-```
-### Start Consumer
-```python
-from diaspora_event_sdk import Consumer  # Kafka producer
-consumer = Consumer(topic)
-for msg in consumer:
-    print(msg)
-```
-### Delete Topic
-```python
-from diaspora_event_sdk import KafkaAdmin
-admin = KafkaAdmin()
-res = admin.delete_topics(topics=[topic])
-print(res)
-
-```
-
-### Release Topic Ownership
-```python
-from diaspora_event_sdk import Client as GlobusClient
-c = GlobusClient()
-topic = f"topic-of-{c.subject_openid}" # or any topic you claimed
-print(c.acl_remove(topic))
-print(c.acl_list())
-```
-
-## Use other Kafka libraries
-```python
-from diaspora_event_sdk import Client as GlobusClient
-c = GlobusClient()
-c.retrieve_or_create_key()
-```
-For SASL/SCRAM authentication, use `username` and `secret_key` as authentication credential;
-For AWS_MSK_IAM authentication, use `access_key` and `secret_key` as authentication credential.

diaspora-event-sdk-0.0.3/diaspora_event_sdk.egg-info/requires.txt

@@ -1,2 +0,0 @@
-globus-compute-sdk
-kafka-python