+import datetime
+import logging
+
+RFC6415_TYPE = 'application/xrd+xml'
+RFC7033_TYPE = 'application/jrd+json'
+
+JRD_TYPES = ('application/jrd+json', 'application/xrd+json', 'application/json', 'text/json')
+XRD_TYPES = ('application/xrd+xml', 'text/xml')
+
+KNOWN_RELS = {
+ 'activity_streams': 'http://activitystrea.ms/spec/1.0',
+ 'app': ('http://apinamespace.org/atom', 'application/atomsvc+xml'),
+ 'avatar': 'http://webfinger.net/rel/avatar',
+ 'foaf': ('describedby', 'application/rdf+xml'),
+ 'hcard': 'http://microformats.org/profile/hcard',
+ 'oauth_access_token': 'http://apinamespace.org/oauth/access_token',
+ 'oauth_authorize': 'http://apinamespace.org/oauth/authorize',
+ 'oauth_request_token': 'http://apinamespace.org/oauth/request_token',
+ 'openid': 'http://specs.openid.net/auth/2.0/provider',
+ 'opensocial': 'http://ns.opensocial.org/2008/opensocial/activitystreams',
+ 'portable_contacts': 'http://portablecontacts.net/spec/1.0',
+ 'profile': 'http://webfinger.net/rel/profile-page',
+ 'updates_from': 'http://schemas.google.com/g/2010#updates-from',
+ 'ostatus_sub': 'http://ostatus.org/schema/1.0/subscribe',
+ 'salmon_endpoint': 'salmon',
+ 'salmon_key': 'magic-public-key',
+ 'webfist': 'http://webfist.org/spec/rel',
+ 'xfn': 'http://gmpg.org/xfn/11',
+
+ 'jrd': ('lrdd', 'application/json'),
+ 'webfinger': ('lrdd', 'application/jrd+json'),
+ 'xrd': ('lrdd', 'application/xrd+xml'),
+}
+
+logger = logging.getLogger("rd")
+
+
+def _is_str(s):
+ try:
+ return isinstance(s, str)
+ except NameError:
+ return isinstance(s, str)
+
+
+def loads(content, content_type):
+
+ from rd import jrd, xrd
+
+ content_type = content_type.split(";")[0]
+
+ if content_type in JRD_TYPES:
+ logger.debug("loads() loading JRD")
+ return jrd.loads(content)
+
+ elif content_type in XRD_TYPES:
+ logger.debug("loads() loading XRD")
+ return xrd.loads(content)
+
+ raise TypeError('Unknown content type')
+
+#
+# helper functions for host parsing and discovery
+#
+
+def parse_uri_components(resource, default_scheme='https'):
+ hostname = None
+ scheme = default_scheme
+
+ from urllib.parse import urlparse
+
+ parts = urlparse(resource)
+ if parts.scheme and parts.netloc:
+ scheme = parts.scheme
+ ''' FIXME: if we have https://user@some.example/ we end up with parts.netloc='user@some.example' here. '''
+ hostname = parts.netloc
+ path = parts.path
+
+ elif parts.scheme == 'acct' or (not parts.scheme and '@' in parts.path):
+ ''' acct: means we expect WebFinger to work, and RFC7033 requires https, so host-meta should support it too. '''
+ scheme = 'https'
+
+ ''' We should just have user@site.example here, but if it instead
+ is user@site.example/whatever/else we have to split it later
+ on the first slash character, '/'.
+ '''
+ hostname = parts.path.split('@')[-1]
+ path = None
+
+ ''' In case we have hostname=='site.example/whatever/else' we do the split
+ on the first slash, giving us 'site.example' and 'whatever/else'.
+ '''
+ if '/' in hostname:
+ (hostname, path) = hostname.split('/', maxsplit=1)
+ ''' Normalize path so it always starts with /, which is the behaviour of urlparse too. '''
+ path = '/' + path
+
+ else:
+ if not parts.path:
+ raise ValueError('No hostname could be deduced from arguments.')
+
+ elif '/' in parts.path:
+ (hostname, path) = parts.path.split('/', maxsplit=1)
+ ''' Normalize path so it always starts with /, which is the behaviour of urlparse too. '''
+ path = '/' + path
+ else:
+ hostname = parts.path
+ path = None
+
+ return (scheme, hostname, path)
+
+#
+# special XRD types
+#
+
+class Attribute(object):
+
+ def __init__(self, name, value):
+ self.name = name
+ self.value = value
+
+ def __cmp__(self, other):
+ return cmp(str(self), str(other))
+
+ def __eq__(self, other):
+ return str(self) == other
+
+ def __str__(self):
+ return "%s=%s" % (self.name, self.value)
+
+
+class Element(object):
+
+ def __init__(self, name, value, attrs=None):
+ self.name = name
+ self.value = value
+ self.attrs = attrs or {}
+
+
+class Title(object):
+
+ def __init__(self, value, lang=None):
+ self.value = value
+ self.lang = lang
+
+ def __cmp__(self, other):
+ return cmp(str(self), str(other))
+
+ def __eq__(self, other):
+ return str(self) == str(other)
+
+ def __str__(self):
+ if self.lang:
+ return "%s:%s" % (self.lang, self.value)
+ return self.value
+
+
+class Property(object):
+
+ def __init__(self, type_, value=None):
+ self.type = type_
+ self.value = value
+
+ def __cmp__(self, other):
+ return cmp(str(self), str(other))
+
+ def __eq__(self, other):
+ return str(self) == other
+
+ def __str__(self):
+ if self.value:
+ return "%s:%s" % (self.type, self.value)
+ return self.type
+
+
+#
+# special list types
+#
+
+class ListLikeObject(list):
+
+ def __setitem__(self, key, value):
+ value = self.item(value)
+ super(ListLikeObject, self).__setitem__(key, value)
+
+ def append(self, value):
+ value = self.item(value)
+ super(ListLikeObject, self).append(value)
+
+ def extend(self, values):
+ values = (self.item(value) for value in values)
+ super(ListLikeObject, self).extend(values)
+
+
+class AttributeList(ListLikeObject):
+
+ def __call__(self, name):
+ for attr in self:
+ if attr.name == name:
+ yield attr
+
+ def item(self, value):
+ if isinstance(value, (list, tuple)):
+ return Attribute(*value)
+ elif not isinstance(value, Attribute):
+ raise ValueError('value must be an instance of Attribute')
+ return value
+
+
+class ElementList(ListLikeObject):
+
+ def item(self, value):
+ if not isinstance(value, Element):
+ raise ValueError('value must be an instance of Type')
+ return value
+
+
+class TitleList(ListLikeObject):
+
+ def item(self, value):
+ if _is_str(value):
+ return Title(value)
+ elif isinstance(value, (list, tuple)):
+ return Title(*value)
+ elif not isinstance(value, Title):
+ raise ValueError('value must be an instance of Title')
+ return value
+
+
+class LinkList(ListLikeObject):
+
+ def __call__(self, rel):
+ for link in self:
+ if link.rel == rel:
+ yield link
+
+ def item(self, value):
+ if not isinstance(value, Link):
+ raise ValueError('value must be an instance of Link')
+ return value
+
+
+class PropertyList(ListLikeObject):
+
+ def __call__(self, type_):
+ for prop in self:
+ if prop.type == type_:
+ yield prop
+
+ def item(self, value):
+ if _is_str(value):
+ return Property(value)
+ elif isinstance(value, (tuple, list)):
+ return Property(*value)
+ elif not isinstance(value, Property):
+ raise ValueError('value must be an instance of Property')
+ return value
+
+
+#
+# Link object
+#
+
+class Link(object):
+
+ def __init__(self, rel=None, type=None, href=None, template=None):
+ self.rel = rel
+ self.type = type
+ self.href = href
+ self.template = template
+ self._titles = TitleList()
+ self._properties = PropertyList()
+
+ def get_titles(self):
+ return self._titles
+ titles = property(get_titles)
+
+ def get_properties(self):
+ return self._properties
+ properties = property(get_properties)
+
+ def apply_template(self, uri):
+
+ from urllib.parse import quote
+
+ if not self.template:
+ raise TypeError('This is not a template Link')
+ return self.template.replace('{uri}', quote(uri, safe=''))
+
+ def __str__(self):
+
+ from cgi import escape
+
+ attrs = ''
+ for prop in ['rel', 'type', 'href', 'template']:
+ val = getattr(self, prop)
+ if val:
+ attrs += ' {!s}="{!s}"'.format(escape(prop), escape(val))
+
+ return '<Link{!s}/>'.format(attrs)
+
+
+#
+# main RD class
+#
+
+class RD(object):
+
+ def __init__(self, xml_id=None, subject=None):
+
+ self.xml_id = xml_id
+ self.subject = subject
+ self._expires = None
+ self._aliases = []
+ self._properties = PropertyList()
+ self._links = LinkList()
+ self._signatures = []
+
+ self._attributes = AttributeList()
+ self._elements = ElementList()
+
+ # ser/deser methods
+
+ def to_json(self):
+ from rd import jrd
+ return jrd.dumps(self)
+
+ def to_xml(self):
+ from rd import xrd
+ return xrd.dumps(self)
+
+ # helper methods
+
+ def find_link(self, rels, attr=None, mimetype=None):
+ if not isinstance(rels, (list, tuple)):
+ rels = (rels,)
+ for link in self.links:
+ if link.rel in rels:
+ if mimetype and link.type != mimetype:
+ continue
+ if attr:
+ return getattr(link, attr, None)
+ return link
+
+ def __getattr__(self, name, attr=None):
+ if name in KNOWN_RELS:
+ try:
+ ''' If we have a specific mimetype for this rel value '''
+ rel, mimetype = KNOWN_RELS[name]
+ except ValueError:
+ rel = KNOWN_RELS[name]
+ mimetype = None
+ return self.find_link(rel, attr=attr, mimetype=mimetype)
+ raise AttributeError(name)
+
+ # custom elements and attributes
+
+ def get_elements(self):
+ return self._elements
+ elements = property(get_elements)
+
+ @property
+ def attributes(self):
+ return self._attributes
+
+ # defined elements and attributes
+
+ def get_expires(self):
+ return self._expires
+
+ def set_expires(self, expires):
+ if not isinstance(expires, datetime.datetime):
+ raise ValueError('expires must be a datetime object')
+ self._expires = expires
+ expires = property(get_expires, set_expires)
+
+ def get_aliases(self):
+ return self._aliases
+ aliases = property(get_aliases)
+
+ def get_properties(self):
+ return self._properties
+ properties = property(get_properties)
+
+ def get_links(self):
+ return self._links
+ links = property(get_links)
+
+ def get_signatures(self):
+ return self._signatures
+ signatures = property(get_links)
projects / friends.git / commitdiff
