示例#1
0
def test_basic(session_cls):
    session_en = session_cls()
    translator_en = Translator(Translation, session_cls(), 'en')
    translator_en.bind(session_en)

    session_fr = session_cls()
    translator_fr = Translator(Translation, session_cls(), 'fr')
    translator_fr.bind(session_fr)

    model = Model(name='name')
    session_en.add(model)
    session_en.commit()

    # translate into fr
    translatable = model.name
    translatable.pending_value = 'namë_fr'
    translator_fr.save_translation(translatable)

    new_model = Model(name='name')
    session_en.add(new_model)
    session_en.commit()

    suggestion = translator_fr.suggest_translation(new_model.name,
                                                   from_language='en',
                                                   to_language='fr')

    assert suggestion == 'namë_fr'
示例#2
0
    def test_delete_on_delete(self, session, session_cls):
        session1 = session_cls()
        translator1 = Translator(Translation, session_cls(), 'language1')
        translator1.bind(session1)

        session2 = session_cls()
        translator2 = Translator(Translation, session_cls(), 'language2')
        translator2.bind(session2)

        instance = Model(id=1)
        session.add(instance)
        session.commit()

        instance = session1.query(Model).get(1)
        instance.name = 'name'
        session1.commit()

        instance = session2.query(Model).get(1)
        instance.name = 'name'
        session2.commit()

        assert translator1.session.query(Translation).count() == 2
        session2.delete(instance)
        assert translator1.session.query(Translation).count() == 2
        session2.commit()

        translator1.session.rollback()  # expire caches
        assert translator1.session.query(Translation).count() == 0
示例#3
0
    def test_delete_on_delete(self, session, session_cls):
        session1 = session_cls()
        translator1 = Translator(Translation, session_cls(), 'language1')
        translator1.bind(session1)

        session2 = session_cls()
        translator2 = Translator(Translation, session_cls(), 'language2')
        translator2.bind(session2)

        instance = Model(id=1)
        session.add(instance)
        session.commit()

        instance = session1.query(Model).get(1)
        instance.name = 'name'
        session1.commit()

        instance = session2.query(Model).get(1)
        instance.name = 'name'
        session2.commit()

        assert translator1.session.query(Translation).count() == 2
        session2.delete(instance)
        assert translator1.session.query(Translation).count() == 2
        session2.commit()

        translator1.session.rollback()  # expire caches
        assert translator1.session.query(Translation).count() == 0
示例#4
0
def test_set_from_other_instance_and_commit(bound_session):
    instance1 = Model(name='name')
    instance2 = Model(name=instance1.name)
    assert isinstance(instance2.name, TranslatableString)
    assert instance2.name.pending_value == 'name'
    bound_session.add(instance1)
    bound_session.add(instance2)
    bound_session.commit()
示例#5
0
def test_set_from_to(first, second):
    instance = Model(name=first)
    instance.name = second
    if second is None:
        assert instance.name is None
    else:
        assert isinstance(instance.name, TranslatableString)
        assert instance.name.pending_value == second
示例#6
0
def test_set_from_to(first, second):
    instance = Model(name=first)
    instance.name = second
    if second is None:
        assert instance.name is None
    else:
        assert isinstance(instance.name, TranslatableString)
        assert instance.name.pending_value == second
示例#7
0
def test_dirty_but_not_modified(bound_session):
    instance = Model(identifier="foo")
    bound_session.add(instance)
    bound_session.commit()

    # trigger refresh
    assert instance.identifier
    instance.identifier = "foo"
    bound_session.flush()
示例#8
0
def test_dirty_but_not_modified(bound_session):
    instance = Model(identifier="foo")
    bound_session.add(instance)
    bound_session.commit()

    # trigger refresh
    assert instance.identifier
    instance.identifier = "foo"
    bound_session.flush()
示例#9
0
def test_modify_from_to(bound_session, first, second):
    instance = Model(name=first)
    bound_session.add(instance)
    bound_session.commit()
    instance.name = second
    bound_session.commit()
    if second is None:
        assert instance.name is None
    else:
        assert isinstance(instance.name, TranslatableString)
        assert instance.name.pending_value is None
