micawber 0.6.0__py3-none-any.whl

examples/django_ex/manage.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python
+from django.core.management import execute_manager
+import imp
+try:
+    imp.find_module('settings') # Assumed to be in the same directory.
+except ImportError:
+    import sys
+    sys.stderr.write("Error: Can't find the file 'settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n" % __file__)
+    sys.exit(1)
+
+import settings
+
+if __name__ == "__main__":
+    execute_manager(settings)

examples/django_ex/settings.py

@@ -0,0 +1,86 @@
+import os
+
+#### MICAWBER SETTINGS
+
+# add a template filter called "oembed_no_urlize" that will not automatically
+# convert URLs to clickable links in the event a provider is not found for
+# the given url
+MICAWBER_TEMPLATE_EXTENSIONS = [
+    ('oembed_no_urlize', {'urlize_all': False}),
+]
+
+# by default, micawber will use the "bootstrap_basic" providers, but should you
+# wish to use embedly you can try out the second example.  You can also provide
+# your own ProviderRegistry with a path to a module and either a callable or
+# ProviderRegistry instance
+MICAWBER_PROVIDERS = 'micawber.contrib.mcdjango.providers.bootstrap_basic'
+#MICAWBER_PROVIDERS = 'micawber.contrib.mcdjango.providers.bootstrap_embedly'
+
+# if you are using embed.ly you can specify an API key that will be used with
+# the bootstrap_embedly provider setting
+# MICAWBER_EMBEDLY_KEY = 'foofoo'
+
+# since template filters are limited to a single optional parameter, you can
+# specify defaults, such as a maxwidth you prefer to use or an api key
+#MICAWBER_DEFAULT_SETTINGS = {
+#    'key': 'your-embedly-api-key',
+#    'maxwidth': 600,
+#    'maxheight': 600,
+#}
+
+#### END MICAWBER SETTINGS
+
+CURRENT_DIR = os.path.dirname(__file__)
+
+DEBUG = True
+TEMPLATE_DEBUG = DEBUG
+
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.sqlite3',
+        'NAME': 'django_ex.db',
+    }
+}
+
+SITE_ID = 1
+
+SECRET_KEY = 'fapfapfap'
+
+STATIC_URL = '/static/'
+STATICFILES_DIRS = (
+    os.path.join(CURRENT_DIR, 'static'),
+)
+
+STATICFILES_FINDERS = (
+    'django.contrib.staticfiles.finders.FileSystemFinder',
+    'django.contrib.staticfiles.finders.AppDirectoriesFinder',
+)
+
+
+TEMPLATE_LOADERS = (
+    'django.template.loaders.filesystem.Loader',
+    'django.template.loaders.app_directories.Loader',
+)
+
+MIDDLEWARE_CLASSES = (
+    'django.middleware.common.CommonMiddleware',
+    'django.contrib.sessions.middleware.SessionMiddleware',
+    'django.middleware.csrf.CsrfViewMiddleware',
+    'django.contrib.auth.middleware.AuthenticationMiddleware',
+    'django.contrib.messages.middleware.MessageMiddleware',
+)
+
+ROOT_URLCONF = 'django_ex.urls'
+
+TEMPLATE_DIRS = (
+    os.path.join(CURRENT_DIR, 'templates'),
+)
+
+INSTALLED_APPS = (
+    'django.contrib.auth',
+    'django.contrib.contenttypes',
+    'django.contrib.sessions',
+    'django.contrib.sites',
+    'django.contrib.staticfiles',
+    'micawber.contrib.mcdjango',
+)

examples/django_ex/urls.py

@@ -0,0 +1,5 @@
+from django.conf.urls.defaults import patterns, include, url
+
+urlpatterns = patterns('',
+    url(r'^$', 'django_ex.views.example_view', name='example_view'),
+)

examples/django_ex/views.py

