wbportfolio 2.2.1__py2.py3-none-any.whl

wbportfolio/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

wbportfolio/admin/__init__.py

@@ -0,0 +1,12 @@
+# Import CRM Relevant Data
+from .portfolio_relationships import PortfolioInstrumentPreferredClassificationThroughInlineModelAdmin
+from .asset import AssetPositionModelAdmin
+from .custodians import CustodianModelAdmin
+from .products import ProductAdmin
+from .product_groups import ProductGroupAdmin
+from .portfolio import PortfolioModelAdmin
+from .registers import RegisterModelAdmin
+from .roles import PortfolioRoleAdmin
+from .synchronization import *
+from .transactions import DividendAdmin, FeesAdmin, TradeAdmin, TransactionModelAdmin
+from .reconciliations import AccountReconciliationAdmin

wbportfolio/admin/asset.py

@@ -0,0 +1,47 @@
+from django.contrib import admin
+from wbportfolio.models import AssetPosition
+
+
+@admin.register(AssetPosition)
+class AssetPositionModelAdmin(admin.ModelAdmin):
+    list_filter = ("underlying_instrument", "portfolio")
+    search_fields = (
+        "underlying_instrument__name",
+        "underlying_instrument__ticker",
+    )
+    # date_hierarchy = "date"
+    list_filter = ("underlying_instrument__instrument_type",)
+    list_display = (
+        "date",
+        "_price",
+        "currency",
+        "_currency_fx_rate",
+        "_shares",
+        "_total_value_fx_usd",
+        "weighting",
+        "portfolio",
+        "underlying_instrument",
+    )
+    readonly_fields = [
+        "_market_capitalization",
+        "_price",
+        "_currency_fx_rate",
+        "_price_fx_portfolio",
+        "_total_value",
+        "_total_value_fx_usd",
+        "_total_value_fx_portfolio",
+        "_market_share",
+    ]
+    autocomplete_fields = [
+        "portfolio",
+        "currency",
+        "underlying_instrument",
+    ]
+    ordering = ("-date",)
+    raw_id_fields = [
+        "import_source",
+        "applied_adjustment",
+        "underlying_instrument_price",
+        "currency_fx_rate_instrument_to_usd",
+        "currency_fx_rate_portfolio_to_usd",
+    ]

wbportfolio/admin/custodians.py

@@ -0,0 +1,9 @@
+from django.contrib import admin
+from django_better_admin_arrayfield.admin.mixins import DynamicArrayMixin
+from wbportfolio.models import Custodian
+
+
+@admin.register(Custodian)
+class CustodianModelAdmin(admin.ModelAdmin, DynamicArrayMixin):
+    search_fields = ("name", "mapping")
+    list_display = ("name", "mapping", "company")

wbportfolio/admin/portfolio.py

