wbfdm 2.2.1__py2.py3-none-any.whl

wbfdm/factories/classifications.py

@@ -0,0 +1,56 @@
+import factory
+import rstr
+from wbfdm.models import (
+    Classification,
+    ClassificationGroup,
+    InstrumentClassificationThroughModel,
+)
+
+
+class ClassificationGroupFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = ClassificationGroup
+        django_get_or_create = ("is_primary",)
+
+    name = factory.Sequence(lambda n: f"Classification Group {n}")
+    is_primary = True
+    max_depth = 1
+    code_level_digits = 2
+
+
+class ClassificationFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Classification
+
+    code_aggregated = factory.LazyAttribute(lambda o: rstr.xeger("([0-9]{8})"))
+    name = factory.Sequence(lambda n: f"Classification {n}")
+    # parent = factory.SubFactory("wbfdm.factories.ParentClassificationFactory", parent=None)
+    group = factory.SubFactory(ClassificationGroupFactory)
+    level = 0
+    # level_representation = factory.LazyAttribute(lambda x: f"Level {x.level}")
+
+
+class ParentClassificationFactory(ClassificationFactory):
+    parent = None
+
+
+class InstrumentClassificationThroughModelFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = InstrumentClassificationThroughModel
+        django_get_or_create = ("instrument", "classification")
+
+    instrument = factory.SubFactory("wbfdm.factories.InstrumentFactory")
+    classification = factory.SubFactory("wbfdm.factories.ClassificationFactory")
+    is_favorite = factory.Faker("pybool")
+    reason = factory.Faker("paragraph")
+    pure_player = factory.Faker("pybool")
+    top_player = factory.Faker("pybool")
+
+    @factory.post_generation
+    def related_instruments(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        if extracted:
+            for instrument in extracted:
+                self.related_instruments.add(instrument)

wbfdm/factories/controversies.py

@@ -0,0 +1,27 @@
+import factory
+from wbfdm.enums import (
+    ESGControveryFlag,
+    ESGControverySeverity,
+    ESGControveryStatus,
+    ESGControveryType,
+)
+from wbfdm.models.esg.controversies import Controversy
+
+
+class ControversyFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Controversy
+
+    instrument = factory.SubFactory("wbfdm.factories.instruments.InstrumentFactory")
+    external_id = factory.LazyAttribute(lambda o: f"{o.instrument.id}-{hash(o.headline)}")
+    headline = factory.Faker("sentence")
+    description = factory.Faker("sentence")
+    source = factory.Faker("company")
+    status = ESGControveryStatus.ONGOING
+    type = ESGControveryType.STRUCTURAL
+    severity = ESGControverySeverity.MINOR
+    flag = ESGControveryFlag.GREEN
+    direct_involvement = True
+    company_response = factory.Faker("sentence")
+    review = factory.Faker("date_object")
+    initiated = factory.Faker("date_object")

wbfdm/factories/exchanges.py

@@ -0,0 +1,21 @@
+import factory
+import rstr
+from wbfdm.models import Exchange
+
+
+class ExchangeFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Exchange
+        django_get_or_create = ("mic_code",)
+
+    city = None
+    name = factory.LazyAttribute(lambda o: f"Exchange: {o.city}")
+    mic_code = factory.LazyAttribute(lambda o: rstr.xeger("([A-Z]{4})"))
+    operating_mic_code = factory.LazyAttribute(lambda o: rstr.xeger("([A-Z]{4})"))
+    bbg_exchange_codes = factory.LazyAttribute(lambda o: [rstr.xeger("([A-Z]{4})")])
+    bbg_composite_primary = factory.Faker("boolean")
+    bbg_composite = factory.LazyAttribute(lambda o: rstr.xeger("([A-Z]{4})"))
+    refinitiv_identifier_code = factory.LazyAttribute(lambda o: rstr.xeger("([A-Z]{4})"))
+
+    website = factory.Faker("url")
+    comments = factory.Faker("paragraph")

wbfdm/factories/instrument_list.py

@@ -0,0 +1,22 @@
+import factory
+from slugify import slugify
+from wbfdm.models import InstrumentList, InstrumentListThroughModel
+
+
+class InstrumentListFactory(factory.django.DjangoModelFactory):
+    name = factory.Faker("word")
+    identifier = factory.LazyAttribute(lambda o: slugify(o.name))
+    instrument_list_type = None
+
+    class Meta:
+        django_get_or_create = ("identifier",)
+        model = InstrumentList
+
+
+class InstrumentListThroughModelFactory(factory.django.DjangoModelFactory):
+    instrument_list = factory.SubFactory(InstrumentListFactory)
+    instrument = factory.SubFactory("wbfdm.factories.instruments.InstrumentFactory")
+
+    class Meta:
+        django_get_or_create = ("instrument_list",)
+        model = InstrumentListThroughModel

wbfdm/factories/instrument_prices.py

@@ -0,0 +1,79 @@
+import random
+from datetime import date
+from decimal import Decimal
+
+import factory
+from pandas.tseries.offsets import BDay
+from wbcore.contrib.currency.models import CurrencyFXRates
+from wbfdm.models import InstrumentPrice
+
+
+def get_weekday(o):
+    if (
+        o.instrument.id
+        and (prices := InstrumentPrice.objects.filter(instrument=o.instrument, calculated=o.calculated)).exists()
+    ):
+        latest_price = prices.latest("date").date
+    else:
+        latest_price = date(2020, 1, 1)
+    return (latest_price + BDay(1)).date()
+
+
+def get_coherent_net_value(o):
+    previous_prices = InstrumentPrice.objects.filter(date__lt=o.date)
+    if previous_prices.exists() and (last_price := previous_prices.latest("date")):
+        return last_price.net_value * Decimal(
+            1 + random.randrange(-5, 5)
+        )  # Simulating a markov chain process of variance 10%
+    return Decimal(100)
+
+
+class InstrumentPriceFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = InstrumentPrice
+        django_get_or_create = ("instrument", "date", "calculated")
+
+    instrument = factory.SubFactory("wbfdm.factories.InstrumentFactory")
+    date = factory.LazyAttribute(lambda o: get_weekday(o))
+    currency_fx_rate_to_usd = factory.LazyAttribute(
+        lambda o: CurrencyFXRates.objects.get_or_create(
+            currency=o.instrument.currency, date=o.date, defaults={"value": Decimal(1.0)}
+        )[0]
+    )
+
+    net_value = factory.Faker("pydecimal", min_value=10, max_value=100, right_digits=6)
+    gross_value = factory.LazyAttribute(lambda o: o.net_value + Decimal(random.random()))
+
+    calculated = False
+    sharpe_ratio = factory.LazyAttribute(lambda o: random.random())
+    correlation = factory.LazyAttribute(lambda o: random.random())
+    beta = factory.LazyAttribute(lambda o: random.random())
+
+    volume = factory.LazyAttribute(lambda o: random.randint(1000, 100000))
+    volume_50d = factory.LazyAttribute(lambda o: random.randint(1000, 100000))
+    volume_200d = factory.LazyAttribute(lambda o: random.randint(1000, 100000))
+    market_capitalization = factory.LazyAttribute(lambda o: random.randint(10000, 100000))
+
+    # custom_beta_180d = factory.Faker("pyfloat", positive=True, max_value=10e3)
+    # custom_beta_1y = factory.Faker("pyfloat", positive=True, max_value=10e3)
+    # custom_beta_2y = factory.Faker("pyfloat", positive=True, max_value=10e3)
+    # custom_beta_3y = factory.Faker("pyfloat", positive=True, max_value=10e3)
+    # custom_beta_5y = factory.Faker("pyfloat", positive=True, max_value=10e3)
+
+    outstanding_shares = None
+    volume_50d = factory.Faker("pyfloat", positive=True, max_value=10e3)
+    volume_200d = factory.Faker("pyfloat", positive=True, max_value=10e3)
+
+    # performance_1d = factory.Faker("pydecimal", min_value=-1, max_value=1)
+    # performance_7d = factory.Faker("pydecimal", min_value=-1, max_value=1)
+    # performance_30d = factory.Faker("pydecimal", min_value=-1, max_value=1)
+    # performance_90d = factory.Faker("pydecimal", min_value=-1, max_value=1)
+    # performance_365d = factory.Faker("pydecimal", min_value=-1, max_value=1)
+    # performance_ytd = factory.Faker("pydecimal", min_value=-1, max_value=1)
+    # performance_inception = factory.Faker("pydecimal", min_value=-1, max_value=1)
+
+    @factory.post_generation
+    def post_gen_currency_creation(self, create, extracted, **kwargs):
+        CurrencyFXRates.objects.get_or_create(
+            currency=self.instrument.currency, date=self.date, defaults={"value": Decimal(1.0)}
+        )

wbfdm/factories/instruments.py

@@ -0,0 +1,63 @@
+import factory
+import rstr
+from slugify import slugify
+from wbfdm.models import Instrument, InstrumentType
+
+
+class InstrumentTypeFactory(factory.django.DjangoModelFactory):
+    name = factory.Faker("word")
+    key = factory.LazyAttribute(lambda o: slugify(o.name))
+
+    class Meta:
+        django_get_or_create = ("key",)
+        model = InstrumentType
+
+
+class InstrumentFactory(factory.django.DjangoModelFactory):
+    name = factory.Faker("company")
+    name_repr = factory.LazyAttribute(lambda x: x.name)
+    description = factory.Faker("paragraph")
+    instrument_type = factory.SubFactory(InstrumentTypeFactory)
+    inception_date = factory.Faker("past_date")
+    delisted_date = None
+    currency = factory.SubFactory("wbcore.contrib.currency.factories.CurrencyFactory")
+    country = factory.SubFactory("wbcore.contrib.geography.factories.CountryFactory")
+    exchange = factory.SubFactory("wbfdm.factories.exchanges.ExchangeFactory")
+
+    identifier = factory.LazyAttribute(lambda o: rstr.xeger("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})"))
+    isin = factory.LazyAttribute(lambda o: rstr.xeger("([A-Z]{2}[A-Z0-9]{9}[0-9]{1})"))
+    ticker = factory.LazyAttribute(lambda o: rstr.xeger("([A-Z]{4})"))
+    dl_parameters = {"market_data": {"path": "wbfdm.contrib.internal.dataloaders.market_data.MarketDataDataloader"}}
+
+    @factory.post_generation
+    def classifications(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        if extracted:
+            for classification in extracted:
+                self.classifications.add(classification)
+
+    @factory.post_generation
+    def related_instruments(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        if extracted:
+            for instrument in extracted:
+                self.related_instruments.add(instrument)
+
+    class Meta:
+        model = Instrument
+
+
+class CashFactory(InstrumentFactory):
+    is_cash = True
+    instrument_type = factory.LazyAttribute(lambda o: InstrumentTypeFactory.create(name="Cash", key="cash"))
+
+
+class EquityFactory(InstrumentFactory):
+    instrument_type = factory.LazyAttribute(lambda o: InstrumentTypeFactory.create(name="Equity", key="equity"))
+
+    class Meta:
+        model = Instrument

wbfdm/factories/instruments_relationships.py

@@ -0,0 +1,31 @@
+import factory
+from wbfdm.models import InstrumentFavoriteGroup, RelatedInstrumentThroughModel
+
+
+class RelatedInstrumentThroughModelFactory(factory.django.DjangoModelFactory):
+    instrument = factory.SubFactory("wbfdm.factories.InstrumentFactory")
+    related_instrument = factory.SubFactory("wbfdm.factories.InstrumentFactory")
+    related_type = factory.Iterator(RelatedInstrumentThroughModel.RelatedTypeChoices.values)
+
+    class Meta:
+        model = RelatedInstrumentThroughModel
+        django_get_or_create = ("instrument", "related_instrument", "related_type")
+
+
+class InstrumentFavoriteGroupFactory(factory.django.DjangoModelFactory):
+    name = factory.Faker("company")
+    owner = factory.SubFactory("wbcore.contrib.directory.factories.PersonFactory")
+    public = factory.Faker("pybool")
+    primary = factory.Faker("pybool")
+
+    class Meta:
+        model = InstrumentFavoriteGroup
+
+    @factory.post_generation
+    def instruments(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        if extracted:
+            for instrument in extracted:
+                self.instruments.add(instrument)

wbfdm/factories/options.py

@@ -0,0 +1,66 @@
+from datetime import timedelta
+
+import factory
+from faker import Faker
+from pandas.tseries.offsets import BDay
+from wbfdm.models import Option, OptionAggregate
+
+fake = Faker()
+
+
+class OptionAggregateFactory(factory.django.DjangoModelFactory):
+    type = factory.Iterator(Option.Type)
+    date = factory.LazyAttribute(lambda o: (fake.date_object() + BDay(1)).date())
+    instrument = factory.SubFactory("wbfdm.factories.InstrumentFactory")
+
+    volume = factory.Faker("pyfloat")
+    volume_5d = factory.Faker("pyfloat")
+    volume_20d = factory.Faker("pyfloat")
+    volume_50d = factory.Faker("pyfloat")
+
+    open_interest = factory.Faker("pyfloat")
+    volatility_30d = factory.Faker("pyfloat")
+    volatility_60d = factory.Faker("pyfloat")
+    volatility_90d = factory.Faker("pyfloat")
+
+    class Meta:
+        django_get_or_create = ("type", "instrument", "date")
+        model = OptionAggregate
+
+
+class OptionFactory(factory.django.DjangoModelFactory):
+    type = factory.Iterator(Option.Type)
+    contract_identifier = factory.Faker("word")
+    date = factory.LazyAttribute(lambda o: (fake.date_object() + BDay(1)).date())
+    expiration_date = factory.LazyAttribute(lambda o: o.date + timedelta(days=7))
+    instrument = factory.SubFactory("wbfdm.factories.InstrumentFactory")
+    strike = factory.Faker("pyfloat")
+    open = factory.Faker("pyfloat")
+    high = factory.Faker("pyfloat")
+    low = factory.Faker("pyfloat")
+    close = factory.Faker("pyfloat")
+    bid = factory.Faker("pyfloat")
+    ask = factory.Faker("pyfloat")
+    volume = factory.Faker("pyfloat")
+    open_interest = factory.Faker("pyfloat")
+    vwap = factory.Faker("pyfloat")
+    volatility_30d = factory.Faker("pyfloat")
+    volatility_60d = factory.Faker("pyfloat")
+    volatility_90d = factory.Faker("pyfloat")
+    risk_delta = factory.Faker("pyfloat")
+    risk_theta = factory.Faker("pyfloat")
+    risk_gamma = factory.Faker("pyfloat")
+    risk_vega = factory.Faker("pyfloat")
+    risk_rho = factory.Faker("pyfloat")
+    risk_lambda = factory.Faker("pyfloat")
+    risk_epsilon = factory.Faker("pyfloat")
+    risk_vomma = factory.Faker("pyfloat")
+    risk_vera = factory.Faker("pyfloat")
+    risk_speed = factory.Faker("pyfloat")
+    risk_zomma = factory.Faker("pyfloat")
+    risk_color = factory.Faker("pyfloat")
+    risk_ultima = factory.Faker("pyfloat")
+
+    class Meta:
+        django_get_or_create = ("contract_identifier", "type", "instrument", "date")
+        model = Option

wbfdm/figures/__init__.py

@@ -0,0 +1 @@
+from .financials import FinancialsChartGenerator

wbfdm/figures/financials/__init__.py

@@ -0,0 +1 @@
+from .financials_charts import FinancialsChartGenerator