コード例 #1
0
def prepare_operands(s1, s2):
    # First, we reload schemas using jsonref to resolve $ref
    # before starting canonicalization.
    # At the moment, we will get undefined behaviour for recursive/circual refs.
    s1 = jsonref.loads(json.dumps(s1))
    s2 = jsonref.loads(json.dumps(s2))

    # Canonicalize and embed checkers for both lhs
    # and rhs schemas  before starting the subtype checking.
    # This also validates input schemas and canonicalized schemas.

    print_db("LHS", s1)
    print_db()
    s1 = simplify_schema_and_embed_checkers(
        canonicalize_schema(s1))
    print_db("LHS_canonical", s1)
    print_db()

    print_db("RHS", s2)
    print_db()
    s2 = simplify_schema_and_embed_checkers(
        canonicalize_schema(s2))
    print_db("RHS_canonical", s2)
    print_db()
    return s1, s2
コード例 #2
0
def main():
    json_schema_uri = 'https://raw.githubusercontent.com/biocompute-objects/BCO_Specification/1.3.1/schemas/biocomputeobject.json'

    parser = argparse.ArgumentParser()
    parser.add_argument('json_schema_uri',
                        default=json_schema_uri,
                        help="json schema uri")
    parser.add_argument('json',
                        type=argparse.FileType('r'),
                        help="json to validate")
    args = parser.parse_args()

    data = json.load(args.json)
    #schema = jsonref.load(args.json_schema_uri, jsonschema=True)
    schema = jsonref.loads(f'{{ "$ref": "{json_schema_uri}" }}',
                           jsonschema=True)
    return jsonschema.validate(data, schema)

    # Load JSON Schema from the repository by using URL or local file using absolute path and 'file:' prefix
    schema = jsonref.loads(f'{{ "$ref": "{schema_uri}" }}', jsonschema=True)

    data = {}
    # Use the extended validator to fill in `data` with default values from the schema
    for err in DefaultValidatingDraft7Validator(schema).iter_errors(data):
        # print validation errors with a schema path to make them easier to read/trace
        print(
            f'{err.message} in the schema path {err.schema.get("$id") }#{"/".join(err.schema_path)}'
        )

    # Pretty print `data` showing the assigned default values.
    print(json.dumps(data, indent=2))
コード例 #3
0
def open_jsonref(fileUrl):
    # function to retrieve either a json file from url or from disk
    import jsonref
    import requests
    if fileUrl[0:4] == "http":
        # es URL
        pointer = requests.get(fileUrl)
        return jsonref.loads(pointer.content.decode('utf-8'))
    else:
        # es file
        file = open(fileUrl, "r")
        return jsonref.loads(file.read())
コード例 #4
0
ファイル: conftest.py プロジェクト: blankoworld/rero-ils
def item_type_schema():
    """Item type Jsonschema for records."""
    schema_in_bytes = resource_string(
        'rero_ils.modules.item_types.jsonschemas',
        '/item_types/item_type-v0.0.1.json')
    schema = jsonref.loads(schema_in_bytes.decode('utf8'))
    return schema
コード例 #5
0
ファイル: schema.py プロジェクト: spendnetwork/flatten-tool
    def __init__(
        self,
        schema_filename=None,
        root_schema_dict=None,
        main_sheet_name="main",
        rollup=False,
        root_id="ocid",
        use_titles=False,
    ):
        self.sub_sheets = {}
        self.main_sheet = Sheet()
        self.sub_sheet_mapping = {}
        self.main_sheet_name = main_sheet_name
        self.rollup = rollup
        self.root_id = root_id
        self.use_titles = use_titles

        if root_schema_dict is None and schema_filename is None:
            raise ValueError("One of schema_filename or root_schema_dict must be supplied")
        if root_schema_dict is not None and schema_filename is not None:
            raise ValueError("Only one of schema_filename or root_schema_dict should be supplied")
        if schema_filename:
            if schema_filename.startswith("http"):
                import requests

                r = requests.get(schema_filename)
                self.root_schema_dict = jsonref.loads(r.text, object_pairs_hook=OrderedDict)
            else:
                with codecs.open(schema_filename, encoding="utf-8") as schema_file:
                    self.root_schema_dict = jsonref.load(schema_file, object_pairs_hook=OrderedDict)
        else:
            self.root_schema_dict = root_schema_dict
