para-sdk 0.21.0rc9__cp38-abi3-macosx_10_12_x86_64.whl → 0.23.1rc3__cp38-abi3-macosx_10_12_x86_64.whl

para/__init__.py

@@ -1 +1 @@
-# from para import para
+from .client import UserClient, new_client, new_connection

para/client.py

@@ -0,0 +1,326 @@
+import os
+import json
+import base64
+import builtins
+from dataclasses import dataclass
+from queue import Empty, Queue
+
+from para import para
+
+from .poller import Poller
+from .messages import *
+if hasattr(builtins, "__IPYTHON__"):
+  from .conversation_panel import ConversationPanel
+
+class PncpConversation:
+  """Represents and active or completed conversation.
+  """
+
+  id: str
+  """The unique conversation ID"""
+
+  messages: list[PncpMessage]
+  """List of messages in the conversation"""
+
+  _user_client: any
+  _complete: bool
+  _message_ids: set[str]
+
+  def __init__(self, id: str, client, actor=None):
+    self.id = id
+    self._user_client = client
+    self._complete = False
+    self._message_ids = set()
+    self.provider = actor
+    self.messages = []
+
+  def _repr_json_(self):
+    meta = {'root': 'conversation', 'expanded': True}
+    data = {'id': self.id, 'messages': [m._repr_json_()[0] for m in self.messages]}
+    return (data, meta)
+
+  def _push_pncp(self, msg):
+    body = msg['body']
+    id = body['messageId']
+    if id not in self._message_ids:
+      obj = pncp_to_py(msg)
+      if obj is not None:
+        if isinstance(obj, PncpResponse) or isinstance(obj, PncpError):
+          self._complete = True
+        self.messages.append(obj)
+        self._message_ids.add(obj.id)
+        return obj
+
+  def _push_gql(self, msg):
+    id = msg['id']
+    if id not in self._message_ids:
+      obj = graphql_to_py(msg)
+      if obj is not None:
+        if isinstance(obj, PncpResponse) or isinstance(obj, PncpError):
+          self._complete = True
+        self.messages.append(obj)
+        self._message_ids.add(obj.id)
+        return obj
+
+  def _sort(self):
+    self.messages.sort(key=lambda x: x.created)
+
+  def dup(self):
+    return PncpConversation(self.id, self._user_client, actor=self.provider)
+
+  def get_last_message(self) -> PncpMessage:
+    if len(self.messages) > 0:
+      return self.messages[-1]
+
+  def get_request(self) -> PncpRequest:
+    for m in self.messages:
+      if isinstance(m, PncpRequest):
+        return m
+    return None
+
+  def get_response(self) -> PncpMessage:
+    for m in self.messages:
+      if isinstance(m, PncpResponse) or isinstance(m, PncpError):
+        return m
+    return None
+
+  def update(self):
+    """Update `messages` attribute with any new messages.
+    """
+
+    if self._complete:
+      return
+    list_resp = self._user_client._client.list_messages(self.id, 9999)
+    for m in list_resp['messages']:
+      self._push_gql(m)
+    self._sort()
+
+  def wait_response(self, show_status=False) -> PncpMessage:
+    """Wait for the conversation to complete.
+
+    Returns the response (`PncpResponse`) and an error (`PncpError`).
+    """
+
+    if not self._complete:
+      # start poller before update to ensure no messages are missed
+      q = self._user_client._poller.subscribe(id(self), self.id)
+      self.update()
+      try:
+        while not self._complete:
+          try:
+            item = q.get(timeout=0.5)
+            if item['type'] == 'message':
+              obj = self._push_pncp(item)
+              if show_status and obj is not None:
+                if isinstance(obj, PncpStatus):
+                  print(obj.display_text())
+              self._sort()
+          except Empty:
+            pass
+      finally:
+        self._user_client._poller.unsubscribe(id(self), self.id)
+    return self.get_response()
+  
+  def panel(self, out=None):
+    """Create a live notebook panel that displays conversation status and messages."""
+
+    if hasattr(builtins, "__IPYTHON__"):
+      return make_panel(self, out)
+    else:
+      raise Exception('Not an ipython environment')
+
+
+class ConversationStream:
+  def __init__(self, conv: PncpConversation):
+    self._conversation = conv
+    # start poller before update to ensure no messages are missed
+    self._queue = conv._user_client._poller.subscribe(id(self), conv.id)
+    self._position = 0
+    conv.update()
+    if conv._complete:
+      conv._user_client._poller.unsubscribe(id(self), conv.id)
+
+  def _poll(self):    
+    try:
+      item = self._queue.get(block=False)
+      if item['type'] == 'message':
+        self._conversation._push_pncp(item)
+        if self._conversation._complete:
+          self._conversation._user_client._poller.unsubscribe(id(self), self._conversation.id)
+        self._conversation._sort()
+    except Empty:
+      pass
+
+  def next(self):
+    cur = self._position
+    if cur == len(self._conversation.messages):
+      if not self._conversation._complete:
+        self._poll()
+
+    if cur < len(self._conversation.messages):
+      self._position += 1
+      return self._conversation.messages[cur]
+    return None
+
+def make_panel(conv: PncpConversation, out) -> ConversationStream:
+  # create new instance of PncpConversation panel uses on background thread
+  copy = conv.dup()
+  stream = ConversationStream(copy)
+  p = ConversationPanel(out)
+  return p.create(stream)
+
+
+@dataclass
+class ActorList:
+  actors: list[dict]
+
+  def _repr_markdown_(self):
+    lines = ['| id | kind |', '| --- | --- |']
+    for a in self.actors:
+      lines.append(f"| {a['id']} | {a['kind']} |")
+    return '\n'.join(lines)
+
+@dataclass
+class SkillList:
+  skills: list[dict]
+
+  def _repr_markdown_(self):
+    lines = ['| skillset | subject | action | inputs |', '| --- | --- | --- | --- |']
+    for s in self.skills:
+      schema = s.get('input_schema')
+      inputs = []
+      if schema is not None:
+        if schema['type'] == 'object':
+          for prop in schema['properties']:
+            inp = prop
+            typ = schema['properties'][prop].get('type')
+            if typ is not None:
+              inp = inp + ': ' + typ
+            inputs.append(inp)
+
+      lines.append(f"| {s['skillset']} | {s['subject']} | {s['action']} | {', '.join(inputs)} |")
+    return '\n'.join(lines)
+
+class UserClient:
+  """A build-in instance of this class is created and accessible as `client` within the notebook environment.  The client is automatically logged in with your user ID."""
+
+  _client: any
+  _poller: Poller
+
+  def __init__(self, paranet_client):
+    self._client = paranet_client
+    self._poller = Poller(paranet_client)
+    self._poller.start()
+
+  def new_request(self, subject: str, action: str, target_actor_id=None, **kwargs) -> PncpConversation:
+    """Send a new skill request.
+
+    - `subject` The skill request subject.
+    - `action` The skill request action.
+    - `kwargs` Any number of keyword arguments that are passed as the inputs for the skill request.
+
+    Returns the active conversation (`PncpConversation`).
+
+    """
+
+    resp = self._client.skill_request(subject, action, target_actor_id=target_actor_id, **kwargs)
+    cid = resp['id'].split('@')[0]
+    conv = PncpConversation(cid, self, actor=resp.get('matched_id'))
+    conv.update()
+    return conv
+
+  def skill_request(self, subject: str, action: str, target_actor_id=None, **kwargs) -> PncpMessage:
+    """Send a new skill request and wait for the response.
+
+    - `subject` The skill request subject.
+    - `action` The skill request action.
+    - `kwargs` Any number of keyword arguments that are passed as the inputs for the skill request.
+
+    Returns the response (`PncpResponse`) and an error (`PncpError`).
+
+    """
+
+    resp = self._client.skill_request(subject, action, target_actor_id=target_actor_id, **kwargs)
+    cid = resp['id'].split('@')[0]
+    conv = PncpConversation(cid, self, actor=resp.get('matched_id'))
+    return conv.wait_response(show_status=True)
+
+  def list_actors(self):
+    """Request a list of registered actors.
+
+    Returns `ActorList`
+    """
+
+    resp = self.skill_request('paranode', 'list_actors')
+    actors = resp.response['actors']
+    return ActorList(actors=actors)
+
+  def list_skills(self):
+    """Request a full list of registered skills.
+
+    Returns `SkillList`
+    """
+
+    resp = self.skill_request('paranode', 'list_skills')
+    skills = resp.response['skills']
+    return SkillList(skills=skills)
+
+  def list_actor_skills(self, actor: str):
+    """Request a list of the given actor's registered skills.
+
+    `actor` Name of the actor to request skills for.
+
+    Returns `SkillList`
+    """
+
+    if '@' not in actor:
+      actor = actor + '@1.0.0'
+    resp = self.skill_request('paranode', 'list_actor_skills', actor=actor)
+    skills = resp.response['skills']
+    return SkillList(skills=skills)
+
+def new_connection(endpoint=None, actor=None, version=None, password=None, jwt=None, token=None, tls_id=None):
+  endpoint = endpoint or os.environ['PARANET_ENDPOINT']
+
+  broker_url = endpoint if endpoint else 'https://paranode:3131'
+  service_url = endpoint+'/api/paranet-service' if endpoint else 'https://paranode:3132'
+
+  actor = actor or os.environ.get('PARANET_ACTOR') or 'root'
+  version = version or os.environ.get('PARANET_ACTOR_VERSION') or '1.0.0'
+  actor_entity = f'{actor}@{version}'
+  password = password or os.environ.get('PARANET_PASSWORD')
+  jwt = jwt or os.environ.get('PARANET_JWT')
+  token = token or os.environ.get('PARANET_TOKEN')
+
+  tls_id = tls_id or os.environ.get('PARANET_TLS_ID')
+
+  connection = para.connect(broker_url, service_url, actor_entity, password, jwt, token, tls_id)
+
+  print(f'Connected to {broker_url} with actor {actor_entity}')
+
+  return UserClient(connection)
+  
+def new_client(proxy=None):
+  if 'PARANET_PROXY' in os.environ:
+    endpoint = os.environ['PARANET_PROXY']
+    broker_url = endpoint
+    service_url = endpoint+'/api/paranet-service'
+    if endpoint.startswith('http:'):
+      client = para.connect(broker_url, service_url, 'root', None)
+      return UserClient(client)
+  else:
+    broker_url = 'https://paranode:3131'
+    service_url = 'https://paranode:3132'
+
+  encoded_token = os.environ.get("PN_PY_USER")
+  del os.environ["PN_PY_USER"]
+  credentials = json.loads(base64.b64decode(encoded_token))
+  actor_id = credentials['id']
+  actor = actor_id.split('@')[0]
+  access_token = {'access_token': credentials['token'], 'refresh_token': credentials['refresh']}
+  client = para.connect(broker_url, service_url, actor, json.dumps(access_token))
+  return UserClient(client)
+
+if hasattr(builtins, "__IPYTHON__"):
+  import panel as pn
+  pn.extension()