示例#10
0
def test_modify_from_to(bound_session, first, second):
    instance = Model(name=first)
    bound_session.add(instance)
    bound_session.commit()
    instance.name = second
    bound_session.commit()
    if second is None:
        assert instance.name is None
    else:
        assert isinstance(instance.name, TranslatableString)
        assert instance.name.pending_value is None
示例#11
0
def test_edit_other_field(bound_session, session_cls):
    # regression test for translation being removed when editing other fields
    session = bound_session

    instance = Model(id=1, identifier='key', name='name')
    session.add(instance)
    session.commit()

    assert session.query(Translation).count() == 1

    instance = session.query(Model).get(1)
    instance.identifier = "key2"
    session.commit()

    assert session.query(Translation).count() == 1
示例#12
0
def test_removing_translations(session, session_cls, first, second):
    translator = Translator(Translation, session_cls(), 'language')
    translator.bind(session)
    instance = Model(name=first)
    session.add(instance)
    session.commit()

    expected_count = 1 if is_translatable_value(first) else 0
    assert translator.session.query(Translation).count() == expected_count

    instance.name = second
    session.commit()

    expected_count = 1 if is_translatable_value(second) else 0
    assert translator.session.query(Translation).count() == expected_count
示例#13
0
def test_removing_translations(session, session_cls, first, second):
    translator = Translator(Translation, session_cls(), 'language')
    translator.bind(session)
    instance = Model(name=first)
    session.add(instance)
    session.commit()

    expected_count = 1 if is_translatable_value(first) else 0
    assert translator.session.query(Translation).count() == expected_count

    instance.name = second
    session.commit()

    expected_count = 1 if is_translatable_value(second) else 0
    assert translator.session.query(Translation).count() == expected_count
示例#14
0
def test_edit_other_field(bound_session, session_cls):
    # regression test for translation being removed when editing other fields
    session = bound_session

    instance = Model(id=1, identifier='key', name='name')
    session.add(instance)
    session.commit()

    assert session.query(Translation).count() == 1

    instance = session.query(Model).get(1)
    instance.identifier = "key2"
    session.commit()

    assert session.query(Translation).count() == 1
示例#15
0
def test_bulk_update_to_value(bound_session, initial):
    instance = Model(name=initial)
    bound_session.add(instance)
    bound_session.commit()

    with pytest.raises(StatementError):
        bound_session.query(Model).update({'name': 'name'})
示例#16
0
def test_load_translatable_string(bound_session):
    # can happen in session.merge
    instance = Model(name='name')
    bound_session.add(instance)
    attr_before = instance.name
    load(instance, None)
    assert instance.name == attr_before
示例#17
0
def test_use_most_frequent(session_cls):
    session_en = session_cls()
    translator_en = Translator(Translation, session_cls(), 'en')
    translator_en.bind(session_en)

    session_fr = session_cls()
    translator_fr = Translator(Translation, session_cls(), 'fr')
    translator_fr.bind(session_fr)

    def add_with_translation(en, fr):
        model = Model(name=en)
        session_en.add(model)
        session_en.commit()

        # translate into fr
        translatable = model.name
        translatable.pending_value = fr
        translator_fr.save_translation(translatable)

    model = Model(name='a')
    session_en.add(model)
    session_en.commit()

    add_with_translation('a', '1')
    translator_fr.suggest_translation(model.name, 'en', 'fr') == '1'

    add_with_translation('a', '2')
    add_with_translation('a', '2')
    translator_fr.suggest_translation(model.name, 'en', 'fr') == '2'
示例#18
0
def test_save_sentinel(bound_session):
    instance = Model(name=TRANSLATION_MISSING)
    bound_session.add(instance)
    with pytest.raises(RuntimeError) as exc:
        bound_session.commit()
    assert 'Cannot save' in str(exc)
    assert str(TRANSLATION_MISSING) in str(exc)
示例#19
0
def test_bulk_update_normal_field(bound_session):
    # regression test: should be allowed
    instance = Model(name='name')
    bound_session.add(instance)
    bound_session.commit()

    bound_session.query(Model).update({'identifier': 'foo'})
    bound_session.commit()