@@ -0,0 +1,14 @@
+from django.shortcuts import render_to_response
+
+def example_view(request):
+    text = request.GET.get('text', 'http://www.youtube.com/watch?v=nda_OSWeyn8')
+    html = request.GET.get('html', """
+<p>This is a test</p>
+<p>http://www.youtube.com/watch?v=nda_OSWeyn8</p>
+<p>This will get rendered as a link: http://www.youtube.com/watch?v=nda_OSWeyn8</p>
+<p>This will not be modified: <a href="http://www.google.com/">http://www.youtube.com/watch?v=nda_OSWeyn8</a></p>
+    """)
+    return render_to_response('example.html', dict(
+        text=text,
+        html=html,
+    ))

micawber/__init__.py

@@ -0,0 +1,17 @@
+__version__ = '0.6.0'
+
+from micawber.cache import Cache
+from micawber.cache import PickleCache
+from micawber.exceptions import ProviderException
+from micawber.exceptions import InvalidResponseException
+from micawber.parsers import extract
+from micawber.parsers import extract_html
+from micawber.parsers import parse_text
+from micawber.parsers import parse_text_full
+from micawber.parsers import parse_html
+from micawber.providers import Provider
+from micawber.providers import ProviderRegistry
+from micawber.providers import bootstrap_basic
+from micawber.providers import bootstrap_embedly
+from micawber.providers import bootstrap_noembed
+from micawber.providers import bootstrap_oembed

micawber/cache.py

@@ -0,0 +1,61 @@
+from __future__ import with_statement
+import os
+import pickle
+try:
+    from redis import Redis
+except ImportError:
+    Redis = None
+
+
+class Cache(object):
+    def __init__(self):
+        self._cache = {}
+
+    def get(self, k):
+        return self._cache.get(k)
+
+    def set(self, k, v):
+        self._cache[k] = v
+
+
+class PickleCache(Cache):
+    def __init__(self, filename='cache.db'):
+        self.filename = filename
+        self._cache = self.load()
+
+    def load(self):
+        if os.path.exists(self.filename):
+            with open(self.filename, 'rb') as fh:
+                return pickle.load(fh)
+        return {}
+
+    def save(self):
+        with open(self.filename, 'wb') as fh:
+            pickle.dump(self._cache, fh)
+
+
+if Redis:
+    class RedisCache(Cache):
+        """
+        :param str namespace: key prefix.
+        :param int timeout: expiration timeout in seconds
+        """
+        def __init__(self, namespace='micawber', timeout=None, **conn):
+            self.namespace = namespace
+            self.timeout = timeout
+            self.conn = Redis(**conn)
+
+        def key_fn(self, k):
+            return '%s.%s' % (self.namespace, k)
+
+        def get(self, k):
+            cached = self.conn.get(self.key_fn(k))
+            if cached:
+                return pickle.loads(cached)
+
+        def set(self, k, v):
+            ck, cv = self.key_fn(k), pickle.dumps(v)
+            if self.timeout is not None:
+                self.conn.setex(ck, cv, self.timeout)
+            else:
+                self.conn.set(ck, cv)

micawber/compat.py