para/conversation_panel.py

@@ -0,0 +1,67 @@
+import threading
+import time
+from typing import cast
+import panel as pn
+
+from .messages import *
+
+class ConversationPanel:
+  def __init__(self, out):
+    self._out = out
+
+  def create(self, stream):
+    self._stream = stream
+    self._conversation = stream._conversation
+    self._recipient = 'actor' if self._conversation.provider is None else self._conversation.provider.split('@')[0]
+    self._request = cast(PncpRequest, self._conversation.get_request())
+
+    self._status = 'Live'
+
+    # build panel
+    self.spinner = pn.indicators.LoadingSpinner(value=True, width=20, height=20, color="primary")
+    self.title = pn.pane.Markdown(self._title_display())
+    self.status_text = pn.pane.HTML(self._status_display(), width=400)
+    self.column = pn.Column(
+        self.title,
+        self.spinner
+    )
+    self._insert = 1
+    self._poller = pn.state.add_periodic_callback(self._update_status, period=1000)
+    return self.column
+
+  def _title_display(self):
+    req = self._request.request
+    title = f"### {self._status}: {req['subject']}/{req['action']}"
+    if self._conversation.provider is not None:
+      title += ' -> ' + self._conversation.provider.split('@')[0]
+    return title
+
+  def _status_display(self):
+    return f"<B>{self._status}</B>"
+
+  def _update_status(self):
+    while True:
+      obj = self._stream.next()
+      if obj is None:
+        return
+      if self._out is not None:
+        self._out.append_stdout(f"got: {obj}\n")
+      self._append_message(obj)
+      if isinstance(obj, PncpResponse) or isinstance(obj, PncpError):
+        self._status = 'Complete' if isinstance(obj, PncpResponse) else 'Failed'
+        self.status_text.object = self._status_display()
+        self.title.object = self._title_display()
+        self.spinner.value = False
+        self.column.pop()
+        self._poller.stop()
+        self._out.append_stdout(f"{self._status}\n")
+
+  def _append_message(self, msg):
+    match msg:
+      case PncpRequest():
+        party = 'you'
+      case _:
+        party = self._recipient
+    index = self._insert
+    self._insert += 1
+    self.column.insert(index, pn.pane.HTML(f"({party}) {msg.display_text()}", width=400))