示例#20
0
def test_bulk_update_to_none(bound_session):
    # not yet supported
    instance = Model(name='name')
    bound_session.add(instance)
    bound_session.commit()

    with pytest.raises(RuntimeError):
        bound_session.query(Model).update({'name': None})
示例#21
0
    def add_with_translation(en, fr):
        model = Model(name=en)
        session_en.add(model)
        session_en.commit()

        # translate into fr
        translatable = model.name
        translatable.pending_value = fr
        translator_fr.save_translation(translatable)
示例#22
0
def test_flushing(bound_session, session_cls, initial):
    instance = Model(name=initial)
    bound_session.add(instance)
    bound_session.flush()

    if initial is None:
        assert instance.name is None
    else:
        assert isinstance(instance.name, TranslatableString)
示例#23
0
def test_set_from_other_model(session, session_cls):
    model1 = Model(name='name')
    model2 = RequiredModel(name=model1.name)
    translator = Translator(Translation, session_cls(), 'language')
    translator.bind(session)
    session.add(model1)
    session.add(model2)
    session.commit()

    assert translator.session.query(
        Translation.context).distinct().count() == 2
示例#24
0
def test_refresh(bound_session, session_cls, value):
    instance = Model(name=value)
    bound_session.add(instance)
    bound_session.commit()
    pk = instance.id

    instance = bound_session.query(Model).get(pk)
    if value is None:
        assert instance.name is None
    else:
        assert isinstance(instance.name, TranslatableString)
示例#25
0
    def test_savepoints(self, session, session_cls):
        translator = Translator(Translation, session_cls(), 'language')
        translator.bind(session)

        instance1 = Model(name='instance 1')
        session.add(instance1)

        session.begin_nested()

        instance2 = Model(name='instance 2')
        session.add(instance2)
        session.flush()
        assert session in flush_log
        assert len(flush_log[session]) == 2

        session.rollback()
        session.commit()

        assert session.query(Model).count() == 1
        assert translator.session.query(Translation).count() == 1
示例#26
0
def test_unknown_language(session_cls):
    session = session_cls()
    translator = Translator(Translation, session_cls(), 'en')
    translator.bind(session)

    model = Model(name='name')
    session.add(model)
    session.commit()

    assert translator.suggest_translation(model.name, 'en', 'foo') is None
    assert translator.suggest_translation(model.name, 'foo', 'en') is None
示例#27
0
    def test_verify(self, session, session_cls):
        # check the test setup works
        translator = Translator(Translation, session_cls(), 'language')
        translator.bind(session)

        assert session not in flush_log
        assert translator.session not in flush_log

        instance1 = Model(name='instance 1')
        session.add(instance1)

        session.flush()
        assert session in flush_log
        assert len(flush_log[session]) == 1
        session.commit()
        assert session not in flush_log

        instance2 = Model(name='instance 2')
        session.add(instance2)
        session.commit()
        assert session not in flush_log
        assert translator.session.query(Translation).count() == 2
示例#28
0
def test_query_values(session_cls):
    session1 = session_cls()
    session2 = session_cls()

    translator = Translator(Translation, session_cls(), 'language')
    translator.bind(session1)
    translator.bind(session2)
    model = Model(name='name')
    session1.add(model)
    session1.commit()

    (value, ) = session2.query(Model.name).one()
    assert value == PlaceholderValue
示例#29
0
    def test_values(self, session_cls):
        session1 = session_cls()
        translator1 = Translator(Translation, session_cls(), 'language1')
        translator1.bind(session1)

        session2 = session_cls()
        translator2 = Translator(Translation, session_cls(), 'language2')
        translator2.bind(session2)

        instance = Model(name='name')
        session1.add(instance)
        session1.commit()
        pk = instance.id

        loaded = session2.query(Model).get(pk)
        assert loaded.name is not None

        instance.name = None
        session1.commit()

        session2.rollback()  # expire isn't enough to trigger reloading
        assert loaded.name is None
        assert translator1.session.query(Translation).count() == 0
