morp 7.0.0__py3-none-any.whl

morp/__init__.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+
+from .config import (
+    DsnConnection,
+    Connection,
+)
+from .interface import (
+    get_interface,
+    set_interface,
+    get_interfaces,
+    configure_environ,
+    find_environ,
+)
+from .message import Message
+from .exception import (
+    InterfaceError,
+    ReleaseMessage,
+    AckMessage,
+)
+
+
+__version__ = "7.0.0"
+

morp/compat.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+from datatypes.compat import *
+from datatypes import String, ByteString
+

morp/config.py

@@ -0,0 +1,173 @@
+# -*- coding: utf-8 -*-
+import base64
+
+import dsnparse
+from datatypes import ReflectName
+from datatypes import property as cachedproperty
+from datatypes.config import Environ
+
+
+from .compat import *
+
+
+class Connection(object):
+    """The base connection class, you will most likely always use DsnConnection
+    """
+    name = ""
+    """str, the name of this connection, handy when you have more than one used
+    interface (eg, nsq)"""
+
+    username = ""
+    """str, the username (if needed)"""
+
+    password = ""
+    """str, the password (if needed)"""
+
+    hosts = None
+    """list, a list of (hostname, port) tuples"""
+
+    path = None
+    """str, the path (if applicable)"""
+
+    interface_name = ""
+    """str, full Interface class name -- the interface that will connect to the
+    messaging backend"""
+
+    options = None
+    """dict, any other interface specific options you need"""
+
+    @property
+    def interface_class(self):
+        interface_class = ReflectName(self.interface_name).get_class()
+        return interface_class
+
+    @property
+    def interface(self):
+        interface_class = self.interface_class
+        return interface_class(self)
+
+    @property
+    def serializer(self):
+        serializer = self.options.get("serializer", "pickle")
+        if serializer not in set(["pickle", "json"]):
+            raise ValueError(f"Unknown serializer {serializer}")
+        return serializer
+
+    @cachedproperty(cached="_key")
+    def key(self):
+        """string -- an encryption key loaded from options['key'],
+        it must be 32 bytes long so this makes sure it is"""
+        key = self.options.get('key', "")
+        if key:
+            # Fernet key must be 32 url-safe base64-encoded bytes
+            bs = ByteString(ByteString(key).sha256())
+            key = base64.b64encode(bs[:32])
+        return key
+
+    def __init__(self, **kwargs):
+        """set all the values by passing them into this constructor, any
+        unrecognized kwargs get put into .options
+
+        :example:
+            c = Connection(
+                interface_name="...",
+                hosts=[("host", port), ("host2", port2)],
+                some_random_thing="foo"
+            )
+
+            print c.port # 5000
+            print c.options # {"some_random_thing": "foo"}
+        """
+        self.options = kwargs.pop('options', {})
+        self.hosts = []
+
+        for key, val in kwargs.items():
+            if hasattr(self, key):
+                setattr(self, key, val)
+
+            else:
+                self.options[key] = val
+
+        # 1 hour to process message
+        self.options.setdefault('max_timeout', 3600)
+
+        # failure backoff multiplier
+        self.options.setdefault('backoff_multiplier', 5)
+
+    def get_netlocs(self, default_port):
+        return [
+            "{}:{}".format(
+                h[0],
+                default_port if h[1] is None else h[1]
+            ) for h in self.hosts
+        ]
+
+    def get_option(self, key, default_val):
+        return getattr(self.options, key, default_val)
+
+
+class DsnConnection(Connection):
+    """
+    Create a connection object from a dsn in the form
+
+        InterfaceName://username:password@host:port?opt1=val1#connection_name
+
+    example -- connect to amazon SQS
+
+        morp.interface.sqs.SQS://AWS_ID:AWS_KEY@
+    """
+    def __init__(self, dsn):
+        self.dsn = dsn
+        d = self.parse(dsn)
+        super().__init__(**d)
+
+    def parse(self, dsn):
+        d = {'options': {}, 'hosts': []}
+        parser = dsnparse.parse(dsn)
+        p = parser.fields
+        d["dsn"] = parser.parser.dsn
+
+        # get the scheme, which is actually our interface_name
+        d['interface_name'] = self.normalize_scheme(p["scheme"])
+
+        dsn_hosts = []
+        if p["hostname"]:
+            d['hosts'].append((p["hostname"], p.get('port', None)))
+
+        d['options'] = p["query_params"] or {}
+        d['name'] = p["fragment"]
+        d['username'] = p["username"]
+        d['password'] = p["password"]
+        d["path"] = p["path"]
+
+        return d
+
+    def normalize_scheme(self, v):
+        ret = v
+        d = {
+            "morp.interface.sqs:SQS": set(["sqs"]),
+            "morp.interface.dropfile:Dropfile": set(["dropfile", "file"]),
+            "morp.interface.postgres:Postgres": set([
+                "postgres",
+                "postgresql",
+                "psql",
+            ]),
+        }
+
+        kv = v.lower()
+        for interface_name, vals in d.items():
+            if kv in vals:
+                ret = interface_name
+                break
+
+        return ret
+
+
+environ = Environ("MORP_") # Load any MORP_* environment variables
+
+environ.setdefault('DISABLED', False, type=bool)
+"""If set to 1 then messages won't actually be sent"""
+
+environ.setdefault('PREFIX', '')
+"""This prefix will be used to create the queue, see Message.get_name()"""
+