para/messages.py

@@ -0,0 +1,181 @@
+import sys
+import json
+import html
+import builtins
+from datetime import datetime
+from dataclasses import dataclass
+from types import MethodType
+from IPython.core import display_functions
+import mimeparse
+
+def value_summary(v):
+  if type(v) == list:
+    elms = [value_summary(e) for e in v]
+    return '[' + ', '.join(elms) + ']'
+  elif type(v) == dict:
+    elms = []
+    for k in v:
+      elms.append(k+': ' + value_summary(v[k]))
+    return '{' + ', '.join(elms) + '}'
+  elif type(v) == str:
+    return json.dumps(v)
+  return str(v)
+
+def data_summary(data):
+    if type(data) == dict:
+      elms = []
+      for k in data:
+        elms.append(k+': ' + value_summary(data[k]))
+      return ', '.join(elms)
+    else:
+      return value_summary(data)
+
+@dataclass
+class PncpMessage:
+  id: str
+  created: datetime
+
+  def display_text(self):
+    return f"Unknown message type"
+
+@dataclass
+class PncpStatus(PncpMessage):
+  status: dict
+
+  def _repr_json_(self):
+    meta = {'root': 'message', 'expanded': True}
+    data = {'id': self.id, 'created': self.created, 'status': self.status}
+    return (data, meta)
+
+  def display_text(self):
+    keys = list(self.status.keys())
+    if len(keys) == 1:
+      k = keys[0].lower()
+      if k == 'message' or k == 'status':
+        return 'Status: ' + data_summary(self.status[keys[0]])
+    return 'Status: ' + data_summary(self.status)
+
+@dataclass
+class PncpResponse(PncpMessage):
+  response: dict
+
+  def _repr_json_(self):
+    meta = {'root': 'message', 'expanded': True}
+    data = {'id': self.id, 'created': self.created, 'response': self.response}
+    return (data, meta)
+
+  def display_text(self):
+    keys = list(self.response.keys())
+    if len(keys) == 1:
+      k = keys[0].lower()
+      if k == 'message' or k == 'response' or k == 'result':
+        return 'Response: ' + data_summary(self.response[keys[0]])
+    return 'Response: ' + data_summary(self.response)
+
+@dataclass
+class PncpError(PncpMessage):
+  error: dict
+
+  def _repr_json_(self):
+    meta = {'root': 'message', 'expanded': True}
+    data = {'id': self.id, 'created': self.created, 'error': self.error}
+    return (data, meta)
+
+  def display_text(self):
+    keys = list(self.error.keys())
+    if len(keys) == 1:
+      k = keys[0].lower()
+      if k == 'message' or k == 'error' or k == 'result':
+        return 'Error: ' + data_summary(self.error[keys[0]])
+    return 'Error: ' + data_summary(self.error)
+
+@dataclass
+class PncpRequest(PncpMessage):
+  request: dict
+
+  def _repr_json_(self):
+    meta = {'root': 'message', 'expanded': True}
+    request = {'subject': self.request['subject'], 'action': self.request['action'], 'data': self.request['data']}
+    data = {'id': self.id, 'created': self.created, 'request': request}
+    return (data, meta)
+
+  def display_text(self):
+    args = data_summary(self.request['data'])
+    return f"Request: {self.request['subject']}/{self.request['action']}({args})"
+
+def get_mime_field(body: dict[str,any]):
+  if type(body) == dict:
+    for mk in body:
+      if mk.startswith('Mime'):
+        k = mk[4:]
+        k = k[0:1].lower() + k[1:]
+        if k in body:
+          try:
+            mime_type = mimeparse.parse_mime_type(body[mk])
+            return (mime_type, body[k])
+          except:
+            pass
+      elif mk.startswith('_mime_'):
+        k = mk[6:]
+        if k in body:
+          try:
+            mime_type = mimeparse.parse_mime_type(body[mk])
+            return (mime_type, body[k])
+          except:
+            pass
+
+def apply_rendering(msg: PncpMessage, body: dict[str,any]):
+  if not hasattr(builtins, "__IPYTHON__"):
+    return msg
+
+  render = get_mime_field(body)
+  if render is not None:
+    (mime, data) = render
+    (base, subtype, params) = mime
+    if base == 'application' and subtype == 'vnd.paranet.embed+html':
+      width = params.get('width', '100%')
+      height = params.get('height', '400')
+      iframe = f"<iframe width=\"{width}\" height=\"{height}\" srcdoc=\"{html.escape(data)}\" frameborder=\"0\"></iframe>"
+      # Notebook prioritizes json over html, so this method circumvents that by only providing html
+      def display(self):
+        display_functions.display({'text/html': iframe}, raw=True)
+      setattr(msg, '_ipython_display_', display.__get__(msg, msg.__class__))
+      
+  return msg
+
+def graphql_to_py(msg):
+  id = msg['id']
+  created = datetime.fromisoformat(msg['createdAt'].replace("Z", "+00:00"))
+  if msg['contents']['packet']['type'] == 'request':
+    request = msg['contents']['packet']['body']['body']
+    request['data'] = request['body']
+    del request['body']
+    return PncpRequest(id=id, created=created, request=request)
+  elif msg['contents']['packet']['type'] == 'message':
+    body = msg['contents']['packet']['body']
+    if body['message']['type'] == 'response':
+      response = body['message']['body']['data']
+      return apply_rendering(PncpResponse(id=id, created=created, response=response), response)
+    elif body['message']['type'] == 'status':
+      status = body['message']['body']['data']
+      return PncpStatus(id=id, created=created, status=status)
+    elif body['message']['type'] == 'error':
+      error = body['message']['body']['data']
+      return PncpError(id=id, created=created, error=error)
+  print('Unexpected GQL message', msg, file=sys.stderr)
+
+def pncp_to_py(msg):
+  if msg['type'] == 'message':
+    body = msg['body']
+    id = body['messageId']
+    created = datetime.fromisoformat(body['timeCreated'].replace("Z", "+00:00"))
+    if body['message']['message']['type'] == 'response':
+      response = body['message']['message']['body']['data']
+      return apply_rendering(PncpResponse(id=id, created=created, response=response), response)
+    elif body['message']['message']['type'] == 'status':
+      status = body['message']['message']['body']['data']
+      return PncpStatus(id=id, created=created, status=status)
+    elif body['message']['message']['type'] == 'error':
+      error = body['message']['message']['body']['data']
+      return PncpError(id=id, created=created, error=error)
+  print('Unexpected PNCP message', msg, file=sys.stderr)

