First commit

Author: cwacek

MANIFEST.in

@@ -0,0 +1,3 @@
+include requirements.txt
+include README.md
+

development.txt

@@ -0,0 +1,2 @@
+nose==1.3.0
+rednose==0.4.1

python_jsonschema_objects/__init__.py

@@ -0,0 +1,285 @@
+import util
+import validators
+
+
+class ProtocolBase(object):
+    __propinfo__ = {}
+    __required__ = set()
+
+    __SCHEMA_TYPES__ = {
+        'array': list,
+        'boolean': bool,
+        'integer': int,
+        'number': float,
+        'null': None,
+        'string': unicode,
+        'object': dict
+    }
+
+    def __str__(self):
+        return repr(self)
+
+    def __repr__(self):
+        props = ["%s=%s" % (k, str(v)) for k, v in
+                 self._properties.iteritems()]
+        return "<%s %s>" % (
+            self.__class__.__name__,
+            " ".join(props)
+        )
+
+    def __init__(this, **props):
+        for prop in props:
+            try:
+                propname = this.__prop_names__[prop]
+            except KeyError:
+                raise AttributeError(
+                    "{0} is not valid property "
+                    "of '{1}'".format(prop,
+                                      this.__class__))
+
+            setattr(this, propname, props[prop])
+
+    @classmethod
+    def propinfo(cls, propname):
+        if propname not in cls.__propinfo__:
+            return {}
+        return cls.__propinfo__[propname]
+
+    def serialize(self):
+        enc = util.ProtocolJSONEncoder()
+        return enc.encode(self)
+
+    def validate(this):
+        missing = [x for x in this.__required__
+                   if this._properties[x] is None]
+
+        if len(missing) > 0:
+            raise validators.ValidationError(
+                "'{0}' are required attributes for {1}"
+                            .format(missing, this.__class__))
+
+        for prop, val in this._properties.iteritems():
+            info = this.propinfo(prop)
+
+            for param, paramval in info.iteritems():
+                validator = getattr(validators, param, None)
+                if validator is not None:
+                    validator(paramval, val)
+
+        return True
+
+    def validate_property(self, propinfo, propval):
+        """Validate a property value, and return true or false
+
+        :propinfo: A dictionary containing property info
+        :propval: The property value
+        :returns: True or False
+        """
+
+
+class ClassBuilder(object):
+
+    def __init__(self, resolver):
+        self.resolver = resolver
+        self.resolved = {}
+
+    def resolve_classes(self, iterable):
+        pp = []
+        for elem in iterable:
+            if '$ref' in elem:
+                ref = elem['$ref']
+                uri = util.resolve_ref_uri(self.resolver.resolution_scope, ref)
+                if uri in self.resolved:
+                    pp.append(self.resolved[uri])
+                else:
+                    with self.resolver.resolving(ref) as resolved:
+                        self.resolved[uri] = self.construct(
+                            uri,
+                            resolved,
+                            (ProtocolBase,))
+                        pp.append(self.resolved[uri])
+            else:
+                pp.append(elem)
+
+        return pp
+
+    def construct(self, uri, clsdata, parent=(ProtocolBase,)):
+        if 'oneOf' in clsdata:
+            potential_parents = self.resolve_classes(clsdata['oneOf'])
+
+            for p in potential_parents:
+                if issubclass(p, ProtocolBase):
+                    self.resolved[uri] = self._build_object(
+                        uri,
+                        clsdata,
+                        (p,))
+                else:
+                    raise Exception("Don't know how to deal with this")
+
+        elif 'anyOf' in clsdata:
+            raise NotImplementedError(
+                "anyOf is not supported as bare property")
+
+        elif 'allOf' in clsdata:
+            potential_parents = self.resolve_classes(clsdata['allOf'])
+            parents = []
+            for p in potential_parents:
+                if isinstance(p, dict):
+                    # This is additional constraints
+                    clsdata.update(p)
+                elif issubclass(p, ProtocolBase):
+                    parents.append(p)
+
+            self.resolved[uri] = self._build_object(
+                uri,
+                clsdata,
+                parents)
+            return self.resolved[uri]
+
+        elif '$ref' in clsdata:
+
+            if uri in self.resolved:
+                return self.resolved[uri]
+            else:
+                reffed_doc = self.resolver.resolve_remote(uri)
+                self.resolved[uri] = self._build_object(
+                    uri,
+                    reffed_doc,
+                    parent)
+                return self.resolved[uri]
+
+        elif (clsdata.get('type', None) == 'object' or
+              clsdata.get('properties', None) is not None):
+            self.resolved[uri] = self._build_object(
+                uri,
+                clsdata,
+                parent)
+            return self.resolved[uri]
+        else:
+            raise NotImplementedError(
+                "Unable to parse schema object with "
+                "no type and no reference")
+
+    def _build_object(self, nm, clsdata, parents):
+
+        props = {}
+
+        properties = {}
+        for p in parents:
+            properties = util.propmerge(properties, p.__propinfo__)
+
+        if 'properties' in clsdata:
+            properties = util.propmerge(properties, clsdata['properties'])
+
+        name_translation = {}
+
+        for prop, detail in properties.items():
+            properties[prop]['raw_name'] = prop
+            name_translation[prop] = prop.replace('@', '')
+            prop = name_translation[prop]
+
+            if 'type' not in detail and '$ref' in detail:
+                ref = detail['$ref']
+                uri = util.resolve_ref_uri(self.resolver.resolution_scope, ref)
+                if uri in self.resolved:
+                    props[prop] = make_property(prop,
+                                                {'type': self.resolved[uri]},
+                                                self.resolved[uri].__doc__)
+                    properties[prop]['$ref'] = uri
+                    properties[prop]['type'] = self.resolved[uri]
+                else:
+                    with self.resolver.resolving(ref) as resolved:
+                        self.resolved[uri] = self.construct(
+                            uri,
+                            resolved,
+                            (ProtocolBase,))
+            elif 'oneOf' in detail:
+                potential = self.resolve_classes(detail['oneOf'])
+                desc = detail[
+                    'description'] if 'description' in detail else ""
+                props[prop] = make_property(prop,
+                                            {'type': potential}, desc
+                                            )
+
+            else:
+                desc = detail[
+                    'description'] if 'description' in detail else ""
+
+                props[prop] = make_property(prop, detail, desc)
+
+        props['_properties'] = dict(zip(props.keys(),
+                                        [None for x in
+                                         xrange(len(props.keys()))]))
+
+        """ If this object itself has a 'oneOf' designation, then
+        make the validation 'type' the list of potential objects.
+        """
+        if 'oneOf' in clsdata:
+            klasses = self.resolve_classes(clsdata['oneOf'])
+            # Need a validation to check that it meets one of them
+            props['__validation__'] = {'type': klasses}
+
+        props['__prop_names__'] = name_translation
+
+        props['__propinfo__'] = properties
+        required = set.union(*[p.__required__ for p in parents])
+
+        if 'required' in clsdata:
+            for prop in clsdata['required']:
+                required.add(prop.replace('@', ''))
+
+        props['__required__'] = required
+
+        cls = type(str(nm.split('/')[-1]), tuple(parents), props)
+
+        return cls
+
+
+def make_property(prop, info, desc=""):
+
+    def getprop(this):
+        try:
+            return this._properties[prop]
+        except KeyError:
+            raise AttributeError("No such attribute")
+
+    def setprop(this, val):
+        if isinstance(info['type'], (list, tuple)):
+            ok = False
+            for typ in info['type']:
+                if isinstance(val, typ):
+                    ok = True
+                    break
+                elif not isinstance(val, ProtocolBase):
+                    try:
+                        val = typ(**val)
+                    except:
+                        pass
+                    else:
+                        val.validate()
+                        ok = True
+                        break
+
+            if not ok:
+                raise TypeError(
+                    "Value must be one of {0}".format(info['type']))
+
+        if info['type'] in this.__SCHEMA_TYPES__.keys() and val
+            is not None:
+            val = this.__SCHEMA_TYPES__[info['type']](val)
+
+        elif issubclass(info['type'], ProtocolBase):
+            if not isinstance(val, info['type']):
+                val = info['type'](**val)
+
+            val.validate()
+
+        this._properties[prop] = val
+
+    def delprop(this):
+        if prop in this.__required__:
+            raise AttributeError("'%s' is required" % prop)
+        else:
+            del this._properties[prop]
+
+    return property(getprop, setprop, delprop, desc)