@@ -0,0 +1,263 @@
+import sys
+
+PY3 = sys.version_info >= (3,)
+
+if PY3:
+    from urllib.request import Request, urlopen, URLError, HTTPError
+    from urllib.parse import urlencode
+    text_type = str
+    string_types = str,
+    def get_charset(response):
+        return response.headers.get_param('charset')
+else:
+    from urllib2 import Request, urlopen, URLError, HTTPError
+    from urllib import urlencode
+    text_type = unicode
+    string_types = basestring,
+    def get_charset(response):
+        return response.headers.getparam('charset')
+
+try:
+    from collections import OrderedDict
+except ImportError:
+    try:
+        from _abcoll import KeysView, ValuesView, ItemsView
+    except ImportError:
+        pass
+
+    class OrderedDict(dict):
+        'Dictionary that remembers insertion order'
+        # An inherited dict maps keys to values.
+        # The inherited dict provides __getitem__, __len__, __contains__, and get.
+        # The remaining methods are order-aware.
+        # Big-O running times for all methods are the same as for regular dictionaries.
+
+        # The internal self.__map dictionary maps keys to links in a doubly linked list.
+        # The circular doubly linked list starts and ends with a sentinel element.
+        # The sentinel element never gets deleted (this simplifies the algorithm).
+        # Each link is stored as a list of length three:  [PREV, NEXT, KEY].
+
+        def __init__(self, *args, **kwds):
+            '''Initialize an ordered dictionary.  Signature is the same as for
+            regular dictionaries, but keyword arguments are not recommended
+            because their insertion order is arbitrary.
+
+            '''
+            if len(args) > 1:
+                raise TypeError('expected at most 1 arguments, got %d' % len(args))
+            try:
+                self.__root
+            except AttributeError:
+                self.__root = root = []                     # sentinel node
+                root[:] = [root, root, None]
+                self.__map = {}
+            self.__update(*args, **kwds)
+
+        def __setitem__(self, key, value, dict_setitem=dict.__setitem__):
+            'od.__setitem__(i, y) <==> od[i]=y'
+            # Setting a new item creates a new link which goes at the end of the linked
+            # list, and the inherited dictionary is updated with the new key/value pair.
+            if key not in self:
+                root = self.__root
+                last = root[0]
+                last[1] = root[0] = self.__map[key] = [last, root, key]
+            dict_setitem(self, key, value)
+
+        def __delitem__(self, key, dict_delitem=dict.__delitem__):
+            'od.__delitem__(y) <==> del od[y]'
+            # Deleting an existing item uses self.__map to find the link which is
+            # then removed by updating the links in the predecessor and successor nodes.
+            dict_delitem(self, key)
+            link_prev, link_next, key = self.__map.pop(key)
+            link_prev[1] = link_next
+            link_next[0] = link_prev
+
+        def __iter__(self):
+            'od.__iter__() <==> iter(od)'
+            root = self.__root
+            curr = root[1]
+            while curr is not root:
+                yield curr[2]
+                curr = curr[1]
+
+        def __reversed__(self):
+            'od.__reversed__() <==> reversed(od)'
+            root = self.__root
+            curr = root[0]
+            while curr is not root:
+                yield curr[2]
+                curr = curr[0]
+
+        def clear(self):
+            'od.clear() -> None.  Remove all items from od.'
+            try:
+                for node in self.__map.itervalues():
+                    del node[:]
+                root = self.__root
+                root[:] = [root, root, None]
+                self.__map.clear()
+            except AttributeError:
+                pass
+            dict.clear(self)
+
+        def popitem(self, last=True):
+            '''od.popitem() -> (k, v), return and remove a (key, value) pair.
+            Pairs are returned in LIFO order if last is true or FIFO order if false.
+
+            '''
+            if not self:
+                raise KeyError('dictionary is empty')
+            root = self.__root
+            if last:
+                link = root[0]
+                link_prev = link[0]
+                link_prev[1] = root
+                root[0] = link_prev
+            else:
+                link = root[1]
+                link_next = link[1]
+                root[1] = link_next
+                link_next[0] = root
+            key = link[2]
+            del self.__map[key]
+            value = dict.pop(self, key)
+            return key, value
+
+        # -- the following methods do not depend on the internal structure --
+
+        def keys(self):
+            'od.keys() -> list of keys in od'
+            return list(self)
+
+        def values(self):
+            'od.values() -> list of values in od'
+            return [self[key] for key in self]
+
+        def items(self):
+            'od.items() -> list of (key, value) pairs in od'
+            return [(key, self[key]) for key in self]
+
+        def iterkeys(self):
+            'od.iterkeys() -> an iterator over the keys in od'
+            return iter(self)
+
+        def itervalues(self):
+            'od.itervalues -> an iterator over the values in od'
+            for k in self:
+                yield self[k]
+
+        def iteritems(self):
+            'od.iteritems -> an iterator over the (key, value) items in od'
+            for k in self:
+                yield (k, self[k])
+
+        def update(*args, **kwds):
+            '''od.update(E, **F) -> None.  Update od from dict/iterable E and F.
+
+            If E is a dict instance, does:           for k in E: od[k] = E[k]
+            If E has a .keys() method, does:         for k in E.keys(): od[k] = E[k]
+            Or if E is an iterable of items, does:   for k, v in E: od[k] = v
+            In either case, this is followed by:     for k, v in F.items(): od[k] = v
+
+            '''
+            if len(args) > 2:
+                raise TypeError('update() takes at most 2 positional '
+                                'arguments (%d given)' % (len(args),))
+            elif not args:
+                raise TypeError('update() takes at least 1 argument (0 given)')
+            self = args[0]
+            # Make progressively weaker assumptions about "other"
+            other = ()
+            if len(args) == 2:
+                other = args[1]
+            if isinstance(other, dict):
+                for key in other:
+                    self[key] = other[key]
+            elif hasattr(other, 'keys'):
+                for key in other.keys():
+                    self[key] = other[key]
+            else:
+                for key, value in other:
+                    self[key] = value
+            for key, value in kwds.items():
+                self[key] = value
+
+        __update = update  # let subclasses override update without breaking __init__
+
+        __marker = object()
+
+        def pop(self, key, default=__marker):
+            '''od.pop(k[,d]) -> v, remove specified key and return the corresponding value.
+            If key is not found, d is returned if given, otherwise KeyError is raised.
+
+            '''
+            if key in self:
+                result = self[key]
+                del self[key]
+                return result
+            if default is self.__marker:
+                raise KeyError(key)
+            return default
+
+        def setdefault(self, key, default=None):
+            'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'
+            if key in self:
+                return self[key]
+            self[key] = default
+            return default
+
+        def __repr__(self):
+            if not self:
+                return '%s()' % (self.__class__.__name__,)
+            return '%s(%r)' % (self.__class__.__name__, self.items())
+
+        def __reduce__(self):
+            'Return state information for pickling'
+            items = [[k, self[k]] for k in self]
+            inst_dict = vars(self).copy()
+            for k in vars(OrderedDict()):
+                inst_dict.pop(k, None)
+            if inst_dict:
+                return (self.__class__, (items,), inst_dict)
+            return self.__class__, (items,)
+
+        def copy(self):
+            'od.copy() -> a shallow copy of od'
+            return self.__class__(self)
+
+        @classmethod
+        def fromkeys(cls, iterable, value=None):
+            '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S
+            and values equal to v (which defaults to None).
+
+            '''
+            d = cls()
+            for key in iterable:
+                d[key] = value
+            return d
+
+        def __eq__(self, other):
+            '''od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
+            while comparison to a regular mapping is order-insensitive.
+
+            '''
+            if isinstance(other, OrderedDict):
+                return len(self)==len(other) and self.items() == other.items()
+            return dict.__eq__(self, other)
+
+        def __ne__(self, other):
+            return not self == other
+
+        # -- the following methods are only used in Python 2.7 --
+
+        def viewkeys(self):
+            "od.viewkeys() -> a set-like object providing a view on od's keys"
+            return KeysView(self)
+
+        def viewvalues(self):
+            "od.viewvalues() -> an object providing a view on od's values"
+            return ValuesView(self)
+
+        def viewitems(self):
+            "od.viewitems() -> a set-like object providing a view on od's items"
+            return ItemsView(self)

micawber/contrib/mcdjango/__init__.py

@@ -0,0 +1,92 @@
+from collections.abc import Callable
+from importlib import import_module
+
+from django import template
+from django.conf import settings
+from django.template.loader import render_to_string
+from django.utils.safestring import mark_safe
+
+from micawber.compat import string_types
+from micawber.parsers import full_handler, inline_handler, parse_text, \
+    parse_html, extract, extract_html
+
+
+def _load_from_module(path):
+    package, attr = path.rsplit('.', 1)
+    module = import_module(package)
+    return getattr(module, attr)
+
+
+PROVIDERS = getattr(settings, 'MICAWBER_PROVIDERS', 'micawber.contrib.mcdjango.providers.bootstrap_basic')
+
+providers = _load_from_module(PROVIDERS)
+if isinstance(providers, Callable):
+    providers = providers()
+
+
+register = template.Library()
+
+def django_template_handler(url, response_data, **params):
+    names = (
+        response_data.get('provider_name'),
+        response_data['type'],
+    )
+    template_names = ['micawber/%s.html' % name for name in names if name]
+    return mark_safe(
+        render_to_string(
+            template_names,
+            {'params': params,
+             'response': response_data,
+             'url': url,
+            }).strip())
+
+def fix_width_height(width_height, params):
+    if width_height:
+        if 'x' in width_height:
+            params['maxwidth'], params['maxheight'] = [int(n) for n in  width_height.split('x')]
+        else:
+            params['maxwidth'] = int(width_height)
+            params.pop('maxheight', None)
+    return params
+
+def extension(filter_name, providers=providers, urlize_all=True, html=False, handler=django_template_handler,
+              block_handler=inline_handler, text_fn=parse_text, html_fn=parse_html, **kwargs):
+    if html:
+        fn = html_fn
+    else:
+        fn = text_fn
+    def _extension(s, width_height=None):
+        params = getattr(settings, 'MICAWBER_DEFAULT_SETTINGS', {})
+        params.update(kwargs)
+        params = fix_width_height(width_height, params)
+        return mark_safe(fn(s, providers, urlize_all, handler, block_handler, **params))
+    register.filter(filter_name, _extension)
+    return _extension
+
+oembed = extension('oembed')
+oembed_html = extension('oembed_html', html=True)
+
+def _extract_oembed(text, width_height=None, html=False):
+    if html:
+        fn = extract_html
+    else:
+        fn = extract
+    params = getattr(settings, 'MICAWBER_DEFAULT_SETTINGS', {})
+    params = fix_width_height(width_height, params)
+    url_list, url_data = fn(text, providers, **params)
+    return [(u, url_data[u]) for u in url_list if u in url_data]
+
+@register.filter
+def extract_oembed(text, width_height=None):
+    return _extract_oembed(text, width_height)
+
+@register.filter
+def extract_oembed_html(text, width_height=None):
+    return _extract_oembed(text, width_height, True)
+
+user_extensions = getattr(settings, 'MICAWBER_TEMPLATE_EXTENSIONS', [])
+if isinstance(user_extensions, string_types):
+    user_extensions = _load_from_module(user_extensions)
+
+for filter_name, filter_params in user_extensions:
+    extension(filter_name, **filter_params)

micawber/contrib/mcdjango/mcdjango_tests/tests.py

@@ -0,0 +1,119 @@
+from django.template import Context
+from django.template import Template
+from django.test import TestCase
+
+from micawber.parsers import parse_text
+from micawber.test_utils import BaseTestCase
+from micawber.test_utils import test_cache
+from micawber.test_utils import test_pr
+from micawber.test_utils import test_pr_cache
+from micawber.test_utils import TestProvider
+
+
+class MicawberDjangoTestCase(TestCase, BaseTestCase):
+    def render(self, s, **params):
+        s = '{%% load micawber_tags %%}%s' % s
+        return Template(s).render(Context(params)).strip()
+
+    def test_oembed_alt(self):
+        from micawber.contrib.mcdjango import extension
+
+        def custom_handler(url, response_data):
+            return url
+
+        oembed_alt = extension(
+            'oembed_alt',
+            urlize_all=False,
+            block_handler=custom_handler)
+
+        text = '\n'.join((
+            'this is the first line',
+            'http://photo-test2',
+            'this is the third line http://photo-test2',
+            'http://photo-test2 this is the fourth line'))
+        rendered = self.render('{{ text|oembed_alt }}', text=text)
+        self.assertEqual(rendered.splitlines(), [
+            'this is the first line',
+            self.full_pairs['http://photo-test2'],
+            'this is the third line http://photo-test2',
+            'http://photo-test2 this is the fourth line',
+        ])
+
+    def test_fix_wh(self):
+        from micawber.contrib.mcdjango import fix_width_height
+        self.assertEqual(fix_width_height('300x400', {}), {'maxwidth': 300, 'maxheight': 400})
+        self.assertEqual(fix_width_height('300', {}), {'maxwidth': 300})
+
+    def test_provider_loading(self):
+        from micawber.contrib.mcdjango import providers
+        self.assertEqual(providers, test_pr)
+
+    def test_oembed_filter_multiline_plain(self):
+        for url, expected in self.full_pairs.items():
+            expected_inline = self.inline_pairs[url]
+            frame = 'this is inline: %s\n%s\nand yet another %s'
+
+            test_str = frame % (url, url, url)
+
+            parsed = self.render('{{ test_str|oembed }}', test_str=test_str)
+            self.assertEqual(parsed, frame % (expected_inline, expected, expected_inline))
+
+    def test_oembed_filter_multiline_html(self):
+        for url, expected in self.full_pairs.items():
+            expected_inline = self.inline_pairs[url]
+            frame = '<p>%s</p>\n<p>this is inline: %s</p>\n<p>\n%s\n</p><p>last test\n%s\n</p>'
+
+            test_str = frame % (url, url, url, url)
+
+            parsed = self.render('{{ test_str|oembed_html }}', test_str=test_str)
+            self.assertHTMLEqual(parsed, frame % (expected, expected_inline, expected, expected_inline))
+
+        for url, expected in self.full_pairs.items():
+            expected_inline = self.inline_pairs[url]
+            frame = '<p><a href="#foo">%s</a></p>\n<p>this is inline: %s</p>\n<p>last test\n%s\n</p>'
+
+            test_str = frame % (url, url, url)
+
+            parsed = self.render('{{ test_str|oembed_html }}', test_str=test_str)
+            self.assertHTMLEqual(parsed, frame % (url, expected_inline, expected_inline))
+
+    def test_urlize(self):
+        u1 = 'http://fappio.com/'
+        u2 = 'http://google.com/fap/'
+        u1h = '<a href="%s">%s</a>' % (u1, u1)
+        u2h = '<a href="%s">%s</a>' % (u2, u2)
+        for url, expected in self.full_pairs.items():
+            expected_inline = self.inline_pairs[url]
+            frame = 'test %s\n%s\n%s\nand another %s'
+
+            test_str = frame % (u1, u2, url, url)
+
+            parsed = self.render('{{ test_str|oembed }}', test_str=test_str)
+            self.assertEqual(parsed, frame % (u1h, u2h, expected, expected_inline))
+
+    def test_oembed_filter_extension(self):
+        for url, expected in self.full_pairs.items():
+            expected_inline = self.inline_pairs[url]
+            frame = 'test http://fappio.com\nhttp://google.com\n%s\nand another %s'
+
+            test_str = frame % (url, url)
+
+            parsed = self.render('{{ test_str|oembed_no_urlize }}', test_str=test_str)
+            self.assertEqual(parsed, frame % (expected, expected_inline))
+
+    def test_extract_filter(self):
+        blank = 'http://fapp.io/foo/'
+        frame = 'test %s\n%s\n%s\n%s at last'
+        frame_html = '<p>test %s</p><p><a href="foo">%s</a> %s</p><p>%s</p>'
+
+        t = """{% for url, data in test_str|extract_oembed %}{{ url }}\n{% endfor %}"""
+        t2 = """{% for url, data in test_str|extract_oembed_html %}{{ url }}\n{% endfor %}"""
+
+        for url, expected in self.data_pairs.items():
+            test_str = frame % (url, blank, url, blank)
+            rendered = self.render(t, test_str=test_str)
+            self.assertEqual(rendered, url)
+
+            test_str = frame_html % (url, blank, url, blank)
+            rendered = self.render(t, test_str=test_str)
+            self.assertEqual(rendered, url)