para/poller.py

@@ -0,0 +1,60 @@
+import time
+from dataclasses import dataclass
+from typing import Tuple
+from queue import Queue
+from threading import Lock, Thread
+
+class Poller:
+  _client: any
+  _subscribers: dict[str,list[Tuple[int,Queue]]]
+  _lock: Lock
+
+  def __init__(self, client):
+    self._client = client
+    self._subscribers = {}
+    self._lock = Lock()
+
+  def start(self):
+    self._thread = Thread(target=self._mainloop, daemon=True)
+    self._thread.start()
+
+  def _mainloop(self):
+    while True:
+      resp = self._client.poll_next()
+      if resp is not None:
+        if resp['type'] == 'message':
+          body = resp['body']
+          cid = body['id'].split('@')[0]
+          if self._lock.acquire():
+            try:
+              if cid in self._subscribers:
+                for (_, q) in self._subscribers[cid]:
+                  q.put(resp)
+            except Exception as ex:
+              print(ex)
+            self._lock.release()
+      else:
+        time.sleep(0.1)
+
+  def subscribe(self, uid: int, cid: str) -> Queue:
+    if self._lock.acquire():
+      try:
+        if cid not in self._subscribers:
+          self._subscribers[cid] = []
+        q = Queue()
+        self._subscribers[cid].append((uid, q))
+      except Exception as ex:
+        print(ex)
+      self._lock.release()
+      return q
+
+  def unsubscribe(self, uid: int, cid: str):
+    if self._lock.acquire():
+      try:
+        if cid in self._subscribers:
+          self._subscribers[cid] = [sub for sub in self._subscribers[cid] if sub[0] != uid]
+          if len(self._subscribers[cid]) == 0:
+            del self._subscribers[cid]
+      except Exception as ex:
+        print(ex)
+      self._lock.release()

