django-rest-framework/djangorestframework/utils/__init__.py

import django
from django.utils.encoding import smart_unicode
from django.utils.xmlutils import SimplerXMLGenerator
from django.core.urlresolvers import resolve, reverse as django_reverse
from django.conf import settings

from djangorestframework.compat import StringIO

import re
import xml.etree.ElementTree as ET


#def admin_media_prefix(request):
#    """Adds the ADMIN_MEDIA_PREFIX to the request context."""
#    return {'ADMIN_MEDIA_PREFIX': settings.ADMIN_MEDIA_PREFIX}

from mediatypes import media_type_matches, is_form_media_type
from mediatypes import add_media_type_param, get_media_type_params, order_by_precedence

MSIE_USER_AGENT_REGEX = re.compile(r'^Mozilla/[0-9]+\.[0-9]+ \([^)]*; MSIE [0-9]+\.[0-9]+[a-z]?;[^)]*\)(?!.* Opera )')

def as_tuple(obj):
    """
    Given an object which may be a list/tuple, another object, or None,
    return that object in list form.

    IE:
    If the object is already a list/tuple just return it.
    If the object is not None, return it in a list with a single element.
    If the object is None return an empty list.
    """
    if obj is None:
        return ()
    elif isinstance(obj, list):
        return tuple(obj)
    elif isinstance(obj, tuple):
        return obj
    return (obj,)


def url_resolves(url):
    """
    Return True if the given URL is mapped to a view in the urlconf, False otherwise.
    """
    try:
        resolve(url)
    except Exception:
        return False
    return True


def allowed_methods(view):
    """
    Return the list of uppercased allowed HTTP methods on `view`.
    """
    return [method.upper() for method in view.http_method_names if hasattr(view, method)]


# From http://www.koders.com/python/fidB6E125C586A6F49EAC38992CF3AFDAAE35651975.aspx?s=mdef:xml
#class object_dict(dict):
#    """object view of dict, you can
#    >>> a = object_dict()
#    >>> a.fish = 'fish'
#    >>> a['fish']
#    'fish'
#    >>> a['water'] = 'water'
#    >>> a.water
#    'water'
#    >>> a.test = {'value': 1}
#    >>> a.test2 = object_dict({'name': 'test2', 'value': 2})
#    >>> a.test, a.test2.name, a.test2.value
#    (1, 'test2', 2)
#    """
#    def __init__(self, initd=None):
#        if initd is None:
#            initd = {}
#        dict.__init__(self, initd)
#
#    def __getattr__(self, item):
#        d = self.__getitem__(item)
#        # if value is the only key in object, you can omit it
#        if isinstance(d, dict) and 'value' in d and len(d) == 1:
#            return d['value']
#        else:
#            return d
#
#    def __setattr__(self, item, value):
#        self.__setitem__(item, value)


# From xml2dict
class XML2Dict(object):

    def __init__(self):
        pass

    def _parse_node(self, node):
        node_tree = {}
        # Save attrs and text, hope there will not be a child with same name
        if node.text:
            node_tree = node.text
        for (k,v) in node.attrib.items():
            k,v = self._namespace_split(k, v)
            node_tree[k] = v
        #Save childrens
        for child in node.getchildren():
            tag, tree = self._namespace_split(child.tag, self._parse_node(child))
            if  tag not in node_tree: # the first time, so store it in dict
                node_tree[tag] = tree
                continue
            old = node_tree[tag]
            if not isinstance(old, list):
                node_tree.pop(tag)
                node_tree[tag] = [old] # multi times, so change old dict to a list
            node_tree[tag].append(tree) # add the new one

        return  node_tree


    def _namespace_split(self, tag, value):
        """
           Split the tag  '{http://cs.sfsu.edu/csc867/myscheduler}patients'
             ns = http://cs.sfsu.edu/csc867/myscheduler
             name = patients
        """
        result = re.compile("\{(.*)\}(.*)").search(tag)
        if result:
            value.namespace, tag = result.groups()
        return (tag, value)

    def parse(self, file):
        """parse a xml file to a dict"""
        f = open(file, 'r')
        return self.fromstring(f.read())

    def fromstring(self, s):
        """parse a string"""
        t = ET.fromstring(s)
        unused_root_tag, root_tree = self._namespace_split(t.tag, self._parse_node(t))
        return root_tree


def xml2dict(input):
    return XML2Dict().fromstring(input)


# Piston:
class XMLRenderer():
    def _to_xml(self, xml, data):
        if isinstance(data, (list, tuple)):
            for item in data:
                xml.startElement("list-item", {})
                self._to_xml(xml, item)
                xml.endElement("list-item")

        elif isinstance(data, dict):
            for key, value in data.iteritems():
                xml.startElement(key, {})
                self._to_xml(xml, value)
                xml.endElement(key)

        elif data is None:
            # Don't output any value
            pass

        else:
            xml.characters(smart_unicode(data))

    def dict2xml(self, data):
        stream = StringIO.StringIO()

        xml = SimplerXMLGenerator(stream, "utf-8")
        xml.startDocument()
        xml.startElement("root", {})

        self._to_xml(xml, data)

        xml.endElement("root")
        xml.endDocument()
        return stream.getvalue()

def dict2xml(input):
    return XMLRenderer().dict2xml(input)


def reverse(viewname, request, *args, **kwargs):
    """
    Do the same as :py:func:`django.core.urlresolvers.reverse` but using
    *request* to build a fully qualified URL.
    """
    return request.build_absolute_uri(django_reverse(viewname, *args, **kwargs))

if django.VERSION >= (1, 4):
    from django.core.urlresolvers import reverse_lazy as django_reverse_lazy

    def reverse_lazy(viewname, request, *args, **kwargs):
        """
        Do the same as :py:func:`django.core.urlresolvers.reverse_lazy` but using
        *request* to build a fully qualified URL.
        """
        return request.build_absolute_uri(django_reverse_lazy(viewname, *args, **kwargs))