Exemplo n.º 1
0
def test_ref_path():
    from jsonschema.compat import urlsplit
    url = "file:////home/user/mappyfile/mappyfile/schemas/"
    scheme, netloc, path, query, fragment = urlsplit(url)
    print(scheme, netloc, path, query, fragment)
    assert(scheme == "file")

    url = "file:///D:/GitHub/mappyfile/mappyfile/schemas/"

    scheme, netloc, path, query, fragment = urlsplit(url)
    print(scheme, netloc, path, query, fragment)
    assert(scheme == "file")
Exemplo n.º 2
0
def test_ref_path():
    from jsonschema.compat import urlsplit
    url = "file:////home/user/mappyfile/mappyfile/schemas/"
    scheme, netloc, path, query, fragment = urlsplit(url)
    print(scheme, netloc, path, query, fragment)
    assert (scheme == "file")

    url = "file:///D:/GitHub/mappyfile/mappyfile/schemas/"

    scheme, netloc, path, query, fragment = urlsplit(url)
    print(scheme, netloc, path, query, fragment)
    assert (scheme == "file")
Exemplo n.º 3
0
    def resolve_remote(self, uri):

        scheme = urlsplit(uri).scheme
        # if there's no scheme, it's a local file, so prefix it with "file://"
        if scheme == '':
            uri = 'file://' + uri

        if scheme in self.handlers:
            result = self.handlers[scheme](uri)
        elif scheme in [u"http", u"https"]:
            # Requests has support for detecting the correct encoding of
            # json over http
            result = requests.get(uri).json()
        else:
            # Otherwise, pass off to urllib and assume utf-8
            with urlopen(uri) as url:
                content = url.read().decode("utf-8")
                if uri.endswith('.yaml') or uri.endswith('.yml'):
                    result = yaml.safe_load(content)
                else:
                    result = json.loads(content)

        if self.cache_remote:
            self.store[uri] = result
        return result
Exemplo n.º 4
0
    def resolve_remote(self, uri):
        """
        Resolve a remote ``uri``.

        If called directly, does not check the store first, but after
        retrieving the document at the specified URI it will be saved in
        the store if :attr:`cache_remote` is True.

        .. note::

            If the requests_ library is present, ``jsonschema`` will use it to
            request the remote ``uri``, so that the correct encoding is
            detected and used.

            If it isn't, or if the scheme of the ``uri`` is not ``http`` or
            ``https``, UTF-8 is assumed.

        Arguments:

            uri (str):

                The URI to resolve

        Returns:

            The retrieved document

        .. _requests: http://pypi.python.org/pypi/requests/

        """
        try:
            import requests
        except ImportError:
            requests = None

        scheme = urlsplit(uri).scheme

        if scheme in self.handlers:
            result = self.handlers[scheme](uri)
        elif (
            scheme in [u"http", u"https"] and
            requests and
            getattr(requests.Response, "json", None) is not None
        ):
            # Requests has support for detecting the correct encoding of
            # json over http
            if callable(requests.Response.json):
                result = requests.get(uri).json()
            else:
                result = requests.get(uri).json
        else:
            # Otherwise, pass off to urllib and assume utf-8
            with urlopen(uri) as url:
                result = json.loads(url.read().decode("utf-8"))

        if self.cache_remote:
            self.store[uri] = result
        return result
Exemplo n.º 5
0
    def resolve_remote(self, uri):
        """
        Resolve a remote ``uri``.

        If called directly, does not check the store first, but after
        retrieving the document at the specified URI it will be saved in
        the store if :attr:`cache_remote` is True.

        .. note::

            If the requests_ library is present, ``jsonschema`` will use it to
            request the remote ``uri``, so that the correct encoding is
            detected and used.

            If it isn't, or if the scheme of the ``uri`` is not ``http`` or
            ``https``, UTF-8 is assumed.

        Arguments:

            uri (str):

                The URI to resolve

        Returns:

            The retrieved document

        .. _requests: http://pypi.python.org/pypi/requests/

        """

        scheme = urlsplit(uri).scheme

        if scheme in self.handlers:
            result = self.handlers[scheme](uri)
        elif (
            scheme in [u"http", u"https"] and
            requests and
            getattr(requests.Response, "json", None) is not None
        ):
            # Requests has support for detecting the correct encoding of
            # json over http
            if callable(requests.Response.json):
                result = requests.get(uri).json()
            else:
                result = requests.get(uri).json
        else:
            # Otherwise, pass off to urllib and assume utf-8
            result = json.loads(urlopen(uri).read().decode("utf-8"))

        if self.cache_remote:
            self.store[uri] = result
        return result