コード例 #6
0
ファイル: conftest.py プロジェクト: blankoworld/rero-ils
def acq_account_schema():
    """Acq account Jsonschema for records."""
    schema_in_bytes = resource_string(
        'rero_ils.modules.acq_accounts.jsonschemas',
        '/acq_accounts/acq_account-v0.0.1.json')
    schema = jsonref.loads(schema_in_bytes.decode('utf8'))
    return schema
コード例 #7
0
ファイル: tests.py プロジェクト: krzysztof/jsonref
 def test_dumps(self):
     json = """[1, 2, {"$ref": "#/0"}, 3]"""
     loaded = loads(json)
     # The string version should load the reference
     assert str(loaded) == "[1, 2, 1, 3]"
     # Our dump function should write the original reference
     assert dumps(loaded) == json
コード例 #8
0
    def __init__(self,
                 ui,
                 schema,
                 font_size=11,
                 font_size_form=None,
                 data=DATA):
        """

        :param ui: object containing ui-schema
        :param schema:  structure containing the schema

        """
        self.ui = ui
        # Use jsonref.loads to resolve $ref in schema. If we want to use external
        # references we need external resolver.
        schema_resolve_external = OpenapiResolver(schema).resolve()
        self.schema = jsonref.loads(json.dumps(schema_resolve_external))
        self.resolver = jsonschema.RefResolver.from_schema(self.schema)
        self.font_size = font_size
        self.font_size_form = font_size_form or font_size
        self.data = data or {}
        self.line_feed = 5 * self.font_size
        self.root = ET.Element("html")
        head = ET.SubElement(self.root, "head")
        style = ET.SubElement(head, "link", {
            "href": "form.css",
            "rel": "stylesheet"
        })
        self.body = ET.SubElement(self.root, "body")
        self.form = ET.SubElement(self.body,
                                  "form",
                                  attrib={
                                      "action": "",
                                      "method": "post"
                                  })
コード例 #9
0
def test_list():
    d = {
        'foo': [
            {
                "$ref": "#/definitions/user"
            }
        ],
        'definitions': {
            'user': {
                'properties': {
                    'first_name': {
                        'type': 'string'
                    }
                }
            }
        }
    }
    json_obj = jsonref.loads(json.dumps(d))
    assert type(json_obj['foo'][0]) == jsonref.JsonRef

    post_process_spec(
        json_obj, on_container_callbacks=(replace_jsonref_proxies_callback,))
    assert type(json_obj['foo'][0]) == dict

    assert d['definitions']['user'] == json_obj['foo'][0]
コード例 #10
0
ファイル: conftest.py プロジェクト: blankoworld/rero-ils
def notification_schema():
    """Notifications Jsonschema for records."""
    schema_in_bytes = resource_string(
        'rero_ils.modules.notifications.jsonschemas',
        '/notifications/notification-v0.0.1.json')
    schema = jsonref.loads(schema_in_bytes.decode('utf8'))
    return schema
コード例 #11
0
 def _load_json_schema(self, filename):
     """ Loads the given schema file """
     absolute_path = '{}/{}'.format(self.schema_location, filename)
     base_uri = 'file://{}/'.format(absolute_path)
     with open(absolute_path) as schema_file:
         schemas_file = schema_file.read()
         return jsonref.loads(schemas_file, base_uri=base_uri, jsonschema=True)
