def typed_dict_from_schema_file(schema_path, referenced_schema_files=None):
    if referenced_schema_files:
        referenced_schema_files.append(schema_path)
        schema = load_schema_ordered(referenced_schema_files)
    else:
        schema = expand_schema(load_schema(schema_path))
    return types_for_schema(schema)
Esempio n. 2
0
def test_schema_expansion():
    """https://github.com/fastavro/fastavro/issues/314"""
    sub_schema = {
        "name": "Dependency",
        "namespace": "com.namespace.dependencies",
        "type": "record",
        "fields": [{
            "name": "sub_field_1",
            "type": "string"
        }]
    }

    outer_schema = {
        "name":
        "MasterSchema",
        "namespace":
        "com.namespace.master",
        "type":
        "record",
        "fields": [{
            "name": "field_1",
            "type": "com.namespace.dependencies.Dependency"
        }]
    }

    combined = {
        "name":
        "com.namespace.master.MasterSchema",
        "type":
        "record",
        "fields": [{
            "name": "field_1",
            "type": {
                "name": "com.namespace.dependencies.Dependency",
                "type": "record",
                "fields": [{
                    "name": "sub_field_1",
                    "type": "string"
                }]
            }
        }]
    }

    expand_schema(sub_schema)
    parsed = expand_schema(outer_schema)

    assert parsed == combined
Esempio n. 3
0
def test_schema_expansion_2():
    """https://github.com/fastavro/fastavro/issues/314"""
    original_schema = {
        "name":
        "MasterSchema",
        "namespace":
        "com.namespace.master",
        "type":
        "record",
        "fields": [{
            "name": "field_1",
            "type": {
                "name": "Dependency",
                "namespace": "com.namespace.dependencies",
                "type": "record",
                "fields": [{
                    "name": "sub_field_1",
                    "type": "string"
                }]
            }
        }, {
            "name": "field_2",
            "type": "com.namespace.dependencies.Dependency"
        }]
    }

    expanded_schema = {
        "name":
        "com.namespace.master.MasterSchema",
        "type":
        "record",
        "fields": [{
            "name": "field_1",
            "type": {
                "name": "com.namespace.dependencies.Dependency",
                "type": "record",
                "fields": [{
                    "name": "sub_field_1",
                    "type": "string"
                }]
            }
        }, {
            "name": "field_2",
            "type": {
                "name": "com.namespace.dependencies.Dependency",
                "type": "record",
                "fields": [{
                    "name": "sub_field_1",
                    "type": "string"
                }]
            }
        }]
    }

    assert expanded_schema == expand_schema(original_schema)
Esempio n. 4
0
def test_expanding_recursive_schemas_should_stop():
    """https://github.com/fastavro/fastavro/issues/314"""
    sub_schema = {
        "name": "LongList",
        "type": "record",
        "fields": [
            {"name": "value", "type": "long"},
            {"name": "next", "type": ["LongList", "null"]},
        ],
    }

    parsed = expand_schema(sub_schema)
    assert sub_schema == parsed
Esempio n. 5
0
def test_schema_expansion_3():
    """https://github.com/fastavro/fastavro/issues/538"""
    references = {
        "com.namespace.dependencies.Dependency": {
            "name": "Dependency",
            "namespace": "com.namespace.dependencies",
            "type": "record",
            "fields": [{
                "name": "sub_field_1",
                "type": "string"
            }],
        }
    }

    original_schema = {
        "name":
        "MasterSchema",
        "namespace":
        "com.namespace.master",
        "type":
        "record",
        "fields": [{
            "name": "field_2",
            "type": "com.namespace.dependencies.Dependency"
        }],
    }

    expected_expanded_schema_fields = [{
        "name": "field_2",
        "type": {
            "name": "Dependency",
            "namespace": "com.namespace.dependencies",
            "type": "record",
            "fields": [{
                "name": "sub_field_1",
                "type": "string"
            }],
        },
    }]

    assert isinstance(original_schema, dict)

    try:
        parsed_schema = parse_schema(original_schema, named_schemas=references)
        assert expected_expanded_schema_fields == expand_schema(
            parsed_schema)["fields"]
    except UnknownType:
        pytest.fail(
            "expand_schema raised UnknownType even though referenced type is part of named_schemas"
        )
def typed_dict_from_schema_file(schema_path):
    schema = expand_schema(load_schema(schema_path))

    return types_for_schema(schema)