@@ -0,0 +1,127 @@
+from django.contrib import admin
+from wbportfolio.models import (
+    DailyPortfolioCashFlow,
+    InstrumentPortfolioThroughModel,
+    Portfolio,
+    PortfolioBankAccountThroughModel,
+    PortfolioCashTarget,
+    PortfolioPortfolioThroughModel,
+    PortfolioSwingPricing,
+)
+
+from .portfolio_relationships import (
+    PortfolioInstrumentPreferredClassificationThroughInlineModelAdmin,
+)
+
+
+@admin.register(PortfolioBankAccountThroughModel)
+class PortfolioBankAccountThroughModelModelAdmin(admin.ModelAdmin):
+    autocomplete_fields = ["bank_account", "portfolio"]
+    list_display = ["bank_account", "portfolio", "portfolio_bank_account_type"]
+
+
+class InstrumentPortfolioThroughModelAdmin(admin.TabularInline):
+    model = InstrumentPortfolioThroughModel
+    fk_name = "portfolio"
+    raw_id_fields = ["portfolio", "instrument"]
+
+
+class PortfolioPortfolioThroughModelInlineAdmin(admin.TabularInline):
+    model = PortfolioPortfolioThroughModel
+    fk_name = "portfolio"
+    fields = ["dependency_portfolio", "type"]
+    autocomplete_fields = ["portfolio", "dependency_portfolio"]
+
+
+@admin.register(PortfolioPortfolioThroughModel)
+class PortfolioPortfolioThroughModelModelAdmin(admin.ModelAdmin):
+    list_display = ["portfolio", "dependency_portfolio", "type"]
+
+
+class PortfolioBankAccountThroughModelAdmin(admin.TabularInline):
+    model = PortfolioBankAccountThroughModel
+    fields = ["bank_account", "portfolio_bank_account_type"]
+
+
+@admin.register(Portfolio)
+class PortfolioModelAdmin(admin.ModelAdmin):
+    search_fields = ("name",)
+
+    fieldsets = (
+        (
+            "Main Information",
+            {
+                "fields": (
+                    ("name", "portfolio_synchronization", "last_synchronization"),
+                    ("currency", "hedged_currency"),
+                    ("invested_timespan", "is_manageable", "is_active", "is_tracked", "only_weighting"),
+                )
+            },
+        ),
+    )
+    readonly_fields = ["last_synchronization"]
+    list_display = (
+        "name",
+        "currency",
+        "hedged_currency",
+        "portfolio_synchronization",
+        "is_manageable",
+        "is_active",
+        "is_tracked",
+    )
+    inlines = [
+        PortfolioBankAccountThroughModelAdmin,
+        InstrumentPortfolioThroughModelAdmin,
+        PortfolioInstrumentPreferredClassificationThroughInlineModelAdmin,
+        PortfolioPortfolioThroughModelInlineAdmin,
+    ]
+    raw_id_fields = [
+        "portfolio_synchronization",
+        "depends_on",
+        "preferred_instrument_classifications",
+        "currency",
+        "hedged_currency",
+    ]
+    autocomplete_fields = ["currency", "hedged_currency", "portfolio_synchronization"]
+
+    def get_queryset(self, request):
+        return Portfolio.all_objects.all()
+
+    def update_preferred_classification_per_instrument(self, request, queryset):
+        for portfolio in queryset.all():
+            portfolio.update_preferred_classification_per_instrument()
+
+    actions = [update_preferred_classification_per_instrument]
+
+
+@admin.register(DailyPortfolioCashFlow)
+class DailyPortfolioCashFlowModelAdmin(admin.ModelAdmin):
+    autocomplete_fields = ["portfolio"]
+    raw_id_fields = ["import_source"]
+    list_display = [
+        "portfolio",
+        "value_date",
+    ]
+    readonly_fields = [
+        "estimated_total_assets",
+        "true_cash",
+        "true_cash_pct",
+        "cash_pct",
+        "target_cash",
+        "excess_cash",
+        "min_target_cash_pct",
+        "target_cash_pct",
+        "max_target_cash_pct",
+        "proposed_rebalancing",
+        "rebalancing",
+    ]
+
+
+@admin.register(PortfolioCashTarget)
+class PortfolioCashTargetModelAdmin(admin.ModelAdmin):
+    autocomplete_fields = ["portfolio"]
+
+
+@admin.register(PortfolioSwingPricing)
+class PortfolioSwingPricingModelAdmin(admin.ModelAdmin):
+    autocomplete_fields = ["portfolio"]

wbportfolio/admin/portfolio_relationships.py

@@ -0,0 +1,22 @@
+from django.contrib import admin
+from wbportfolio.models import InstrumentPortfolioThroughModel
+from wbportfolio.models.portfolio_relationship import (
+    PortfolioInstrumentPreferredClassificationThroughModel,
+)
+
+
+class PortfolioInstrumentPreferredClassificationThroughInlineModelAdmin(admin.TabularInline):
+    model = PortfolioInstrumentPreferredClassificationThroughModel
+    fk_name = "portfolio"
+    raw_id_fields = [
+        "portfolio",
+        "instrument",
+        "classification",
+        "classification_group",
+    ]
+
+
+class InstrumentPortfolioThroughModelAdmin(admin.TabularInline):
+    model = InstrumentPortfolioThroughModel
+    fk_name = "instrument"
+    autocomplete_fields = ["portfolio"]

wbportfolio/admin/product_groups.py