Exemplo n.º 6
0
    def package_name_for(self, schema_id):
        """
        Choose a package name for a given schema id.
        """
        path = urlsplit(schema_id).path
        uri_parts = path.split("/")
        if self.keep_uri_parts:
            uri_parts = uri_parts[-self.keep_uri_parts:]
        parts = [underscore(part) for part in uri_parts[:-1] if part]

        if not all(self.is_legal_package_name(part) for part in parts):
            raise ValueError("Unable to construct legal package name from: {}".format(path))

        return ".".join([self.basename] + parts)
 def resolve_from_url(self, uri):
     uri, fragment = urldefrag(uri)
     split_url = urlsplit(uri)
     if split_url.scheme in self.handlers:
         return self.handlers[split_url.scheme](uri)
     full_path = find_schema_path(uri.split('/')[-1])
     if full_path:
         with open(full_path) as fp:
             json_schema = json.load(fp)
         if not json_schema:
             # TODO: fix exception method
             raise RefResolutionError("Unresolvable JSON schema: %r" % uri)
         return self.resolve_fragment(json_schema, fragment)
     else:
         # if a schema can't be found locally, just default to using the standard resolver
         return super(DjangoSchemaResolver, self).resolve_from_url(uri)
Exemplo n.º 8
0
    def resolve_remote(self, uri):
        """
        Resolve a remote ``uri``.

        Does not check the store first, but stores the retrieved document in
        the store if :attr:`RefResolver.cache_remote` is True.

        .. note::

            If the requests_ library is present, ``jsonschema`` will use it to
            request the remote ``uri``, so that the correct encoding is
            detected and used.

            If it isn't, or if the scheme of the ``uri`` is not ``http`` or
            ``https``, UTF-8 is assumed.

        :argument str uri: the URI to resolve
        :returns: the retrieved document

        .. _requests: http://pypi.python.org/pypi/requests/

        """

        scheme = urlsplit(uri).scheme

        if scheme in self.handlers:
            result = self.handlers[scheme](uri)
        elif (
            scheme in [u"http", u"https"] and
            requests and
            getattr(requests.Response, "json", None) is not None
        ):
            # Requests has support for detecting the correct encoding of
            # json over http
            if callable(requests.Response.json):
                result = requests.get(uri).json()
            else:
                result = requests.get(uri).json
        else:
            # Otherwise, pass off to urllib and assume utf-8
            result = json.loads(urlopen(uri).read().decode("utf-8"))

        if self.cache_remote:
            self.store[uri] = result
        return result
Exemplo n.º 9
0
 def resolve_remote(self, uri):
     '''
     Basically the same code provided by RefResolver, but we use
     OrderedDict as base class to load json documents.
     '''
     scheme = urlsplit(uri).scheme
     if scheme in self.handlers:
         result = self.handlers[scheme](uri)
     elif (scheme in [u"http", u"https"] and requests
           and getattr(requests.Response, "json", None) is not None):
         if callable(requests.Response.json):
             result = requests.get(uri).json()
         else:
             result = requests.get(uri).json
     else:
         result = json.loads(urlopen(uri).read().decode("utf-8"),
                             object_pairs_hook=OrderedDict)
     if self.cache_remote:
         self.store[uri] = result
     return result
Exemplo n.º 10
0
    def resolve_remote(self, uri):
        """override default resolve_remote
        to allow testing when there is no ssl certificate
        """
        scheme = urlsplit(uri).scheme

        if scheme in self.handlers:
            result = self.handlers[scheme](uri)
        elif (scheme in [u"http", u"https"] and requests
              and getattr(requests.Response, "json", None) is not None):
            # Requests has support for detecting the correct encoding of
            # json over http
            if callable(requests.Response.json):
                result = requests.get(uri, verify=False).json()
            else:
                result = requests.get(uri, verify=False).json
        else:
            # Otherwise, pass off to urllib and assume utf-8
            result = json.loads(urlopen(uri).read().decode("utf-8"))

        if self.cache_remote:
            self.store[uri] = result
        return result
Exemplo n.º 11
0
    def resolve_remote(self, uri):
        schema_name = uri.split("/")[-1]
        if self.schema_file and self.file_schema_name == schema_name:
            uri = self.schema_file
        else:
            uri = urljoin(self.schema_url, schema_name)

        document = self.store.get(uri)

        if document:
            return document
        if uri.startswith("http"):
            # This branch of the if-statement in-lines `RefResolver.resolve_remote()`, but using `get_request()`.
            scheme = urlsplit(uri).scheme

            if scheme in self.handlers:
                result = self.handlers[scheme](uri)
            elif scheme in [u"http", u"https"]:
                # Requests has support for detecting the correct encoding of
                # json over http
                result = get_request(uri, config=self.config).json()
            else:
                # Otherwise, pass off to urllib and assume utf-8
                with urlopen(uri) as url:
                    result = json.loads(url.read().decode("utf-8"))

            if self.cache_remote:
                self.store[uri] = result
            return result
        else:
            with open(uri) as schema_file:
                result = json.load(schema_file)

        add_is_codelist(result)
        self.store[uri] = result
        return result
Exemplo n.º 12
0
 def normalize(self, uri):
     return urlsplit(uri).geturl()
Exemplo n.º 13
0
 def normalize(self, uri):
     return urlsplit(uri).geturl()
Exemplo n.º 14
0
 def normalize(self, uri):
     parts = urlsplit(uri)
     if 'file' == parts.scheme:
         parts = parts._replace(path=os.path.abspath(parts.path))
     return parts.geturl()