コード例 #12
0
ファイル: schema.py プロジェクト: ColinMaudry/flatten-tool
    def __init__(self,
                 schema_filename=None,
                 root_schema_dict=None,
                 rollup=False,
                 root_id=None,
                 use_titles=False,
                 disable_local_refs=False,
                 truncation_length=3,
                 exclude_deprecated_fields=False):
        self.sub_sheets = {}
        self.main_sheet = Sheet()
        self.sub_sheet_mapping = {}
        self.do_rollup = rollup
        self.rollup = set()
        self.root_id = root_id
        self.use_titles = use_titles
        self.truncation_length = truncation_length
        self.title_lookup = TitleLookup()
        self.flattened = {}
        self.exclude_deprecated_fields = exclude_deprecated_fields

        if root_schema_dict is None and schema_filename is None:
            raise ValueError(
                'One of schema_filename or root_schema_dict must be supplied')
        if root_schema_dict is not None and schema_filename is not None:
            raise ValueError(
                'Only one of schema_filename or root_schema_dict should be supplied'
            )
        if schema_filename:
            if schema_filename.startswith('http'):
                import requests
                r = requests.get(schema_filename)
                self.root_schema_dict = jsonref.loads(
                    r.text, object_pairs_hook=OrderedDict)
            else:
                if disable_local_refs:
                    with codecs.open(schema_filename,
                                     encoding="utf-8") as schema_file:
                        self.root_schema_dict = jsonref.load(
                            schema_file,
                            object_pairs_hook=OrderedDict,
                            loader=JsonLoaderLocalRefsDisabled())
                else:
                    if sys.version_info[:2] > (3, 0):
                        base_uri = pathlib.Path(
                            os.path.realpath(schema_filename)).as_uri()
                    else:
                        base_uri = urlparse.urljoin(
                            'file:',
                            urllib.pathname2url(
                                os.path.abspath(schema_filename)))
                    with codecs.open(schema_filename,
                                     encoding="utf-8") as schema_file:
                        self.root_schema_dict = jsonref.load(
                            schema_file,
                            object_pairs_hook=OrderedDict,
                            base_uri=base_uri)

        else:
            self.root_schema_dict = root_schema_dict
コード例 #13
0
ファイル: model.py プロジェクト: lauren-d/rero-ils
def unimarc_languages(self, key, value):
    """Get languages.

    languages: 008 and 041 [$a, repetitive]
    """
    languages = utils.force_list(value.get('a'))
    to_return = []
    schema_in_bytes = resource_string(
        'rero_ils.jsonschemas',
        'common/languages-v0.0.1.json'
    )
    schema = jsonref.loads(schema_in_bytes.decode('utf8'))
    langs = schema['language']['enum']

    for language in languages:
        if language in langs:
            to_return.append({'value': language, 'type': 'bf:Language'})

    translatedsfrom = utils.force_list(value.get('c'))
    if translatedsfrom:
        self['translatedFrom'] = []
        for translatedfrom in translatedsfrom:
            self['translatedFrom'].append(translatedfrom)

    return to_return
コード例 #14
0
 def test_dumps(self):
     json = """[1, 2, {"$ref": "#/0"}, 3]"""
     loaded = loads(json)
     # The string version should load the reference
     assert str(loaded) == "[1, 2, 1, 3]"
     # Our dump function should write the original reference
     assert dumps(loaded) == json
コード例 #15
0
ファイル: conftest.py プロジェクト: blankoworld/rero-ils
def patron_transaction_event_schema():
    """Patron transaction event Jsonschema for records."""
    schema_in_bytes = resource_string(
        'rero_ils.modules.patron_transaction_events.jsonschemas',
        'patron_transaction_events/patron_transaction_event-v0.0.1.json')
    schema = jsonref.loads(schema_in_bytes.decode('utf8'))
    return schema
コード例 #16
0
ファイル: schema.py プロジェクト: pladdy/jsonschema-scratch
def render_schema(path, filename):
    if "resolve" in flask.request.args.keys():
        with open(path) as schema:
            print(path)
            print(config.SCHEMAS_ABS_DIR)
            return flask.jsonify(
                jsonref.loads(schema.read(), base_uri=config.SCHEMAS_BASE_URI))
    return flask.send_from_directory(config.SCHEMAS_RELATIVE_PATH, filename)
