Exemple #1
0
    def test_register_no_create(self):
        called = [False]

        @self.register("bundle", create_writers=False)
        def bundle_ingest(
            environ,
            asset_db_writer,
            minute_bar_writer,
            daily_bar_writer,
            adjustment_writer,
            calendar,
            start_session,
            end_session,
            cache,
            show_progress,
            output_dir,
        ):
            assert_is_none(asset_db_writer)
            assert_is_none(minute_bar_writer)
            assert_is_none(daily_bar_writer)
            assert_is_none(adjustment_writer)
            called[0] = True

        self.ingest("bundle", self.environ)
        assert_true(called[0])
Exemple #2
0
    def test_register_no_create(self):
        called = [False]

        @self.register("bundle", create_writers=False)
        def bundle_ingest(
            environ,
            asset_db_writer,
            minute_bar_writer,
            daily_bar_writer,
            adjustment_writer,
            calendar,
            start_session,
            end_session,
            cache,
            show_progress,
            output_dir,
        ):
            assert_is_none(asset_db_writer)
            assert_is_none(minute_bar_writer)
            assert_is_none(daily_bar_writer)
            assert_is_none(adjustment_writer)
            called[0] = True

        self.ingest("bundle", self.environ)
        assert_true(called[0])
Exemple #3
0
 def check_registered():
     assert_true(
         rm.is_registered("ayy-lmao"),
         "Class ProperDummyInterface wasn't properly registered under"
         "name 'ayy-lmao'",
     )
     self.assertIsInstance(rm.load("ayy-lmao"), ProperDummyInterface)
 def check_registered():
     assert_true(
         rm.is_registered('ayy-lmao'),
         "Class ProperDummyInterface wasn't properly registered under"
         "name 'ayy-lmao'"
     )
     self.assertIsInstance(rm.load('ayy-lmao'), ProperDummyInterface)
Exemple #5
0
    def test_ingest_assets_versions(self):
        versions = (1, 2)

        called = [False]

        @self.register('bundle', create_writers=False)
        def bundle_ingest_no_create_writers(*args, **kwargs):
            called[0] = True

        now = pd.Timestamp.utcnow()
        with self.assertRaisesRegex(ValueError,
                                    "ingest .* creates writers .* downgrade"):
            self.ingest('bundle',
                        self.environ,
                        assets_versions=versions,
                        timestamp=now - pd.Timedelta(seconds=1))
        assert_false(called[0])
        assert_equal(len(ingestions_for_bundle('bundle', self.environ)), 1)

        @self.register('bundle', create_writers=True)
        def bundle_ingest_create_writers(environ, asset_db_writer,
                                         minute_bar_writer, daily_bar_writer,
                                         adjustment_writer, calendar,
                                         start_session, end_session, cache,
                                         show_progress, output_dir):
            self.assertIsNotNone(asset_db_writer)
            self.assertIsNotNone(minute_bar_writer)
            self.assertIsNotNone(daily_bar_writer)
            self.assertIsNotNone(adjustment_writer)

            equities = make_simple_equity_info(
                tuple(range(3)),
                self.START_DATE,
                self.END_DATE,
            )
            asset_db_writer.write(equities=equities)
            called[0] = True

        # Explicitly use different timestamp; otherwise, test could run so fast
        # that first ingestion is re-used.
        self.ingest('bundle',
                    self.environ,
                    assets_versions=versions,
                    timestamp=now)
        assert_true(called[0])

        ingestions = ingestions_for_bundle('bundle', self.environ)
        assert_equal(len(ingestions), 2)
        for version in sorted(set(versions) | {ASSET_DB_VERSION}):
            eng = sa.create_engine('sqlite:///' + asset_db_path(
                'bundle',
                to_bundle_ingest_dirname(ingestions[0]),  # most recent
                self.environ,
                version,
            ))
            metadata = sa.MetaData()
            metadata.reflect(eng)
            version_table = metadata.tables['version_info']
            check_version_info(eng, version_table, version)
Exemple #6
0
    def test_with_metaclasses_no_subclasses(self):
        class E(with_metaclasses((M, N))):
            pass

        assert_true(E.M)
        assert_true(E.N)

        assert_is_instance(E, M)
        assert_is_instance(E, N)