示例#30
0
    def test_values(self, session_cls):
        session1 = session_cls()
        translator1 = Translator(Translation, session_cls(), 'language1')
        translator1.bind(session1)

        session2 = session_cls()
        translator2 = Translator(Translation, session_cls(), 'language2')
        translator2.bind(session2)

        instance = Model(name='name')
        session1.add(instance)
        session1.commit()
        pk = instance.id

        loaded = session2.query(Model).get(pk)
        assert loaded.name is not None

        instance.name = None
        session1.commit()

        session2.rollback()  # expire isn't enough to trigger reloading
        assert loaded.name is None
        assert translator1.session.query(Translation).count() == 0
示例#31
0
def test_merge_from_other_session(session_cls):
    """ regression test """
    session1 = session_cls()
    session2 = session_cls()

    translator = Translator(Translation, session_cls(), 'language')
    translator.bind(session1)
    translator.bind(session2)

    instance = Model(name='name')
    session1.add(instance)
    session1.commit()

    session2.merge(instance)
    session2.commit()
示例#32
0
def test_load(session, session_cls, value):
    instance = Model(name=value)
    translator = Translator(Translation, session_cls(), 'language')
    translator.bind(session)
    session.add(instance)
    session.commit()
    pk = instance.id

    # make a new session
    session = session_cls()
    translator.bind(session)
    instance = session.query(Model).get(pk)
    if value is None:
        assert instance.name is None
    else:
        assert isinstance(instance.name, TranslatableString)
示例#33
0
def test_deleting(session, session_cls):
    translator = Translator(Translation, session_cls(), 'language')
    translator.bind(session)
    instance = Model(name='name')
    assert translator.session.query(Translation).count() == 0

    session.add(instance)
    assert translator.session.query(Translation).count() == 0
    session.commit()
    assert translator.session.query(Translation).count() == 1

    session.delete(instance)
    assert translator.session.query(Translation).count() == 1
    session.rollback()
    assert translator.session.query(Translation).count() == 1
    session.commit()
    assert translator.session.query(Translation).count() == 1

    session.delete(instance)
    assert translator.session.query(Translation).count() == 1
    session.commit()
    assert translator.session.query(Translation).count() == 0
示例#34
0
def test_load_error():
    instance = Model()
    instance.__dict__['name'] = 'foo'
    with pytest.raises(TypeError):
        load(instance, None)
示例#35
0
def test_save_none(bound_session):
    instance = Model()
    bound_session.add(instance)
    bound_session.commit()
    assert instance.name is None
示例#36
0
def test_save_value(bound_session):
    instance = Model(name='name')
    bound_session.add(instance)
    bound_session.commit()
    assert isinstance(instance.name, TranslatableString)
    assert instance.name.pending_value is None
示例#37
0
def test_no_data(session):
    model = Model(name='foo')
    translator = Translator(Translation, session, '')
    assert translator.suggest_translation(model.name, 'en', 'fr') is None
# print(X.shape[2])

# model.add(LSTM(4, batch_input_shape=(batch_size, X_train.shape[1], X_train.shape[2]), stateful=True))
# model.add(Dense(1))
# model.compile(loss='mean_squared_error', optimizer='adam')
# for i in range(nb_epoch):
#    model.fit(X_train, y_train, epochs=1, batch_size=batch_size, verbose=0, shuffle=False)
#    model.reset_states()

inputs_1_mae = Input(batch_shape=(batch_size, timesteps, 1))
lstm_1_mae = LSTM(10, stateful=True, return_sequences=True)(inputs_1_mae)
lstm_2_mae = LSTM(10, stateful=True, return_sequences=True)(lstm_1_mae)

output_1_mae = Dense(units=1)(lstm_2_mae)

regressor_mae = Model(inputs=inputs_1_mae, outputs=output_1_mae)

regressor_mae.compile(optimizer='adam', loss='mae')
regressor_mae.summary()

epochs = 2
for i in range(epochs):
    print("Epoch: " + str(i))
    regressor_mae.fit(X_train,
                      y_train,
                      shuffle=False,
                      epochs=1,
                      batch_size=batch_size)
    regressor_mae.reset_states()

test_length = data_misc.get_test_length(dataset=raw_values,