python_jsonschema_objects/classbuilder.py

@@ -0,0 +1,77 @@
+import markdown
+from markdown.extensions import Extension
+from markdown.preprocessors import Preprocessor
+import re
+import json
+
+
+def extract_code_blocks(filename):
+    with open(filename) as fin:
+        doc = fin.read().split("\n")
+
+    M = markdown.Markdown(extensions=[SpecialFencedCodeExtension()])
+
+    for prep in M.preprocessors.values():
+        doc = prep.run(doc)
+
+    root = M.parser.parseDocument(doc).getroot()
+
+    for treeproc in M.treeprocessors.values():
+        newRoot = treeproc.run(root)
+        if newRoot is not None:
+            root = newRoot
+
+    return SpecialFencePreprocessor.EXAMPLES
+
+class SpecialFencedCodeExtension(Extension):
+
+    def extendMarkdown(self, md, md_globals):
+        """ Add FencedBlockPreprocessor to the Markdown instance. """
+        md.registerExtension(self)
+
+        md.preprocessors.add('fenced_code_block',
+                             SpecialFencePreprocessor(md),
+                             ">normalize_whitespace")
+
+
+class SpecialFencePreprocessor(Preprocessor):
+    EXAMPLES = {}
+    FENCED_BLOCK_RE = re.compile(r'''
+(?P<fence>^(?:~{3,}|`{3,}))[ ]*         # Opening ``` or ~~~
+(\{?\.?(?P<lang>[a-zA-Z0-9_+-]*))?[ ]*  # Optional {, and lang
+# Optional highlight lines, single- or double-quote-delimited
+(hl_lines=(?P<quot>"|')(?P<hl_lines>.*?)(?P=quot))?[ ]*
+}?[ ]*\n                                # Optional closing }
+(?P<code>.*?)(?<=\n)
+(?P=fence)[ ]*$''', re.MULTILINE | re.DOTALL | re.VERBOSE)
+
+    def __init__(self, md):
+        super(SpecialFencePreprocessor, self).__init__(md)
+
+        self.checked_for_codehilite = False
+        self.codehilite_conf = {}
+
+    def run(self, lines):
+
+        text = "\n".join(lines)
+
+        while True:
+            m = self.FENCED_BLOCK_RE.search(text)
+            if m:
+                if m.group('lang'):
+                    lang = m.group('lang')
+                    example = json.loads(m.group('code'))
+                    try:
+                        self.EXAMPLES[lang].append(example)
+                    except KeyError:
+                        self.EXAMPLES[lang] = [example]
+
+                text = "%s\n%s"% (text[:m.start()], text[m.end():])
+            else:
+                break
+        return text.split("\n")
+
+
+
+if __name__ == '__main__':
+    print(extract_code_blocks())