motifapi 0.2.0__py3-none-any.whl

motifapi/__init__.py

@@ -0,0 +1,5 @@
+__version__ = '0.2.0'
+
+from .api import MotifError, MotifApiError, MotifApi
+from .schedule import datetime_to_cron
+from .util import get_experiment_metadata

motifapi/api.py

@@ -0,0 +1,328 @@
+import re
+import json
+import ssl
+import socket
+import os.path
+import subprocess
+import logging
+import urllib.request
+import urllib.error
+import http.client
+
+DEFAULT_HTTP_TIMEOUT = 10  # seconds
+
+
+# http://code.activestate.com/recipes/577548-https-httplib-client-connection-with-certificate-v/
+# http://stackoverflow.com/questions/1875052/using-paired-certificates-with-urllib2
+
+class HTTPSClientAuthHandler(urllib.request.HTTPSHandler):
+    """
+    Allows sending a client certificate with the HTTPS connection.
+    This version also validates the peer (server) certificate.
+    """
+
+    def __init__(self, key=None, cert=None, ca_certs=None):
+        self.ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        self.ctx.check_hostname = False
+        if ca_certs:
+            self.ctx.verify_mode = ssl.CERT_REQUIRED
+            self.ctx.load_verify_locations(ca_certs)
+        else:
+            self.ctx.verify_mode = ssl.CERT_NONE
+        if cert:
+            self.ctx.load_cert_chain(cert, key)
+        urllib.request.HTTPSHandler.__init__(self, context=self.ctx)
+
+    def https_open(self, req):
+        return self.do_open(self.get_connection, req)
+
+    def get_connection(self, host, timeout=DEFAULT_HTTP_TIMEOUT):
+        return HTTPSConnection(host, timeout=timeout, context=self.ctx)
+
+
+class HTTPSConnection(http.client.HTTPSConnection):
+    """
+    Overridden to allow peer certificate validation using an SSLContext.
+    """
+
+    def __init__(self, host, **kwargs):
+        self.ctx = kwargs.pop('context', None)
+        http.client.HTTPSConnection.__init__(self, host, **kwargs)
+
+    def connect(self):
+        sock = socket.create_connection((self.host, self.port), self.timeout)
+
+        if self._tunnel_host:
+            self.sock = sock
+            self._tunnel()
+
+        if self.ctx:
+            self.sock = self.ctx.wrap_socket(sock, server_hostname=self.host)
+        else:
+            self.sock = sock
+
+
+class MethodRequest(urllib.request.Request):
+    # See: https://gist.github.com/logic/2715756
+
+    def __init__(self, *args, **kwargs):
+        if 'method' in kwargs:
+            self._method = kwargs['method']
+            del kwargs['method']
+        else:
+            self._method = None
+        return urllib.request.Request.__init__(self, *args, **kwargs)
+
+    def get_method(self, *args, **kwargs):
+        return self._method if self._method is not None else urllib.request.Request.get_method(self, *args, **kwargs)
+
+
+class MotifError(Exception):
+    pass
+
+
+class MotifApiError(MotifError):
+    def __init__(self, message, code):
+        self.code = code
+        Exception.__init__(self, message)
+
+
+class MotifApi(object):
+
+    STREAM_TYPE_IMAGE = 1
+    STREAM_TYPE_STATE = 2
+
+    API = {r'version$': 'GET',
+           r'cameras$': 'GET',
+           r'cameras/configure$': 'PATCH',
+           r'cameras/read/(?P<name>[^\s /]+)$': 'GET',
+           r'camera/(?P<serial>[^\s /]+)$': 'GET',
+           r'camera/(?P<serial>[^\s /]+)/configure$': 'PATCH',
+           r'camera/(?P<serial>[^\s /]+)/read/(?P<name>[^\s /]+)$': 'GET',
+           r'camera/(?P<serial>[^\s /]+)/recording/start$': 'POST',
+           r'camera/(?P<serial>[^\s /]+)/recording/stop$': 'POST',
+           r'camera/(?P<serial>[^\s /]+)/recordings$': 'GET',
+           r'camera/(?P<serial>[^\s /]+)/recordings/copy_all$': 'POST',
+           r'camera/(?P<serial>[^\s /]+)/recordings/export_all$': 'POST',
+           r'camera/(?P<serial>[^\s /]+)/io/(?P<name>[^\s /]+)/set': 'POST',
+           r'camera/(?P<serial>[^\s /]+)/io/log': 'POST',
+           r'camera/(?P<serial>[^\s /]+)/io/read': 'GET',
+           r'recording/start$': 'POST',
+           r'recording/stop$': 'POST',
+           r'recordings$': 'GET',
+           r'recordings/copy_all$': 'POST',
+           r'recordings/export_all$': 'POST',
+           r'schedule$': 'GET',
+           r'schedule/clear$': 'POST',
+           r'schedule/(?P<identifier>[^\s /]+)/clear$': 'DELETE',
+           r'schedule/recording/start$': 'POST',
+           r'schedule/camera/(?P<serial>[^\s /]+)/recording/start$': 'POST',
+           r'schedule/recordings/copy_all': 'POST',
+           r'schedule/camera/(?P<serial>[^\s /]+)/recordings/copy_all$': 'POST',
+           r'schedule/recordings/export_all': 'POST',
+           r'schedule/camera/(?P<serial>[^\s /]+)/recordings/export_all$': 'POST',
+           r'schedule/io/(?P<name>[^\s /]+)/set': 'POST',
+           r'schedule/camera/(?P<serial>[^\s /]+)/io/(?P<name>[^\s /]+)/set': 'POST',
+           r'schedule/cameras/configure/(?P<name>[^\s /]+)': 'POST',
+           r'schedule/camera/(?P<serial>[^\s /]+)/configure/(?P<name>[^\s /]+)': 'POST',
+           r'io/(?P<io_serial>[^\s /]+)/(?P<io_port>[^\s /]+)/set': 'POST',
+           r'io/(?P<name>[^\s /]+)/set': 'POST',
+           r'io/log': 'POST',
+           r'io/read': 'GET',
+           r'camera/(?P<serial>[^\s /]+)/experiment/message$': 'POST',
+           r'experiment/message$': 'POST',
+           r'multicam/synchronize': 'POST',
+           r'multicam/connect_camera/(?P<serial>[^\s /]+)': 'POST',
+           r'multicam/disconnect_camera/(?P<serial>[^\s /]+)': 'POST',
+           r'multicam/connect_all': 'POST',
+           r'multicam/disconnect_all': 'POST',
+           }
+
+    def __init__(self, host=None, api_key=None, port=None, ca_cert=None, api_version=1):
+        self._log = logging.getLogger('motifapi')
+
+        if port is None:
+            try:
+                port = int(os.environ.get('MOTIF_PORT', 6083))
+            except:
+                port = 6083
+        else:
+            port = int(port)
+
+        if host is None:
+            try:
+                host = os.environ['MOTIF_HOST']
+                self._log.debug('took host from environment')
+            except KeyError:
+                pass
+            if not host:
+                host = '127.0.0.1'
+
+        if api_key is None:
+            try:
+                api_key = os.environ['MOTIF_API_KEY']
+                self._log.debug('took api_key from environment')
+            except KeyError:
+                pass
+            if not api_key:
+                try:
+                    api_key = subprocess.check_output(['recnode-apikey']).strip()
+                    self._log.debug('took api-key from recnode-apikey subprocess')
+                except OSError:
+                    pass
+
+        if not api_key:
+            raise ValueError('API key must be specified')
+
+        if ca_cert is None:
+            ca_cert = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'server.crt')
+
+        if not os.path.exists(ca_cert):
+            raise ValueError('could not find certificate: %s' % ca_cert)
+
+        self._prefix = 'api/%d/' % api_version
+
+        client_cert_key = None
+        client_cert_pem = None  # file path
+        handler = HTTPSClientAuthHandler(
+            key=client_cert_key,
+            cert=client_cert_pem,
+            ca_certs=ca_cert)
+        self._http = urllib.request.build_opener(handler)
+
+        self._host = host
+        self._api_key = api_key
+        self._port = port
+
+    def _build_request(self, endpoint, data=None, method='GET'):
+        if endpoint[0] == '/':
+            endpoint = endpoint[1:]
+
+        if endpoint != 'version':
+            endpoint = self._prefix + endpoint
+
+        if data is not None:
+            try:
+                data = json.dumps(data).encode("utf-8")
+            except TypeError:
+                raise ValueError('Arguments must be JSON serializable (they were %r)' % (data,))
+
+        url = 'https://%s:%s/%s' % (self._host, self._port, endpoint)
+
+        req = MethodRequest(url, data, method=method)
+        req.add_header('X-Api-Key', self._api_key)
+        req.add_header('Content-Type', 'application/json')
+
+        self._log.debug('%s %s (%d bytes %s)' % (method,
+                                                 url,
+                                                 0 if data is None else len(data),
+                                                 type(data)))
+
+        return req
+
+    def _call(self, req):
+        try:
+            resp = self._http.open(req)
+            data = resp.read()
+            resp.close()
+            return data
+        except urllib.error.HTTPError as e:
+            try:
+                raw = e.read()
+                err = json.loads(raw.decode('utf-8'))
+                exc = MotifApiError(err['error'], err['status_code'])
+            except Exception:
+                raise ValueError('unknown API error')
+            raise exc
+        except urllib.error.URLError:
+            raise MotifError('motif not running or reachable')
+
+    def call(self, endpoint, method=None, data=None, **kwargs):
+        meth = ep = None
+        for _ep, _meth in self.API.items():
+            if re.match(_ep, endpoint):
+                meth = _meth
+                ep = _ep
+                break
+
+        if meth is None:
+            raise ValueError("unknown endpoint '%s' (are you missing/adding '/')" % endpoint)
+
+        req = self._build_request(endpoint,
+                                  data=kwargs or None,
+                                  method=meth)
+        out = self._call(req)
+        if out:
+            try:
+                return json.loads(out.decode('utf-8'))
+            except ValueError as e:
+                raise ValueError('Invalid JSON response: %s' % e.message)
+        else:
+            return {}
+
+    def is_recording(self, serial):
+        r = self.call('camera/%s' % serial)
+        if r['camera_info'].get('filename'):
+            return True
+        elif r['camera_info'].get('status') == 'pending':
+            return True
+        return False
+
+    def is_copying(self, serial):
+        r = self.call('camera/%s' % serial)
+        return r['playback_info']['status'] == 'copying'
+
+    def is_exporting(self, serial):
+        r = self.call('camera/%s' % serial)
+        status = r['playback_info']['status']
+        return status.startswith('export') and ('finished' not in status)
+
+    def send_message(self, message, serial=None):
+        if serial:
+            return self.call('camera/%s/experiment/message' % serial, message=message)
+        return self.call('experiment/message', message=message)
+
+    def get_stream(self, serial=None, stream_type=STREAM_TYPE_IMAGE, force_host=None):
+        from .stream import ImageStreamer, StateStreamer
+
+        if serial is None:
+            try:
+                # get the first camera
+                for c in self.call('cameras').get('cameras', []):
+                    serial = c['serial']
+                    break
+            except (urllib.error.URLError, MotifApiError):
+                raise MotifError('motif not running or reachable')
+
+        if serial is None:
+            raise MotifError('no cameras connected or running')
+
+        def _get_host_port(_stream_name):
+            _stat = self.call('camera/%s' % serial)
+            _host = _stat['camera_info']['stream'][_stream_name]['host']
+            _port = int(_stat['camera_info']['stream'][_stream_name]['port'])
+
+            if force_host is not None:
+                _host = force_host
+            elif (_host == '0.0.0.0') and (self._host != '0.0.0.0'):
+                _host = self._host
+
+            return _host, _port
+
+        if stream_type in (MotifApi.STREAM_TYPE_IMAGE, MotifApi.STREAM_TYPE_STATE):
+            try:
+                if stream_type == MotifApi.STREAM_TYPE_IMAGE:
+                    host, port = _get_host_port('image')
+                    return ImageStreamer(host, port)
+                else:
+                    host, port = _get_host_port('state')
+                    return StateStreamer(host, port)
+            except (urllib.error.URLError, MotifApiError):
+                raise MotifError('camera with serial %s not found or running' % serial)
+            except KeyError:
+                raise MotifError('realtime stream not enabled on camera')
+        else:
+            raise ValueError('unknown stream type')
+
+
+

