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'
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
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()
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
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()
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
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
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
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'})
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
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'
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)
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()
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})
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)
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)
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
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)
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
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
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
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
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
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()
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)
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
def test_load_error(): instance = Model() instance.__dict__['name'] = 'foo' with pytest.raises(TypeError): load(instance, None)
def test_save_none(bound_session): instance = Model() bound_session.add(instance) bound_session.commit() assert instance.name is None
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
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,