Exemple #7
0
    def test_with_metaclasses_no_subclasses(self):
        class E(with_metaclasses((M, N))):
            pass

        assert_true(E.M)
        assert_true(E.N)

        assert_is_instance(E, M)
        assert_is_instance(E, N)
Exemple #8
0
    def test_ingest_assets_versions(self):
        versions = (1, 2)

        called = [False]

        @self.register("bundle", create_writers=False)
        def bundle_ingest_no_create_writers(*args, **kwargs):
            called[0] = True

        now = pd.Timestamp.utcnow()
        with self.assertRaisesRegexp(ValueError, "ingest .* creates writers .* downgrade"):
            self.ingest("bundle", self.environ, assets_versions=versions, timestamp=now - pd.Timedelta(seconds=1))
        assert_false(called[0])
        assert_equal(len(ingestions_for_bundle("bundle", self.environ)), 1)

        @self.register("bundle", create_writers=True)
        def bundle_ingest_create_writers(
            environ,
            asset_db_writer,
            minute_bar_writer,
            daily_bar_writer,
            adjustment_writer,
            calendar,
            start_session,
            end_session,
            cache,
            show_progress,
            output_dir,
        ):
            self.assertIsNotNone(asset_db_writer)
            self.assertIsNotNone(minute_bar_writer)
            self.assertIsNotNone(daily_bar_writer)
            self.assertIsNotNone(adjustment_writer)

            equities = make_simple_equity_info(tuple(range(3)), self.START_DATE, self.END_DATE)
            asset_db_writer.write(equities=equities)
            called[0] = True

        # Explicitly use different timestamp; otherwise, test could run so fast
        # that first ingestion is re-used.
        self.ingest("bundle", self.environ, assets_versions=versions, timestamp=now)
        assert_true(called[0])

        ingestions = ingestions_for_bundle("bundle", self.environ)
        assert_equal(len(ingestions), 2)
        for version in sorted(set(versions) | {ASSET_DB_VERSION}):
            eng = sa.create_engine(
                "sqlite:///"
                + asset_db_path("bundle", to_bundle_ingest_dirname(ingestions[0]), self.environ, version)  # most recent
            )
            metadata = sa.MetaData()
            metadata.reflect(eng)
            version_table = metadata.tables["version_info"]
            check_version_info(eng, version_table, version)
Exemple #9
0
    def test_register_non_decorator(self):
        rm = Registry(FakeInterface)
        assert_equal(rm.get_registered_classes(), {})

        class ProperDummyInterface(FakeInterface):
            pass

        rm.register('ayy-lmao', ProperDummyInterface)

        expected_classes = {'ayy-lmao': ProperDummyInterface}
        assert_equal(rm.get_registered_classes(), expected_classes)
        assert_is(rm.load('ayy-lmao'), ProperDummyInterface)
        assert_true(
            rm.class_registered('ayy-lmao'),
            "Class ProperDummyInterface wasn't properly registered under"
            "name 'ayy-lmao'")

        class Fake(object):
            pass

        msg = "FakeInterface class 'ayy-lmao' is already registered"
        with assert_raises_str(ValueError, msg):
            rm.register('ayy-lmao', Fake)

        class ImproperDummyInterface(object):
            pass

        msg = "The class specified is not a subclass of FakeInterface"
        with assert_raises_str(TypeError, msg):
            rm.register('something-different', ImproperDummyInterface)

        # ensure that the failed registration didn't break the previously
        # registered interface class
        assert_equal(rm.get_registered_classes(), expected_classes)
        assert_is(rm.load('ayy-lmao'), ProperDummyInterface)

        rm.unregister('ayy-lmao')
        assert_equal(rm.get_registered_classes(), {})

        msg = ("no FakeInterface class registered under name 'ayy-lmao', "
               "options are: []")
        with assert_raises_str(ValueError, msg):
            rm.load('ayy-lmao')

        msg = "FakeInterface class 'ayy-lmao' was not already registered"
        with assert_raises_str(ValueError, msg):
            rm.unregister('ayy-lmao')