コード例 #17
0
def _derefence_json(schema: t.Union[str, dict]) -> t.Any:
    """Dereference JSON schema.

    Args:
        schema: JSON schema as a string or dictionary.

    Returns:
        Dereferenced schema.

    Raises:
        ValueError: Wrong `schema` type.
    """
    if isinstance(schema, str):
        return jsonref.loads(schema, jsonschema=True)
    if isinstance(schema, dict):
        return jsonref.loads(json.dumps(schema), jsonschema=True)
    raise ValueError(schema)
コード例 #18
0
 def test_dump(self, tmpdir):
     json = """[1, 2, {"$ref": "#/0"}, 3]"""
     loaded = loads(json)
     # The string version should load the reference
     assert str(loaded) == "[1, 2, 1, 3]"
     dump(loaded, tmpdir.join("out.json"))
     # Our dump function should write the original reference
     assert tmpdir.join("out.json").read() == json
コード例 #19
0
ファイル: common.py プロジェクト: bill-anderson/cove
def _deref_schema(schema_str, schema_host):
    loader = CustomJsonrefLoader(schema_url=schema_host)
    deref_obj = jsonref.loads(schema_str,
                              loader=loader,
                              object_pairs_hook=OrderedDict)
    # Force evaluation of jsonref.loads here
    repr(deref_obj)
    return deref_obj
コード例 #20
0
ファイル: conftest.py プロジェクト: blankoworld/rero-ils
def patron_type_schema():
    """Patron type Jsonschema for records."""
    schema_in_bytes = resource_string(
        'rero_ils.modules.patron_types.jsonschemas',
        '/patron_types/patron_type-v0.0.1.json',
    )
    schema = jsonref.loads(schema_in_bytes.decode('utf8'))
    return schema
コード例 #21
0
def load_config(file):
    if hasattr(file, 'read'):
        obj_with_refs = yaml.safe_load(file)
    else:
        with open(file, 'r') as f:
            obj_with_refs = yaml.safe_load(f)
    obj_without_refs = unref(jsonref.loads(json.dumps(obj_with_refs)))
    return obj_without_refs
コード例 #22
0
ファイル: conftest.py プロジェクト: blankoworld/rero-ils
def organisation_schema():
    """Organisation Jsonschema for records."""
    schema_in_bytes = resource_string(
        'rero_ils.modules.organisations.jsonschemas',
        'organisations/organisation-v0.0.1.json',
    )
    schema = jsonref.loads(schema_in_bytes.decode('utf8'))
    return schema
コード例 #23
0
 def get_schema(self, **kwargs):
     schema_name = kwargs.get('schema_name', 'schema.json')
     s3 = boto3.resource('s3')
     object_key = f'{self._folder_name}/{schema_name}'
     stored_object = s3.Object(self._bucket_name, object_key).get()
     stored_schema_string = stored_object['Body'].read()
     schema = jsonref.loads(stored_schema_string, cls=AlgDecoder)
     return schema
コード例 #24
0
def validate_with_refs(schema_path, data):
    base_path = os.path.abspath(os.path.dirname(schema_path))
    base_uri = 'file://{}/'.format(base_path)
    with open(schema_path) as subnet_model_raw:
        subnet_model = jsonref.loads(subnet_model_raw.read(),
                                     base_uri=base_uri,
                                     jsonschema=True)
    validate(instance=data, schema=subnet_model)
コード例 #25
0
ファイル: conftest.py プロジェクト: blankoworld/rero-ils
def circ_policy_schema():
    """Patron Jsonschema for records."""
    schema_in_bytes = resource_string(
        'rero_ils.modules.circ_policies.jsonschemas',
        'circ_policies/circ_policy-v0.0.1.json',
    )
    schema = jsonref.loads(schema_in_bytes.decode('utf8'))
    return schema
コード例 #26
0
ファイル: tests.py プロジェクト: krzysztof/jsonref
 def test_dump(self, tmpdir):
     json = """[1, 2, {"$ref": "#/0"}, 3]"""
     loaded = loads(json)
     # The string version should load the reference
     assert str(loaded) == "[1, 2, 1, 3]"
     dump(loaded, tmpdir.join("out.json"))
     # Our dump function should write the original reference
     assert tmpdir.join("out.json").read() == json
