wbfdm 2.2.1__py2.py3-none-any.whl

wbfdm/import_export/resources/instruments.py

@@ -0,0 +1,176 @@
+import magic
+from django.apps import apps
+from django.db.models import Q
+from import_export import fields
+from import_export.formats.base_formats import CSV
+from import_export.results import RowResult
+from import_export.signals import post_import
+from import_export.widgets import CharWidget, ForeignKeyWidget, ManyToManyWidget
+from rest_framework.reverse import reverse
+from wbcore.contrib.currency.models import Currency
+from wbcore.contrib.geography.import_export.resources.geography import (
+    CountryForeignKeyWidget,
+)
+from wbcore.contrib.io.resources import FilterModelResource
+from wbcore.contrib.notifications.dispatch import send_notification
+from wbfdm.models import Exchange, Instrument, InstrumentClassificationThroughModel
+
+from .classification import ClassificationManyToManyWidget
+
+
+class TypeWidget(CharWidget):
+    def clean(self, value, row=None, **kwargs):
+        return super().clean(value.lower().name(), row=row, **kwargs)
+
+
+class InstrumentResource(FilterModelResource):
+    """
+    The resource to download AssetPositions
+    """
+
+    instrument_type = fields.Field(column_name="instrument_type", attribute="instrument_type", widget=TypeWidget())
+
+    country = fields.Field(
+        column_name="country",
+        attribute="country",
+        widget=CountryForeignKeyWidget(),
+    )
+
+    exchanges = fields.Field(
+        column_name="exchanges",
+        attribute="exchanges",
+        m2m_add=True,
+        widget=ManyToManyWidget(Exchange, field="mic_code"),
+    )
+
+    currency = fields.Field(
+        column_name="currency",
+        attribute="currency",
+        widget=ForeignKeyWidget(Currency, field="key__iexact"),
+    )
+
+    primary_classifications = fields.Field(
+        column_name="primary_classifications",
+        attribute="classifications",
+        m2m_add=True,
+        widget=ClassificationManyToManyWidget(primary_classification_group=True),
+    )
+    default_classifications = fields.Field(
+        column_name="default_classifications",
+        attribute="classifications",
+        m2m_add=True,
+        widget=ClassificationManyToManyWidget(primary_classification_group=False),
+    )
+
+    def save_m2m(self, obj, data, using_transactions, dry_run):
+        """
+        override save m2m to define what to to with the nested classification instrument through model values
+        """
+        if (not using_transactions and dry_run) or self._meta.use_bulk:
+            # we don't have transactions and we want to do a dry_run
+            # OR use_bulk is enabled (m2m operations are not supported for bulk operations)
+            pass
+        else:
+            for field in self.get_import_fields():
+                if isinstance(field.widget, ClassificationManyToManyWidget):
+                    defaults = {
+                        "is_favorite": str(data.get(f"{field.column_name}__is_favorite", "")).lower()
+                        in ["1", "true", "yes"],
+                        "reason": data.get(f"{field.column_name}__reason", None),
+                        "pure_player": data.get(f"{field.column_name}__pure_player", None),
+                        "top_player": data.get(f"{field.column_name}__top_player", None),
+                        "percent_of_revenue": data.get(f"{field.column_name}__percent_of_revenue", None),
+                    }
+                    defaults = {k: v for k, v in defaults.items() if v is not None}
+                    for classification in field.clean(data):
+                        InstrumentClassificationThroughModel.objects.update_or_create(
+                            instrument=obj, classification=classification, defaults=defaults
+                        )
+                elif isinstance(field.widget, ManyToManyWidget):
+                    self.import_field(field, obj, data, True)
+
+    def get_instance(self, instance_loader, row):
+        try:
+            return Instrument.objects.get(
+                Q(isin=row["isin"]) | Q(refinitiv_identifier_code=row["refinitiv_identifier_code"])
+            )
+        except Instrument.DoesNotExist:
+            return None
+
+    class Meta:
+        import_id_fields = ("isin",)
+        fields = (
+            "id",
+            "founded_year",
+            "inception_date",
+            "delisted_date",
+            "identifier",
+            "name",
+            "name_repr",
+            "description",
+            "isin",
+            "ticker",
+            "refinitiv_ticker",
+            "refinitiv_identifier_code",
+            "refinitiv_mnemonic_code",
+            "sedol",
+            "valoren",
+            "headquarter_address",
+            "primary_url",
+            "is_cash",
+            "instrument_type",
+            "country",
+            "exchanges",
+            "currency",
+            "primary_classifications",
+            "default_classifications",
+        )
+        export_order = fields
+        model = Instrument
+
+
+# This parser satisfy the import source framework interface. The generic logic will probably need to move the io module to avoid repetition
+def parse(import_source):
+    input_format = CSV(encoding="utf-8-sig")
+
+    file_stream = import_source.file.read()
+    if input_format.CONTENT_TYPE == magic.from_buffer(file_stream, mime=True):
+        dataset = input_format.create_dataset(file_stream)
+
+        model = apps.get_model(import_source.parser_handler.handler)
+        result = InstrumentResource().import_data(
+            dataset,
+            dry_run=False,
+            file_name=import_source.file.name,
+            user=import_source.creator,
+            rollback_on_validation_errors=True,
+        )
+        import_source.file.close()
+        post_import.send(sender=None, model=model)
+        success_message = """
+        {} import finished:
+        * new {}
+        * updated {}
+        * skipped {}
+        * failed {}
+        * deleted {}
+        * invalid {}
+        """.format(
+            model._meta.verbose_name_plural,
+            result.totals[RowResult.IMPORT_TYPE_NEW],
+            result.totals[RowResult.IMPORT_TYPE_UPDATE],
+            result.totals[RowResult.IMPORT_TYPE_SKIP],
+            result.totals[RowResult.IMPORT_TYPE_ERROR],
+            result.totals[RowResult.IMPORT_TYPE_DELETE],
+            result.totals[RowResult.IMPORT_TYPE_INVALID],
+        )
+        import_source.log = success_message
+        import_source.save()
+        if import_source.creator:
+            send_notification(
+                code="io.import_done",
+                name="Your import is done",
+                body=success_message,
+                user=import_source.creator,
+                endpoint=reverse(f"{model.get_base_endpoint()}-list") if hasattr(model, "get_base_endpoint") else None,
+            )