@@ -0,0 +1,42 @@
+from django.contrib import admin
+from wbfdm.admin.instruments import InstrumentModelAdmin
+from wbportfolio.models import ProductGroup, ProductGroupRepresentant
+
+from .portfolio_relationships import InstrumentPortfolioThroughModelAdmin
+
+
+@admin.register(ProductGroup)
+class ProductGroupAdmin(InstrumentModelAdmin):
+    search_fields = ("name", "currency")
+
+    autocomplete_fields = [
+        "management_company",
+        "depositary",
+        "transfer_agent",
+        "administrator",
+        "investment_manager",
+        "auditor",
+        "paying_agent",
+        "currency",
+    ] + InstrumentModelAdmin.autocomplete_fields
+
+    fieldsets = (
+        ("Instrument Information", InstrumentModelAdmin.fieldsets[0][1]),
+        (
+            "Group Information",
+            {
+                "fields": (
+                    ("type", "category", "umbrella"),
+                    ("management_company", "depositary", "transfer_agent", "administrator"),
+                    ("investment_manager", "auditor", "paying_agent"),
+                )
+            },
+        ),
+    )
+
+    inlines = [InstrumentPortfolioThroughModelAdmin]
+
+
+@admin.register(ProductGroupRepresentant)
+class ProductGroupRepresentantModelAdmin(admin.ModelAdmin):
+    autocomplete_fields = ["representant"]

wbportfolio/admin/products.py

@@ -0,0 +1,80 @@
+from django.contrib import admin
+from wbfdm.admin import InstrumentModelAdmin
+from wbportfolio.models import FeeProductPercentage, Product
+
+from .roles import PortfolioRoleInline
+
+
+class FeeProductPercentagTabularInline(admin.TabularInline):
+    model = FeeProductPercentage
+    fk_name = "product"
+    fields = [
+        "type",
+        "vat_deduction",
+        "percent",
+        "timespan",
+    ]
+
+
+@admin.register(Product)
+class ProductAdmin(InstrumentModelAdmin):
+    search_fields = ("name", "isin", "ticker")
+    list_display = ("name", "ticker", "isin", "bank", "primary_benchmark", "_is_invested")
+    autocomplete_fields = [
+        "country",
+        "jurisdiction",
+        "white_label_customers",
+        "bank",
+        "default_account",
+        "parent",
+        *InstrumentModelAdmin.autocomplete_fields,
+    ]
+    fieldsets = (
+        ("Instrument Information", InstrumentModelAdmin.fieldsets[0][1]),
+        (
+            "Product Information",
+            {
+                "fields": (
+                    ("share_price", "initial_high_water_mark", "bank"),
+                    ("termsheet", "fee_calculation"),
+                    (
+                        "white_label_customers",
+                        "default_account",
+                        "bank_account",
+                    ),
+                )
+            },
+        ),
+        (
+            "Factsheet",
+            {
+                "fields": (
+                    ("type_of_return", "asset_class", "legal_structure"),
+                    ("investment_index", "liquidity", "risk_scale"),
+                    (
+                        "jurisdiction",
+                        "dividend",
+                    ),
+                    ("external_webpage", "minimum_subscription", "cut_off_time"),
+                )
+            },
+        ),
+    )
+
+    inlines = [FeeProductPercentagTabularInline, PortfolioRoleInline, *InstrumentModelAdmin.inlines]
+    raw_id_fields = [
+        "country",
+        "jurisdiction",
+        "white_label_customers",
+        "bank",
+        "default_account",
+        "parent",
+        *InstrumentModelAdmin.raw_id_fields,
+    ]
+
+    def update_preferred_classification_per_instrument(self, request, queryset):
+        for product in queryset.all():
+            if portfolio := product.portfolio:
+                portfolio.update_preferred_classification_per_instrument()
+
+    actions = [update_preferred_classification_per_instrument]

wbportfolio/admin/reconciliations.py

@@ -0,0 +1,14 @@
+from django.contrib import admin
+from wbportfolio.models import AccountReconciliation, AccountReconciliationLine
+
+
+class AccountReconciliationLineInline(admin.TabularInline):
+    model = AccountReconciliationLine
+    fields = ("product", "price", "price_date", "shares", "shares_external")
+    extra = 0
+
+
+@admin.register(AccountReconciliation)
+class AccountReconciliationAdmin(admin.ModelAdmin):
+    list_display = ("reconciliation_date", "account", "creator")
+    inlines = [AccountReconciliationLineInline]

wbportfolio/admin/registers.py

@@ -0,0 +1,17 @@
+from django.contrib import admin
+from wbportfolio.models import Register
+
+
+@admin.register(Register)
+class RegisterModelAdmin(admin.ModelAdmin):
+    search_fields = [
+        "register_reference",
+        "register_name_1",
+        "register_name_2",
+        "custodian_reference",
+        "custodian_name_1",
+        "custodian_name_2",
+        "outlet_reference",
+        "outlet_name",
+    ]
+    list_display = ("register_reference", "global_register_reference", "register_name_1", "register_name_2")