motifapi/schedule.py

@@ -0,0 +1,2 @@
+def datetime_to_cron(dt):
+    return '%d %d %d %d %d ?' % (dt.second, dt.minute, dt.hour, dt.day, dt.month)

motifapi/server.crt

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDGzCCAgOgAwIBAgIJAOjl0YTg0v1KMA0GCSqGSIb3DQEBCwUAMCQxCzAJBgNV
+BAYTAkFVMRUwEwYDVQQKDAxsb29wYmlvIGdtYmgwHhcNMTcxMDI4MTM1MDQzWhcN
+MjcxMDI2MTM1MDQzWjAkMQswCQYDVQQGEwJBVTEVMBMGA1UECgwMbG9vcGJpbyBn
+bWJoMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuBDT2rvtlC3z330H
+p5Zl1ilA4gvSM7Zlvpwt+kQETb7rCS49+oPaAa89tDEbwrk3rDzxnGG2+YL73h07
+YpTlJk/7WkciGgR7K83CwEiSVUUZsmxfXH/t0V5km4d+Ul7lRWoRI9BcnWu9Mvwr
+572NQJf0cWs0FJu5qYmY0nI7+EjN/qB7OFYYTYSJZQYwoRZzdGFNWCiTkxTBOQc/
+1dyPzmtMbRQONYryMqMHKLUeG4aEYwCsm2XNSTHn7JCxc/dHc8BnBMkAOqNp+XP+
+n4blQ6e4C4e4MWEk/yrv0p8u0m6NIoBvI/nZDhgvdIQTFrj+eIOSCPCtxzAQEnDd
+f9FEiQIDAQABo1AwTjAdBgNVHQ4EFgQU1kn+nli9zgqxumR2zgMFS5WljhgwHwYD
+VR0jBBgwFoAU1kn+nli9zgqxumR2zgMFS5WljhgwDAYDVR0TBAUwAwEB/zANBgkq
+hkiG9w0BAQsFAAOCAQEAdr76akM25qXFURAgWszcjJAaaimp9RRUaXwO5UxVegCR
+x1FCZyfm/TIWDgfKjlPFiPgCS3WBL0gLWummZhJ5YFwd0lI34H9KXl9JgKidyNrH
+aDHBj4On0eu84f6nMxqFPFDDscJLlMvmfBYRFq/7QryU/LuWeSWhn/oQs4vakoRH
+aJxzot67YvH9N8qxX/6Nc2TeEAz4X5AyEYe46mAc99rRROWjnYD39dfmWzv/5Cge
+42YwNxtba8njGyPnCb+/kKerc+jXNBoopBGECBsMyGx3p5cVCnz//NhgvWmvquEU
+msK/FxvWDIB5Y/KEfeaghB4D4hgy3IF9Z6T9ZBsLsg==
+-----END CERTIFICATE-----