wbfdm/jinja2.py

@@ -0,0 +1,7 @@
+from jinja2 import Environment
+from jinjasql import JinjaSql  # type: ignore
+
+
+def get_environment(**options):
+    env = Environment(**options)
+    return JinjaSql(env=env, param_style="format").env

wbfdm/management/__init__.py

@@ -0,0 +1,30 @@
+from django_celery_beat.models import IntervalSchedule, PeriodicTask
+from django.db import DEFAULT_DB_ALIAS
+from django.apps import apps as global_apps
+
+
+def initialize_task(app_config, verbosity=2, interactive=True, using=DEFAULT_DB_ALIAS, apps=global_apps, **kwargs):
+    PeriodicTask.objects.get_or_create(
+        task="wbfdm.tasks.update_of_investable_universe_data",
+        defaults={
+            "name": "FDM: Periodic data update of investable universe",
+            "interval": IntervalSchedule.objects.get_or_create(every=3, period=IntervalSchedule.HOURS)[0],
+            "crontab": None,
+        },
+    )
+    PeriodicTask.objects.get_or_create(
+        task="wbfdm.tasks.synchronize_instruments_as_task",
+        defaults={
+            "name": "FDM: Synchronize Instrument",
+            "interval": IntervalSchedule.objects.get_or_create(every=30, period=IntervalSchedule.MINUTES)[0],
+            "crontab": None,
+        },
+    )
+    PeriodicTask.objects.get_or_create(
+        task="wbfdm.tasks.synchronize_exchanges_as_task",
+        defaults={
+            "name": "FDM: Synchronize Exchange",
+            "interval": IntervalSchedule.objects.get_or_create(every=30, period=IntervalSchedule.MINUTES)[0],
+            "crontab": None,
+        },
+    )