wbportfolio/admin/roles.py

@@ -0,0 +1,19 @@
+from django.contrib import admin
+from wbportfolio.models import PortfolioRole
+
+
+class PortfolioRoleInline(admin.TabularInline):
+    model = PortfolioRole
+    extra = 0
+
+    autocomplete_fields = ["instrument", "person"]
+
+
+@admin.register(PortfolioRole)
+class PortfolioRoleAdmin(admin.ModelAdmin):
+    list_display = ["role_type", "instrument", "person", "start", "end"]
+
+    autocomplete_fields = [
+        "instrument",
+        "person",
+    ]

wbportfolio/admin/synchronization/__init__.py

@@ -0,0 +1,2 @@
+from .portfolio_synchronization import PortfolioSynchronizationModelAdmin
+from .price_computation import PriceComputationModelAdmin

wbportfolio/admin/synchronization/admin.py

@@ -0,0 +1,114 @@
+from django_celery_beat.admin import (
+    PeriodicTaskAdmin,
+    PeriodicTaskForm,
+    _,
+    loads,
+    messages,
+    pluralize,
+)
+
+
+class SynchronizationTaskForm(PeriodicTaskForm):
+    def clean(self):
+        return self.cleaned_data
+
+
+class SynchronizationAdmin(PeriodicTaskAdmin):
+    form = SynchronizationTaskForm
+    search_fields = ("name",)
+    regtask = None
+    readonly_fields = (
+        "last_run_at",
+        # 'regtask',
+        "task",
+        "args",
+        # 'kwargs',
+        "expires",
+        "expire_seconds",
+        "queue",
+        "exchange",
+        "routing_key",
+        "priority",
+        "headers",
+    )
+    fieldsets = (
+        (
+            None,
+            {
+                "fields": (
+                    "name",
+                    "task",
+                    "enabled",
+                    "description",
+                ),
+                "classes": ("extrapretty", "wide"),
+            },
+        ),
+        (
+            "Schedule",
+            {
+                "fields": ("crontab", "start_time", "last_run_at", "one_off"),
+                "classes": ("extrapretty", "wide"),
+            },
+        ),
+        (
+            "Arguments",
+            {
+                "fields": ("args", "kwargs"),
+                "classes": ("extrapretty", "wide", "collapse", "in"),
+            },
+        ),
+        (
+            "Execution Options",
+            {
+                "fields": ("expires", "expire_seconds", "queue", "exchange", "routing_key", "priority", "headers"),
+                "classes": ("extrapretty", "wide", "collapse", "in"),
+            },
+        ),
+    )
+
+    def run_tasks(self, request, queryset):
+        def _load_kwargs(task):
+            kwargs = loads(task.kwargs)
+            kwargs["override_execution_datetime_validity"] = True
+            return kwargs
+
+        self.celery_app.loader.import_default_modules()
+
+        tasks = [
+            (self.celery_app.tasks.get(task.task), loads(task.args), _load_kwargs(task), task.queue)
+            for task in queryset
+        ]
+
+        if any(t[0] is None for t in tasks):
+            for i, t in enumerate(tasks):
+                if t[0] is None:
+                    break
+
+            # variable "i" will be set because list "tasks" is not empty
+            not_found_task_name = queryset[i].task
+
+            self.message_user(
+                request,
+                _('task "{0}" not found'.format(not_found_task_name)),
+                level=messages.ERROR,
+            )
+            return
+
+        task_ids = [
+            task.apply_async(args=args, kwargs=kwargs, queue=queue)
+            if queue and len(queue)
+            else task.apply_async(args=args, kwargs=kwargs)
+            for task, args, kwargs, queue in tasks
+        ]
+        tasks_run = len(task_ids)
+        self.message_user(
+            request,
+            _("{0} task{1} {2} successfully run").format(
+                tasks_run,
+                pluralize(tasks_run),
+                pluralize(tasks_run, _("was,were")),
+            ),
+        )
+
+    run_tasks.short_description = _("Run selected tasks")

wbportfolio/admin/synchronization/portfolio_synchronization.py