morp/exception.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals, division, print_function, absolute_import
+
+
+class Error(Exception):
+    """error wrapper"""
+    def __init__(self, e, exc_info=None):
+        self.e = e
+        self.exc_info = exc_info
+        super(Error, self).__init__(str(e))
+
+
+class InterfaceError(Error):
+    """specifically for wrapping interface errors"""
+    pass
+
+
+class ReleaseMessage(InterfaceError):
+    """Can be raised anytime in a recv() with block or target() method to get the
+    message to be released
+
+    :param delay_seconds: int, how long until message is released to be processed
+        again, the visibility timeout 
+    """
+    def __init__(self, delay_seconds=0):
+        super(ReleaseMessage, self).__init__("")
+        self.delay_seconds = delay_seconds
+
+
+class AckMessage(InterfaceError):
+    """Can be raised anytime in a recv() with block or target() method to get the
+    message to be acknowledged"""
+    def __init__(self):
+        super(AckMessage, self).__init__("")
+

morp/interface/__init__.py

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+
+import dsnparse
+
+from ..compat import *
+from ..config import DsnConnection
+
+
+interfaces = {}
+"""holds all configured interfaces"""
+
+
+def get_interfaces():
+    global interfaces
+    if not interfaces:
+        configure_environ()
+    return interfaces
+
+
+def get_interface(connection_name=""):
+    """get the configured interface that corresponds to connection_name"""
+    global interfaces
+    if not interfaces:
+        configure_environ()
+    return interfaces[connection_name]
+
+
+def set_interface(interface, connection_name=""):
+    """bind an .interface.Interface() instance to connection_name"""
+    global interfaces
+    interfaces[connection_name] = interface
+
+
+def find_environ(dsn_env_name='MORP_DSN', connection_class=DsnConnection):
+    """Returns Connection instances found in the environment
+
+    configure interfaces based on environment variables
+
+    by default, when morp is imported, it will look for MORP_DSN, and MORP_DSN_N
+    (where N is 1 through infinity) in the environment, if it finds them, it
+    will assume they are dsn urls that morp understands and will configure
+    connections with them. If you don't want this behavior (ie, you want to
+    configure morp manually) then just make sure you don't have any environment
+    variables with matching names
+
+    The num checks (eg MORP_DSN_1, MORP_DSN_2) go in order, so you can't do
+    MORP_DSN_1, MORP_DSN_3, because it will fail on _2 and move on, so make sure
+    your num dsns are in order (eg, 1, 2, 3, ...)
+
+    :param dsn_env_name: str, the environment variable name to find the DSN,
+        this will aslo check for values of <dsn_env_name>_N where N is 1 -> N,
+        so you can configure multiple DSNs in the environment and this will pick
+        them all up
+    :param connection_class: Connection, the class that will receive the dsn
+        values
+    :returns: generator<connection_class>
+    """
+    return dsnparse.parse_environs(dsn_env_name, parse_class=connection_class)
+
+
+def configure_environ():
+    """auto hook to configure the environment"""
+    for c in find_environ():
+        inter = c.interface
+        set_interface(c.interface, c.name)
+
+
+def configure(dsn, connection_class=DsnConnection):
+    """
+    configure an interface to be used to send messages to a backend
+
+    you use this function to configure an Interface using a dsn, then you can
+    get that interface using the get_interface() method
+
+    :param dsn: string, a properly formatted morp dsn, see DsnConnection for how
+        to format the dsn
+    """
+    #global interfaces
+    c = dsnparse.parse(dsn, parse_class=connection_class)
+    set_interface(c.interface, c.name)
+