wbfdm/menu.py

@@ -0,0 +1,11 @@
+from django.utils.translation import gettext as _
+from wbcore.menus import ItemPermission, MenuItem
+from wbcore.permissions.shortcuts import is_internal_user
+
+INSTRUMENT_MENU_ITEM = MenuItem(
+    label=_("Instruments"),
+    endpoint="wbfdm:instrument-list",
+    permission=ItemPermission(
+        method=lambda request: is_internal_user(request.user), permissions=["wbfdm.view_instrument"]
+    ),
+)

wbfdm/migrations/0001_initial.py

@@ -0,0 +1,71 @@
+# Generated by Django 4.1.9 on 2023-06-14 07:31
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name="Instrument",
+            fields=[
+                ("id", models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("name", models.CharField(max_length=512)),
+            ],
+            options={
+                "verbose_name": "Instrument",
+                "verbose_name_plural": "Instruments",
+            },
+        ),
+        migrations.CreateModel(
+            name="InstrumentLookup",
+            fields=[
+                ("id", models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("identifier", models.CharField(max_length=64)),
+                ("backend_path", models.CharField(max_length=265)),
+                ("prices", models.BooleanField(default=False)),
+                ("dividends", models.BooleanField(default=False)),
+                ("corporate_actions", models.BooleanField(default=False)),
+                ("statements", models.BooleanField(default=False)),
+                ("estimates", models.BooleanField(default=False)),
+                ("officers", models.BooleanField(default=False)),
+                (
+                    "instrument",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE, related_name="lookups", to="wbfdm.instrument"
+                    ),
+                ),
+            ],
+        ),
+        migrations.CreateModel(
+            name="InstrumentIdentifier",
+            fields=[
+                ("id", models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("identifier", models.CharField(max_length=32)),
+                (
+                    "identifier_type",
+                    models.CharField(
+                        choices=[
+                            ("ISIN", "ISIN"),
+                            ("RIC", "RIC"),
+                            ("BBG", "BBG"),
+                            ("TICKER", "Ticker"),
+                            ("VALOREN", "Valoren"),
+                            ("WKN", "WKN"),
+                        ],
+                        max_length=32,
+                    ),
+                ),
+                (
+                    "instrument",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE, related_name="identifiers", to="wbfdm.instrument"
+                    ),
+                ),
+            ],
+        ),
+    ]

wbfdm/migrations/0002_rename_statements_instrumentlookup_financials_and_more.py

