def test_has_required_lazy():
    m = hdf5storage.Marshallers.TypeMarshaller()
    m.required_parent_modules = ['json']
    m.required_modules = ['json']
    m.python_type_strings = ['ellipsis']
    m.types = ['builtins.ellipsis']
    m.update_type_lookups()
    for name in m.required_modules:
        assert_not_in(name, sys.modules)
    mc = hdf5storage.MarshallerCollection(lazy_loading=True, marshallers=[m])
    for name in m.required_modules:
        assert_not_in(name, sys.modules)
    assert mc._has_required_modules[-1]
    assert_false(mc._imported_required_modules[-1])
    mback, has_modules = mc.get_marshaller_for_type_string( \
        m.python_type_strings[0])
    assert_is_not_none(mback)
    assert has_modules
    assert mc._has_required_modules[-1]
    assert mc._imported_required_modules[-1]
    for name in m.required_modules:
        assert_in(name, sys.modules)

    # Do it again, but this time the modules are already loaded so that
    # flag should be set.
    mc = hdf5storage.MarshallerCollection(lazy_loading=True, marshallers=[m])
    assert mc._has_required_modules[-1]
    assert mc._imported_required_modules[-1]
    mback, has_modules = mc.get_marshaller_for_type_string( \
        m.python_type_strings[0])
    assert_is_not_none(mback)
    assert has_modules
    assert mc._has_required_modules[-1]
    assert mc._imported_required_modules[-1]
def test_plugin_marshaller_SubList():
    mc = hdf5storage.MarshallerCollection(load_plugins=True,
                                          lazy_loading=True)
    options = hdf5storage.Options(store_python_metadata=True,
                                  matlab_compatible=False,
                                  marshaller_collection=mc)
    ell = [1, 2, 'b1', b'3991', True, None]
    data = example_hdf5storage_marshaller_plugin.SubList(ell)
    f = None
    name = '/a'
    try:
        f = tempfile.mkstemp()
        os.close(f[0])
        filename = f[1]
        hdf5storage.write(data, path=name, filename=filename,
                          options=options)
        out = hdf5storage.read(path=name, filename=filename,
                               options=options)
    except:
        raise
    finally:
        if f is not None:
            os.remove(f[1])
    assert_equal_nose(ell, list(out))
    assert_equal_nose(type(out),
                      example_hdf5storage_marshaller_plugin.SubList)
def test_marshaller_read_approximate_missing_import():
    m = Tmarshaller()
    m.required_parent_modules = ['json']
    m.required_modules = ['aiveneiavie']
    m.python_type_strings = ['ellipsis']
    m.types = ['builtins.ellipsis']
    m.update_type_lookups()
    mc = hdf5storage.MarshallerCollection(lazy_loading=True, marshallers=[m])
    options = hdf5storage.Options(marshaller_collection=mc)

    fld = None
    name = '/the'
    try:
        fld = tempfile.mkstemp()
        os.close(fld[0])
        filename = fld[1]
        with h5py.File(filename, mode='w') as f:
            f.create_dataset(name, data=np.int64([1]))
            f[name].attrs.create('Python.Type', b'ellipsis')
            out = hdf5storage.utilities.read_data(f, f, name, options)
    except:
        raise
    finally:
        if fld is not None:
            os.remove(fld[1])

    assert_equal(out, 'read_approximate')
def test_plugin_builtin_user():
    m = JunkMarshaller()
    mc = hdf5storage.MarshallerCollection(load_plugins=True,
                                          priority=('plugin', 'builtin',
                                                    'user'),
                                          marshallers=(m, ))
    assert_equal_nose(m, mc._marshallers[-1])
    if has_example_hdf5storage_marshaller_plugin:
        assert isinstance(mc._marshallers[0], SubListMarshaller)
def test_missing_required_parent():
    m = hdf5storage.Marshallers.TypeMarshaller()
    m.required_parent_modules = ['ainivieanvueaq']
    m.python_type_strings = ['vi8vaeaniea']
    m.types = [s for s in m.python_type_strings]
    m.update_type_lookups()
    mc = hdf5storage.MarshallerCollection(marshallers=[m])
    assert_false(mc._has_required_modules[-1])
    assert_false(mc._imported_required_modules[-1])
    mback, has_modules = mc.get_marshaller_for_type_string( \
        m.python_type_strings[0])
    assert_is_not_none(mback)
    assert_false(has_modules)
    assert_false(mc._has_required_modules[-1])
    assert_false(mc._imported_required_modules[-1])
    for name in m.required_parent_modules:
        assert_not_in(name, sys.modules)
def test_has_required_non_lazy():
    m = hdf5storage.Marshallers.TypeMarshaller()
    m.required_parent_modules = ['csv']
    m.required_modules = ['csv']
    m.python_type_strings = ['ellipsis']
    m.types = ['builtins.ellipsis']
    m.update_type_lookups()
    for name in m.required_modules:
        assert_not_in(name, sys.modules)
    mc = hdf5storage.MarshallerCollection(lazy_loading=False, marshallers=[m])
    for name in m.required_modules:
        assert_in(name, sys.modules)
    assert mc._has_required_modules[-1]
    assert mc._imported_required_modules[-1]
    mback, has_modules = mc.get_marshaller_for_type_string( \
        m.python_type_strings[0])
    assert_is_not_none(mback)
    assert has_modules
    assert mc._has_required_modules[-1]
    assert mc._imported_required_modules[-1]
def test_error_extra_element():
    hdf5storage.MarshallerCollection(priority=('builtin', 'user', 'plugin',
                                               'extra'))
def test_error_missing_element():
    need = ('builtin', 'user', 'plugin')
    hdf5storage.MarshallerCollection(
        priority=[random.choice(need) for i in range(2)])
def check_error_non_tuplelist(obj):
    hdf5storage.MarshallerCollection(priority=obj)
def check_error_non_sequence(obj):
    hdf5storage.MarshallerCollection(priority=obj)