para_sdk-0.23.1rc3.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: para-sdk
+Version: 0.23.1rc3
+Requires-Dist: python-mimeparse
+Requires-Dist: panel
+Requires-Dist: pydeck
+Requires-Dist: ipython

para_sdk-0.23.1rc3.dist-info/RECORD

@@ -0,0 +1,10 @@
+para/__init__.py,sha256=j91SUu6B2VlgXvHvNkH5NK3WDkBdrNBytoPhO5E_LWU,58
+para/__main__.py,sha256=GUDEQZo7PdWXRCYbNZm65kcl0lENtu3AikKs0bflDrM,64
+para/client.py,sha256=-L3BQ54fumiD06vW97etNcPbFgUA6qIjJUu0YF6Ng8A,10141
+para/conversation_panel.py,sha256=cGRdl2ay1BJJ1yOsJTunDgJAY7CD4BczTiWE0VzN3xc,2168
+para/messages.py,sha256=U41mSpPXp9ub5JpUU53hn-yha9dCA9qOxrj9vsGQUHY,6102
+para/para.abi3.so,sha256=g4-Oacrr7vzdrxeZCkJXw5hWwSy_uaRkq0b99pkhT24,59584336
+para/poller.py,sha256=vmUeA_Gj9xD7O15n9tY8w37QMMHZwfJpbShB9lNHoJ4,1666
+para_sdk-0.23.1rc3.dist-info/METADATA,sha256=XRSG1TduRLl1Y8m3z2CgKdbQBGnDNV4NDu3sF8XofkA,154
+para_sdk-0.23.1rc3.dist-info/WHEEL,sha256=GPFYR4mIPdHeeQ1ax6E8LJaGIrcByvaZAJbs3IVoO7M,104
+para_sdk-0.23.1rc3.dist-info/RECORD,,