@@ -0,0 +1,144 @@
+# Generated by Django 4.1.9 on 2023-06-23 11:51
+
+import django.db.models.deletion
+import wbfdm.models.fk_fields
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("wbfdm", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.RenameField(
+            model_name="instrumentlookup",
+            old_name="statements",
+            new_name="financials",
+        ),
+        migrations.AddField(
+            model_name="instrument",
+            name="bbg_lookup",
+            field=wbfdm.models.fk_fields.CompositeForeignKey(
+                null=True,
+                null_if_equal=[],
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="+",
+                to="wbfdm.instrumentidentifier",
+                to_fields={
+                    "identifier_type": wbfdm.models.fk_fields.RawFieldValue("BBG"),
+                    "instrument": wbfdm.models.fk_fields.LocalFieldValue("id"),
+                },
+            ),
+        ),
+        migrations.AddField(
+            model_name="instrument",
+            name="financial_backend",
+            field=wbfdm.models.fk_fields.CompositeForeignKey(
+                null=True,
+                null_if_equal=[],
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="wbfdm.instrumentlookup",
+                to_fields={
+                    "financials": wbfdm.models.fk_fields.RawFieldValue(True),
+                    "instrument_id": wbfdm.models.fk_fields.LocalFieldValue("id"),
+                },
+            ),
+        ),
+        migrations.AddField(
+            model_name="instrument",
+            name="isin_lookup",
+            field=wbfdm.models.fk_fields.CompositeForeignKey(
+                null=True,
+                null_if_equal=[],
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="+",
+                to="wbfdm.instrumentidentifier",
+                to_fields={
+                    "identifier_type": wbfdm.models.fk_fields.RawFieldValue("ISIN"),
+                    "instrument": wbfdm.models.fk_fields.LocalFieldValue("id"),
+                },
+            ),
+        ),
+        migrations.AddField(
+            model_name="instrument",
+            name="price_backend",
+            field=wbfdm.models.fk_fields.CompositeForeignKey(
+                null=True,
+                null_if_equal=[],
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="wbfdm.instrumentlookup",
+                to_fields={
+                    "instrument_id": wbfdm.models.fk_fields.LocalFieldValue("id"),
+                    "prices": wbfdm.models.fk_fields.RawFieldValue(True),
+                },
+            ),
+        ),
+        migrations.AddField(
+            model_name="instrument",
+            name="ric_lookup",
+            field=wbfdm.models.fk_fields.CompositeForeignKey(
+                null=True,
+                null_if_equal=[],
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="+",
+                to="wbfdm.instrumentidentifier",
+                to_fields={
+                    "identifier_type": wbfdm.models.fk_fields.RawFieldValue("RIC"),
+                    "instrument": wbfdm.models.fk_fields.LocalFieldValue("id"),
+                },
+            ),
+        ),
+        migrations.AddField(
+            model_name="instrument",
+            name="ticker_lookup",
+            field=wbfdm.models.fk_fields.CompositeForeignKey(
+                null=True,
+                null_if_equal=[],
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="+",
+                to="wbfdm.instrumentidentifier",
+                to_fields={
+                    "identifier_type": wbfdm.models.fk_fields.RawFieldValue("TICKER"),
+                    "instrument": wbfdm.models.fk_fields.LocalFieldValue("id"),
+                },
+            ),
+        ),
+        migrations.AddField(
+            model_name="instrument",
+            name="valoren_lookup",
+            field=wbfdm.models.fk_fields.CompositeForeignKey(
+                null=True,
+                null_if_equal=[],
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="+",
+                to="wbfdm.instrumentidentifier",
+                to_fields={
+                    "identifier_type": wbfdm.models.fk_fields.RawFieldValue("VALOREN"),
+                    "instrument": wbfdm.models.fk_fields.LocalFieldValue("id"),
+                },
+            ),
+        ),
+        migrations.AddField(
+            model_name="instrument",
+            name="wkn_lookup",
+            field=wbfdm.models.fk_fields.CompositeForeignKey(
+                null=True,
+                null_if_equal=[],
+                on_delete=django.db.models.deletion.SET_NULL,
+                related_name="+",
+                to="wbfdm.instrumentidentifier",
+                to_fields={
+                    "identifier_type": wbfdm.models.fk_fields.RawFieldValue("WKN"),
+                    "instrument": wbfdm.models.fk_fields.LocalFieldValue("id"),
+                },
+            ),
+        ),
+        migrations.AddField(
+            model_name="instrumentlookup",
+            name="parameters",
+            field=models.JSONField(default=dict, null=True),
+        ),
+    ]

wbfdm/migrations/0003_instrument_estimate_backend_and_more.py

@@ -0,0 +1,34 @@
+# Generated by Django 4.1.9 on 2023-07-11 08:24
+
+import django.db.models.deletion
+import wbfdm.models.fk_fields
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("wbfdm", "0002_rename_statements_instrumentlookup_financials_and_more"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="instrument",
+            name="estimate_backend",
+            field=wbfdm.models.fk_fields.CompositeForeignKey(
+                null=True,
+                null_if_equal=[],
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="wbfdm.instrumentlookup",
+                to_fields={
+                    "estimates": wbfdm.models.fk_fields.RawFieldValue(True),
+                    "instrument_id": wbfdm.models.fk_fields.LocalFieldValue("id"),
+                },
+            ),
+        ),
+        migrations.AlterField(
+            model_name="instrumentlookup",
+            name="parameters",
+            field=models.JSONField(blank=True, default=dict, null=True),
+        ),
+    ]

wbfdm/migrations/0004_rename_financials_instrumentlookup_statements_and_more.py