@@ -0,0 +1,18 @@
+from django.contrib import admin
+from wbportfolio.models import PortfolioSynchronization
+
+from .admin import SynchronizationAdmin
+
+
+@admin.register(PortfolioSynchronization)
+class PortfolioSynchronizationModelAdmin(SynchronizationAdmin):
+    fieldsets = (
+        *SynchronizationAdmin.fieldsets,
+        (
+            "Synchronization",
+            {
+                "fields": ("import_path", "dependent_task", "is_automatic_validation"),
+                "classes": ("extrapretty", "wide"),
+            },
+        ),
+    )

wbportfolio/admin/synchronization/price_computation.py

@@ -0,0 +1,21 @@
+from django.contrib import admin
+from wbportfolio.models import PriceComputation
+
+from .admin import SynchronizationAdmin
+
+
+@admin.register(PriceComputation)
+class PriceComputationModelAdmin(SynchronizationAdmin):
+    fieldsets = (
+        *SynchronizationAdmin.fieldsets,
+        (
+            "Synchronization",
+            {
+                "fields": (
+                    "import_path",
+                    "dependent_task",
+                ),
+                "classes": ("extrapretty", "wide"),
+            },
+        ),
+    )

wbportfolio/admin/transactions/__init__.py

@@ -0,0 +1,5 @@
+from .transactions import TransactionModelAdmin  # isort:skip
+from .claim import ClaimModelAdmin
+from .dividends import DividendAdmin
+from .fees import FeesAdmin
+from .trades import TradeAdmin

wbportfolio/admin/transactions/claim.py

@@ -0,0 +1,16 @@
+from django.contrib import admin
+from wbportfolio.models.transactions.claim import Claim
+
+
+class ClaimTabularInline(admin.TabularInline):
+    extra = 0
+    model = Claim
+    list_display = ["reference_id", "product", "shares", "nominal_value", "claimant"]
+    autocomplete_fields = ["account", "product", "claimant"]
+
+
+@admin.register(Claim)
+class ClaimModelAdmin(admin.ModelAdmin):
+    list_display = ["date", "reference_id", "product", "account", "shares", "nominal_value"]
+    autocomplete_fields = ["account", "product", "claimant"]
+    raw_id_fields = ["trade", "account", "product", "claimant", "creator"]

wbportfolio/admin/transactions/dividends.py

@@ -0,0 +1,14 @@
+from django.contrib import admin
+from wbportfolio.admin.transactions import TransactionModelAdmin
+from wbportfolio.models import DividendTransaction
+
+
+@admin.register(DividendTransaction)
+class DividendAdmin(TransactionModelAdmin):
+    fieldsets = (
+        ("Transactions Information", TransactionModelAdmin.fieldsets[0][1]),
+        (
+            "Dividend Information",
+            {"fields": (("retrocession",),)},
+        ),
+    )

wbportfolio/admin/transactions/fees.py

@@ -0,0 +1,35 @@
+from django.contrib import admin
+from django.db.models import Prefetch
+from wbportfolio.admin.transactions import TransactionModelAdmin
+from wbportfolio.models import Fees, Portfolio
+from wbportfolio.models.transactions.fees import FeeCalculation
+
+
+@admin.register(Fees)
+class FeesAdmin(TransactionModelAdmin):
+    list_filter = [*TransactionModelAdmin.list_filter, "linked_product"]
+    list_display = ["transaction_subtype", *TransactionModelAdmin.list_display[1:], "calculated"]
+    fieldsets = (
+        ("Transaction Information", TransactionModelAdmin.fieldsets[0][1]),
+        ("Fees Information", {"fields": (("transaction_subtype", "calculated", "linked_product"),)}),
+    )
+    autocomplete_fields = [*TransactionModelAdmin.autocomplete_fields, "linked_product"]
+
+    def get_queryset(self, request):
+        return (
+            super()
+            .get_queryset(request)
+            .prefetch_related(Prefetch("portfolio", queryset=Portfolio.objects.all().only("id", "name")))
+        )
+
+    def calculate(self, request, queryset):
+        for fees in queryset:
+            fees.calculate_as_task.delay(fees)
+
+    calculate.short_description = "Recalculate selected Fees"
+    actions = [calculate]
+
+
+@admin.register(FeeCalculation)
+class FeeCalculationModelAdmin(admin.ModelAdmin):
+    search_fields = ("name",)