コード例 #27
0
def get_schema(monkeypatch, schema_in_bytes):
    """Get json schema and replace $refs.

    For the resolving of the $ref we have to catch the request.get and
    get the referenced json schema directly from the resource.

    :param monkeypatch: https://docs.pytest.org/en/stable/monkeypatch.html
    :schema_in_bytes: schema in bytes.
    :returns: resolved json schema.
    """
    # apply the monkeypatch for requests.get to mocked_requests_get
    monkeypatch.setattr(requests, "get", mocked_requests_get)

    schema = jsonref.loads(schema_in_bytes.decode('utf8'))
    # Replace all remaining $refs
    while schema != jsonref.loads(jsonref.dumps(schema)):
        schema = jsonref.loads(jsonref.dumps(schema))
    return schema
コード例 #28
0
def json_schema(request):
    """
    JSON objects that correspond to JSON schemas.
    """
    path = root.joinpath(request.param)
    text = path.read_text()
    # Dereference schemas as workaround for https://github.com/Julian/jsonschema/issues/447
    schema = jsonref.loads(text, jsonschema=True)
    return schema
コード例 #29
0
def open_jsonref(fileUrl):
    import requests
    if fileUrl[0:4] == "http":
        # es URL
        try:
            pointer = requests.get(fileUrl)
            output = jsonref.loads(pointer.content.decode('utf-8'),
                                   load_on_repr=False)
            return output
        except:
            return ""
    else:
        # es file
        try:
            file = open(fileUrl, "r")
            return jsonref.loads(file.read())
        except:
            return ""
コード例 #30
0
def json_schema(request):
    """
    JSON objects that correspond to JSON schemas.
    """
    path = root.joinpath(request.param)
    text = path.read_text()
    # Dereference schemas as workaround for https://github.com/Julian/jsonschema/issues/447
    schema = jsonref.loads(text, jsonschema=True)
    return schema
コード例 #31
0
def process_bundles(source_dir=None, target_dir=None):
    bundles = {}
    source_dir = source_dir
    bundle_dir = os.path.join(source_dir, "bundles")

    with open("./schemas/anchore-engine-api.yaml", 'r') as FH:
        anchore_engine_api_swagger = jsonref.loads(
            json.dumps(yaml.safe_load(FH)))
        bundleschema = anchore_engine_api_swagger['definitions'][
            'PolicyBundle']

    if os.path.isdir(bundle_dir):
        for bundlefile in os.listdir(bundle_dir):
            patt = re.match("(.*)\.json$", bundlefile)
            if patt:
                bundlename = patt.group(1)
                thefile = os.path.join(bundle_dir, bundlefile)
                try:
                    print("\tOpening bundle {}...".format(thefile), end='')
                    with open(thefile, 'r') as FH:
                        print("done!")
                        buf = FH.read()
                        digest = "{}:{}".format(
                            "sha256",
                            hashlib.sha256(buf.encode('utf8')).hexdigest())
                        bundle = json.loads(buf)

                        print("\tValidating bundle {}...".format(thefile),
                              end='')
                        jsonschema.validate(bundle, bundleschema)
                        print("done!")

                        print("\tProcessing bundle {}...".format(thefile),
                              end='')
                        bundle_record = {
                            'location':
                            '/'.join([
                                'bundles', bundlename, "{}.json".format(digest)
                            ]),
                            'type':
                            'bundle',
                            'name':
                            bundlename,  #bundle.get('name', 'N/A'),
                            'description':
                            bundle.get('description',
                                       bundle.get('comment', "N/A")),
                            'digest':
                            digest,
                        }
                        bundles[bundlename] = bundle_record
                        print("done!")
                except Exception as err:
                    print("\nERROR parsing bundle {} - exception: {}".format(
                        bundlefile, err))
                    raise err
    return (bundles)
コード例 #32
0
def load_jsonschema(config_file):
    base_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),
                             'schemas', config_file['version'])
    filename = os.path.join(base_path, "config_schema.json")
    if not os.path.exists(filename):
        raise Exception('Version in "{}" is unsupported'.format(filename))
    with open(filename, "r") as f:
        return loads(f.read(),
                     base_uri='file://{}/'.format(base_path),
                     jsonschema=True)