@@ -0,0 +1,86 @@
+# Generated by Django 4.1.9 on 2023-07-12 14:44
+
+import django.db.models.deletion
+import wbfdm.models.fk_fields
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("wbfdm", "0003_instrument_estimate_backend_and_more"),
+    ]
+
+    operations = [
+        migrations.RenameField(
+            model_name="instrumentlookup",
+            old_name="financials",
+            new_name="statements",
+        ),
+        migrations.RemoveField(
+            model_name="instrument",
+            name="financial_backend",
+        ),
+        migrations.AddField(
+            model_name="instrument",
+            name="statement_backend",
+            field=wbfdm.models.fk_fields.CompositeForeignKey(
+                null=True,
+                null_if_equal=[],
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="wbfdm.instrumentlookup",
+                to_fields={
+                    "instrument_id": wbfdm.models.fk_fields.LocalFieldValue("id"),
+                    "statements": wbfdm.models.fk_fields.RawFieldValue(True),
+                },
+            ),
+        ),
+        migrations.RenameField(
+            model_name="instrumentlookup",
+            old_name="estimates",
+            new_name="financials",
+        ),
+        migrations.RemoveField(
+            model_name="instrument",
+            name="estimate_backend",
+        ),
+        migrations.AddField(
+            model_name="instrument",
+            name="financial_backend",
+            field=wbfdm.models.fk_fields.CompositeForeignKey(
+                null=True,
+                null_if_equal=[],
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="wbfdm.instrumentlookup",
+                to_fields={
+                    "financials": wbfdm.models.fk_fields.RawFieldValue(True),
+                    "instrument_id": wbfdm.models.fk_fields.LocalFieldValue("id"),
+                },
+            ),
+        ),
+        migrations.RenameField(
+            model_name="instrumentlookup",
+            old_name="prices",
+            new_name="market_data",
+        ),
+        migrations.RemoveField(
+            model_name="instrument",
+            name="price_backend",
+        ),
+        migrations.AddField(
+            model_name="instrument",
+            name="market_data_backend",
+            field=wbfdm.models.fk_fields.CompositeForeignKey(
+                null=True,
+                null_if_equal=[],
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="wbfdm.instrumentlookup",
+                to_fields={
+                    "instrument_id": wbfdm.models.fk_fields.LocalFieldValue("id"),
+                    "market_data": wbfdm.models.fk_fields.RawFieldValue(True),
+                },
+            ),
+        ),
+    ]

wbfdm/migrations/0005_instrument_corporate_action_backend.py

@@ -0,0 +1,29 @@
+# Generated by Django 4.1.9 on 2023-07-19 07:42
+
+import django.db.models.deletion
+import wbfdm.models.fk_fields
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("wbfdm", "0004_rename_financials_instrumentlookup_statements_and_more"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="instrument",
+            name="corporate_action_backend",
+            field=wbfdm.models.fk_fields.CompositeForeignKey(
+                null=True,
+                null_if_equal=[],
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="wbfdm.instrumentlookup",
+                to_fields={
+                    "corporate_actions": wbfdm.models.fk_fields.RawFieldValue(True),
+                    "instrument_id": wbfdm.models.fk_fields.LocalFieldValue("id"),
+                },
+            ),
+        ),
+    ]

wbfdm/migrations/0006_instrument_officer_backend.py

@@ -0,0 +1,29 @@
+# Generated by Django 4.1.11 on 2023-10-04 06:48
+
+import django.db.models.deletion
+import wbfdm.models.fk_fields
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("wbfdm", "0005_instrument_corporate_action_backend"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="instrument",
+            name="officer_backend",
+            field=wbfdm.models.fk_fields.CompositeForeignKey(
+                null=True,
+                null_if_equal=[],
+                on_delete=django.db.models.deletion.DO_NOTHING,
+                related_name="+",
+                to="wbfdm.instrumentlookup",
+                to_fields={
+                    "instrument_id": wbfdm.models.fk_fields.LocalFieldValue("id"),
+                    "officers": wbfdm.models.fk_fields.RawFieldValue(True),
+                },
+            ),
+        ),
+    ]