motifapi/stream.py

@@ -0,0 +1,100 @@
+import sys
+import json
+import threading
+import logging
+
+import zmq
+import numpy as np
+
+
+if sys.version_info > (3,):
+    buffer = memoryview
+
+
+LOG = logging.getLogger('motifapi.stream')
+
+
+def recv_array(socket, flags=0, copy=True, track=False):
+    md = socket.recv_json(flags=flags)
+    msg = socket.recv(flags=flags, copy=copy, track=track)
+    # note: I don't actually think this is necessary, in PY2 this is type<str> and np.frombuffer(str) does
+    # the right thing, in PY3 this is type<bytes> which supports buffer protocol
+    buf = buffer(msg)
+    A = np.frombuffer(buf, dtype=md.pop('dtype'))
+    return A.reshape(md.pop('shape')), md
+
+
+class ImageStreamer(object):
+
+    stream = None
+
+    def __init__(self, host, port):
+        ctx = zmq.Context()
+        address = "tcp://%s:%d" % (host, port)
+        LOG.debug('image stream connecting to: %s' % address)
+        sock = ctx.socket(zmq.PULL)
+        sock.connect(address)
+        self.stream = sock
+
+    def get_next_image(self, block=True, copy=True):
+        while True:
+            while self.stream.poll(0, zmq.POLLIN):
+                return recv_array(self.stream, copy=copy)
+            if not block:
+                return None, None
+
+
+class StateStreamer(object):
+
+    def __init__(self, host, port, channel='j'):
+        ctx = zmq.Context()
+        address = "tcp://%s:%d" % (host, port)
+        LOG.debug('state stream connecting to: %s' % address)
+        sock = ctx.socket(zmq.SUB)
+        sock.connect(address)
+        sock.setsockopt(zmq.LINGER, 0)
+        if sys.version_info > (3,):
+            sock.setsockopt_string(zmq.SUBSCRIBE, channel)
+        else:
+            sock.setsockopt(zmq.SUBSCRIBE, channel)
+        self.stream = sock
+
+    def get_next_state(self, block=True):
+        while True:
+            _, msg = self.stream.recv_multipart()
+            return json.loads(msg)
+
+
+class StateMirror(threading.Thread):
+
+    daemon = True
+
+    def __init__(self, streamer):
+        assert isinstance(streamer, StateStreamer)
+        threading.Thread.__init__(self)
+        self._lock = threading.Lock()
+        self._state = {}
+        self._streamer = streamer
+
+    @property
+    def is_recording(self):
+        return self._state.get('is_recording', False)
+
+    @property
+    def frame_number(self):
+        return self._state.get('frame_number', None)
+
+    @property
+    def frame_time(self):
+        return self._state.get('frame_time', None)
+
+    def get_state(self, **extra):
+        with self._lock:
+            extra.update(self._state)
+            return extra
+
+    def run(self):
+        while True:
+            _, msg = self._streamer.stream.recv_multipart()
+            with self._lock:
+                self._state.update(json.loads(msg))