コード例 #33
0
    def __init__(self, file_name):
        base_path = os.path.dirname(os.path.abspath(__file__))
        json_path = os.path.join(base_path, file_name)
        base_uri = f"file://{base_path}/"

        with open(json_path) as input_file:
            self.update(
                jsonref.loads(input_file.read(),
                              base_uri=base_uri,
                              jsonschema=True))
コード例 #34
0
 def _get_combined_schema(self, schema):
     combined_schema = {}
     swagger = self._get_api_doc()
     definitions = jsonref.loads(json.dumps(swagger))['components']['schemas']
     definition_schema = definitions[schema]
     json_schemas = definition_schema['allOf'] if definition_schema.get('allOf') else [definition_schema]
     for json_schema in json_schemas:
         combined_schema.update(json_schema)
     combined_schema['additionalProperties'] = False
     return combined_schema
コード例 #35
0
    def __init__(self, schema_filename=None, root_schema_dict=None, rollup=False, root_id=None, use_titles=False,
                 disable_local_refs=False, truncation_length=3, exclude_deprecated_fields=False):
        self.sub_sheets = {}
        self.main_sheet = Sheet()
        self.sub_sheet_mapping = {}
        self.rollup = rollup
        self.root_id = root_id
        self.use_titles = use_titles
        self.truncation_length = truncation_length
        self.title_lookup = TitleLookup()
        self.flattened = {}
        self.exclude_deprecated_fields = exclude_deprecated_fields

        if root_schema_dict is None and schema_filename is  None:
            raise ValueError('One of schema_filename or root_schema_dict must be supplied')
        if root_schema_dict is not None and schema_filename is not None:
            raise ValueError('Only one of schema_filename or root_schema_dict should be supplied')
        if schema_filename:
            if schema_filename.startswith('http'):
                import requests
                r = requests.get(schema_filename)
                self.root_schema_dict = jsonref.loads(r.text, object_pairs_hook=OrderedDict)
            else:
                if disable_local_refs:
                    with codecs.open(schema_filename, encoding="utf-8") as schema_file:
                        self.root_schema_dict = jsonref.load(schema_file, object_pairs_hook=OrderedDict,
                                                             loader=JsonLoaderLocalRefsDisabled())
                else:
                    if sys.version_info[:2] > (3, 0):
                        base_uri = pathlib.Path(os.path.realpath(schema_filename)).as_uri()
                    else:
                        base_uri = urlparse.urljoin('file:', urllib.pathname2url(os.path.abspath(schema_filename)))
                    with codecs.open(schema_filename, encoding="utf-8") as schema_file:
                        self.root_schema_dict = jsonref.load(schema_file, object_pairs_hook=OrderedDict,
                                                             base_uri=base_uri)


        else:
            self.root_schema_dict = root_schema_dict
コード例 #36
0
def test_dict():
    d = {
        'foo': {
            "$ref": "#/definitions/user"
        },
        'definitions': {
            'user': {
                'properties': {
                    'first_name': {
                        'type': 'string'
                    }
                }
            }
        }
    }
    json_obj = jsonref.loads(json.dumps(d))
    assert isinstance(json_obj['foo'], jsonref.JsonRef)

    replace_jsonref_proxies(json_obj)
    assert isinstance(json_obj['foo'], dict)

    assert d['definitions']['user'] == json_obj['foo']
コード例 #37
0
def test_nested_dict():
    d = {
        'foo': {
            "$ref": "#/definitions/user"
        },
        'definitions': {
            'user': {
                'type': 'object',
                'properties': {
                    'first_name': {
                        'type': 'string'
                    },
                    'address': {
                        '$ref': '#/definitions/address',
                    }
                }
            },
            'address': {
                'type': 'object',
                'properties': {
                    'street': {
                        'type': 'string'
                    }
                }
            }
        }
    }
    json_obj = jsonref.loads(json.dumps(d))
    assert type(json_obj['foo']) == jsonref.JsonRef
    assert type(json_obj['foo']['properties']['address']) == jsonref.JsonRef

    post_process_spec(
        json_obj, on_container_callbacks=(replace_jsonref_proxies_callback,))
    assert type(json_obj['foo']) == dict
    assert type(json_obj['foo']['properties']['address']) == dict

    assert d['definitions']['address'] == \
        json_obj['foo']['properties']['address']