{para_sdk-0.21.0rc9.dist-info → para_sdk-0.23.1rc3.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.9.4)
+Generator: maturin (1.9.6)
 Root-Is-Purelib: false
 Tag: cp38-abi3-macosx_10_12_x86_64

para_sdk-0.21.0rc9.dist-info/METADATA

@@ -1,3 +0,0 @@
-Metadata-Version: 2.4
-Name: para-sdk
-Version: 0.21.0rc9

para_sdk-0.21.0rc9.dist-info/RECORD

@@ -1,7 +0,0 @@
-para/__init__.py,sha256=8nY2C-MRakbnN1mtZlVfrTj96QQAJ0FqPtuPL6pGF_U,23
-para/__main__.py,sha256=GUDEQZo7PdWXRCYbNZm65kcl0lENtu3AikKs0bflDrM,64
-para/para.abi3.so,sha256=nB25aNUayLlseCWOQODjfRJ-hSlVbfPty5TDUhO_Eko,51610044
-para_sdk-0.21.0rc9.dist-info/METADATA,sha256=i2mQfYYAjx_zPEZ4YiJPf-Q9PD987ZmXGVzXvixt0y4,56
-para_sdk-0.21.0rc9.dist-info/WHEEL,sha256=qq8T5RNN4nLzVDHWhr9aubnbXTyL36gsBivIyKvr8Qc,104
-para_sdk-0.21.0rc9.dist-info/entry_points.txt,sha256=px5FZ1yAAKZ9kGJTb7564AHax4LzD90r73E5_shEwkU,33
-para_sdk-0.21.0rc9.dist-info/RECORD,,

para_sdk-0.21.0rc9.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-para=para::cli