motifapi/util.py

@@ -0,0 +1,16 @@
+import os
+import json
+
+
+def get_experiment_metadata():
+    try:
+        mdf = os.environ['MOTIF_METADATA_JSON_PATH']
+        with open(mdf, 'r') as f:
+            return json.load(f)
+    except KeyError:
+        # not defined
+        pass
+    except Exception as exc:
+        print("Error parsing metadata file", exc)
+
+    return {}

motifapi-0.2.0.dist-info/METADATA

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: motifapi
+Version: 0.2.0
+Summary: Python interface to Motif recording systems
+Author: John Stowers
+Author-email: john@loopbio.com
+License: BSD
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.6
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: license
+Dynamic: requires-python
+Dynamic: summary
+
+Python interface to Motif recording systems

motifapi-0.2.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+motifapi/__init__.py,sha256=BJ_PWYb2B9QfBnMJuZW3O3COcc5vRN4Zk_gxkid7TUE,157
+motifapi/api.py,sha256=zkv2T52_vGKsxWyHU6YkZyyxwUZX0hsGokfCL7Qbs4M,11923
+motifapi/schedule.py,sha256=j6bhUfI69Xd-OsQ0FZgpDKxRn9Y4dxofAFLFe63q6lo,108
+motifapi/server.crt,sha256=T93bqtfNR8z83vWhPNtlwyr9mKqJrlWDBDUU0Rgw_zM,1139
+motifapi/stream.py,sha256=EkBbemtKJeQm9GdCcO2WWN8u6DNqCQznE9OpM43oY-A,2732
+motifapi/util.py,sha256=BXxxqBN6ocC15IBZr7aDlpnVlKl-WSDp1jSERX-5vKw,333
+motifapi-0.2.0.dist-info/METADATA,sha256=j__1XU-vKsfceEWRTTcMshLM4ep0U4XV9mOepjF_LUY,480
+motifapi-0.2.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+motifapi-0.2.0.dist-info/top_level.txt,sha256=2fm6i3MFwhkeeVTSo3o6ISjkyA0s57V3zk_yJQKZlRw,9
+motifapi-0.2.0.dist-info/RECORD,,

motifapi-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

motifapi-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+motifapi