コード例 #38
0
def test_nested_dict():
    d = {
        'foo': {
            "$ref": "#/definitions/user"
        },
        'definitions': {
            'user': {
                'type': 'object',
                'properties': {
                    'first_name': {
                        'type': 'string'
                    },
                    'address': {
                        '$ref': '#/definitions/address',
                    }
                }
            },
            'address': {
                'type': 'object',
                'properties': {
                    'street': {
                        'type': 'string'
                    }
                }
            }
        }
    }
    json_obj = jsonref.loads(json.dumps(d))
    assert isinstance(json_obj['foo'], jsonref.JsonRef)
    assert isinstance(json_obj['foo']['properties']['address'], jsonref.JsonRef)

    replace_jsonref_proxies(json_obj)
    assert isinstance(json_obj['foo'], dict)
    assert isinstance(json_obj['foo']['properties']['address'], dict)

    assert d['definitions']['address'] == \
        json_obj['foo']['properties']['address']
コード例 #39
0
def test_list():
    d = {
        'foo': [
            {
                "$ref": "#/definitions/user"
            }
        ],
        'definitions': {
            'user': {
                'properties': {
                    'first_name': {
                        'type': 'string'
                    }
                }
            }
        }
    }
    json_obj = jsonref.loads(json.dumps(d))
    assert type(json_obj['foo'][0]) == jsonref.JsonRef

    replace_jsonref_proxies(json_obj)
    assert type(json_obj['foo'][0]) == dict

    assert d['definitions']['user'] == json_obj['foo'][0]
コード例 #40
0
ファイル: views.py プロジェクト: StandardLaw/cove
def get_schema_fields(schema_filename):
    r = requests.get(schema_filename)
    return set(schema_dict_fields_generator(jsonref.loads(r.text, object_pairs_hook=OrderedDict)))
コード例 #41
0
def csl_data_validator():
    text = root.joinpath('csl-data.json').read_text()
    schema = jsonref.loads(text, jsonschema=True)
    Validator = jsonschema.validators.validator_for(schema)
    return Validator(schema)
コード例 #42
0
ファイル: 00sample.py プロジェクト: podhmo/individual-sandbox
# -*- coding:utf-8 -*-
from pprint import pprint
import jsonref

# An example json document
json_str = """{"real": [1, 2, 3, 4], "ref": {"$ref": "#/real"}}"""
data = jsonref.loads(json_str)
pprint(data)  # Reference is not evaluated until here
# {'real': [1, 2, 3, 4], 'ref': [1, 2, 3, 4]}
コード例 #43
0
# -*- coding:utf-8 -*-
import os.path
import pprint as p
import jsonref

s = """
{
  "x": {"$ref": "./files/x.json#x"},
  "y": {"$ref": "./files/y.json#y"}
}
"""

# absolute path is ok
cwd = os.path.dirname(os.path.abspath(__file__))
s = s.replace('"./', '"file://{}/'.format(cwd))
print(s)
data = jsonref.loads(s)
p.pprint(data)
コード例 #44
0
ファイル: tests.py プロジェクト: krzysztof/jsonref
 def test_loads(self):
     json = """{"a": 1, "b": {"$ref": "#/a"}}"""
     assert loads(json) == {"a": 1, "b": 1}
コード例 #45
0
ファイル: tests.py プロジェクト: krzysztof/jsonref
 def test_loads_kwargs(self):
     json = """{"a": 5.5, "b": {"$ref": "#/a"}}"""
     loaded = loads(json, parse_float=lambda x: int(float(x)))
     assert loaded["a"] == loaded["b"] == 5