Analyzera

What one instrument is and how it has done, in aggregate. An equity, ETF, fund or bond, by id from ``find_assets``. Returns return, annualised return, volatility and maximum drawdown over the standard windows, the six factor tilts against the universe and a few company fundamentals, all in the client's currency including the exchange rate. No prices or raw data. A section that does not apply (factor tilts for a fund, a 3Y window for a recent listing) comes back absent with the reason; absent means unknown, not zero. It describes the instrument and makes no recommendation. Several instruments at once, such as a screen's companies, are one ``describe_assets`` call. The card charts the return since the first price, against a comparison the client picks. The points stay out of the result unless ``series_in_context`` asks for them.

describe_asset

GICS codes for the screener's ``industries``: search by name ('banks'), or browse below a ``parent`` code. Neither lists the sectors and their groups.

find_gics

Resolve instrument names, tickers or identifiers to the asset ids the builders take. Each entry is one instrument, given by any codes known for it: ``name``, ``ticker`` in any common notation ('SHB B SS Equity', 'SHB-B.ST', 'STO:SHB-B', 'BRK.B'), ``isin``, ``cusip``, ``sedol``, ``figi``, or free text in ``query``, optionally with the exchange or currency of the line meant. Entries may carry different codes. Each code is resolved on its own and the answers are checked against each other. Up to 50 entries per call. Asset ids are dense, so an unverified id is usually a different, real instrument. Coverage differs by code. Tickers and names reach every traded line, and ISINs about three in four. FIGIs are held for about one in five US listings and most ASX listings, and almost none elsewhere. CUSIPs are held for about one in ten US listings, and are also matched through their ISIN. SEDOLs are matched only through UK and Irish ISINs. A FIGI, CUSIP or SEDOL on its own therefore often finds nothing; with a ticker or ISIN in the same entry, that entry still resolves. Each result has a status. 'exact': the query names one traded line. 'resolved': one company or fund with several lines, of which one was chosen, in order: a line in the client's currency that trades, an ordinary share over a receipt, the primary listing, the most traded line; 'why' names the step. 'ambiguous': different instruments match about equally well, the first being the most likely. 'not found'. Alternatives are the same company's other lines (exchange, currency, share class, receipt) and other instruments that also match, each with its id. Only lines priced within the last two weeks match, so every id can be built with. ``ensure_price=false`` also matches delisted lines, marked 'no recent price', to look up a company that no longer trades; a priced line is still preferred within a company. Names match whole words and word starts, not descriptions ("Novo" matches, "the Danish diabetes one" does not). Strategies and accounts are found with ``find_portfolios``.

find_assets

The six 0-10 tilts and their coverage. Called by the widget. The scenario pair measures the account WITH that addition; see ``preview_scenario``. ``simulations`` applies saved simulations instead.

get_portfolio_fundamentals

Called by the screener card, not the model: every GICS sector, industry group, industry and sub-industry with classified stocks, for its industry picker.

get_gics_tree

Holdings and the five breakdowns. Called by the widget, not by the model. ``lookthrough`` resolves funds into what THEY hold — a three-line pension becomes a thousand companies — and applies to the breakdowns as well as the lines, so the two always describe the same view. The scenario pair renders this tab for an account that also held ``scenario_amount`` of ``scenario_strategy_id``. Nothing is written; see ``preview_scenario``. ``simulations`` applies saved simulations instead.

get_portfolio_weights

How the figures another tool returns are calculated: the model, its main assumptions and why. ``tool_name`` is the tool whose figures are in question, such as ``describe_portfolio_risk`` for volatility and the risk level or ``describe_portfolio_outlook`` for expected return. The result is the same for every caller and portfolio: topics in reading order, each with a summary and sections. It describes how a model is built, not calibrated values, and reads no account data.

describe_methodology

How to build a portfolio or strategy with Analyzera, and which tools each way uses. For a portfolio on a theme or sector (AI, cybersecurity, defence, energy) or on any other screen. 'build_portfolio': a ready-made catalogue strategy (``find_portfolios``), the strategy builder (``build_equity_strategy``, ``build_allocation_strategy``), or the stock screener and weightings (``screen_equities``, ``solve_equity_weights``). 'working_rules': saving, backtests, ids and how results are reported. The same guidance as the server instructions, for hosts that do not show them. Reference text; reads no account data.

describe_build_options

Called by the instrument card's Risk tab, not the model: the risk model's volatility, bad month, 0-10 score and risk by source for one instrument.

get_asset_risk

Make one of the client's accounts TRACK a strategy, for describe_drift and drift alerts; ``strategy_id`` 0 unlinks it. Tracking only — nothing is traded. Account ids come from list_portfolios' 'accounts' group.

assign_strategy

Every alert this client has set.

get_alerts

The target weights pre-rebalance notices have sent for a strategy, latest first, each labelled with its rebalance date. ``portfolio_id`` is a strategy, or an account, which reads the strategy it tracks (list_portfolios shows which). Weights only; none is readable before its 12:00 Stockholm release.

list_rebalance_targets

The saved simulations on an account and the accounts under it. A simulation is a set of trades on one account's holdings, saved in the Analyzera web app or with ``save_simulation``. Only one with status 'executed' has results; pass it with its account to ``open_dashboard`` to compare with and without it. Strategies have no simulations.

list_simulations

Every live share link this client has made, newest first, with what each shows.

list_shares

List everything the client can see, as rows. Three groups: 'accounts' (money the client holds), 'mine' (strategies this client built, here or in the web app) and 'analyzera' (the provider catalogue, narrowed by the client's currency and jurisdiction). Accounts and own strategies come as rows with their ids; the catalogue comes as counts per asset class, and ``find_portfolios`` searches it. A shortened catalogue carries ``shelf_note`` with the reason. An account held at another institution carries ``held_elsewhere``, with the ``source`` and ``account_ref`` that ``sync_external_account`` updates it by. Draws nothing. ``open_dashboard`` shows the same list in the card.

list_portfolios

How far an account has drifted from the strategy it tracks: active share and the largest gaps. Link a strategy first with assign_strategy.

describe_drift

Open the dashboard card: the client's accounts, strategies and the catalogue, with tabs. The one tool that draws the dashboard. The ``describe_*``, ``list_*`` and ``find_*`` reads return figures and rows without it. ``portfolio_id`` opens on that strategy or account; omitted, the card opens on the list. ``tab`` opens on that tab ('returns', 'weights', 'risk', 'fundamentals' or 'outlook'); omitted, 'returns' ('weights' before a backtest). ``compare_id`` puts another strategy, account or market benchmark beside ``portfolio_id`` on every tab: use it whenever the client asks to compare, put side by side, or measure one against another. Returns figures cover ``portfolio_id``'s history, and the comparison's are given only for periods its own record fully covers. ``simulations`` are saved simulations from ``list_simulations`` or ``save_simulation``, selected in the card's comparison instead, so every tab except returns shows ``portfolio_id`` beside itself with them applied. Each is on ``portfolio_id`` or an account under it, such as everything the client holds, and an account takes at most one. Returns a digest of the opened tab; with ``compare_id``, both sides' holdings, risk, outlook and track records; with simulations, the tab measured with them applied. On a strategy whose backtest ``get_backtest_status`` reports done, tab 'returns' shows the finished record.

open_dashboard

The long-run expected return and its build-up. Called by the widget. Loaded when the Outlook tab is opened rather than with the list: a projection prices every holding through the risk model and the fundamentals store, which is seconds of work — paying it for rows nobody opened would make the list the slow call. The scenario pair projects the account WITH that addition; see ``preview_scenario``. ``simulations`` applies saved simulations instead.

get_portfolio_outlook

What each holding and group added to the return over a window. Called by the widget. On a click rather than with the tab: it reads every holding's daily weight and return over the window. The dates default to the last year. ``whole_window``, for the comparison side, returns nothing unless its record covers the whole window. ``include_asset_ids``, also for the comparison side, lists those holdings even outside the largest rows, so each of the other side's holdings has a figure.

get_portfolio_performance_contribution

What a portfolio holds, one level down. Called by the widget's tree. On demand, when a row is expanded — reading every account's holdings up front would be seconds of work for rows nobody has opened, and the list is the call that has to be quick.

get_portfolio_children

Measure an account as it is and with a strategy added, without writing anything. Answers which way the client's position would move if they bought a strategy, and by how much. The account is measured twice through the Risk tab's own pane. Pass ``strategy_id`` + ``amount``, or ``changes`` for several signed changes at once (a switch is a negative amount on an account plus an equal positive one; an account cannot be reduced below what it holds). A change with ``asset_id`` is one instrument: "sell 20,000 of Volvo in the ISK and buy Investor" is ``{id: ISK, asset_id: Volvo, amount: -20000}`` plus ``{asset_id: Investor, amount: 20000}`` with ``account_id: ISK``; for a switch between instruments that names one account, that account is the default. Otherwise ``account_id`` defaults to everything the client holds, or everything one client holds with ``person_id``. An empty account is valid: the before side is empty. Nothing is written: no account, holding or node is created. There is no track record for a scenario and the returns tab is unavailable for it. The result is a measurement, not a suitability judgement; the client's own limits are not read.

preview_scenario

What "X up front and Y a month for Z years" grows to, and how much of it is growth. Handles the plan arithmetic that a lump-sum calculation gets wrong: only the opening amount is invested for the whole span. The house conventions for timing and compounding are fixed here. Returns the central figure at the supplied rate and ``total_contributed``. No range is returned: the outlook's band is stated at the model's horizon and does not transfer to a plan's shorter dispersion horizon. ``dispersion_horizon_years`` under about ten means the figure is arithmetic at an assumed rate rather than an expectation. No client profile is read. ``per_annum_by_year`` replaces ``per_annum`` with one rate per year, such as the glide path rates ``describe_portfolio_outlook`` returns for a strategy with a target date; ``per_annum`` in the result is then the constant rate that ends this plan at the same value.

project_savings_plan

The arguments that would rebuild a strategy: its screen, tilts, caps and items. Call it before editing a strategy. The builders replace a definition rather than patch it, so an edit restates every argument; this is where they come from, including for strategies built in the web app. It returns what a strategy is made of, not what it holds (that is the weights pane). ``not_expressible`` lists stored settings the builders have no argument for; a strategy with any cannot be rewritten here without losing them. Catalogue strategies can be read too; only rewriting requires ownership.

get_strategy_definition

Called by the screener card, not the model: records its latest re-screen.

set_card_screen

Rename one of the client's own portfolios. Called by the widget, not the model. Works on an account or on a strategy they built; the two are stored differently and :func:`browser.rename_portfolio` knows which is which. A catalogue strategy is shared and is refused — renaming it would rename it for everyone it is offered to. Returns a confirmation; the widget re-reads the list with ``get_portfolio_list``.

rename_portfolio

Turn off one share link by its token from ``list_shares``, or every link showing ``portfolio_id``. A revoked link shows that it was turned off.

revoke_share

The highest risk level a stated horizon supports, from Analyzera's published table. For when the client says when they need the money and asks what risk level fits. The result is a ceiling: the client may choose any level at or below it. ``digest`` carries the wording of the result and ``table`` the whole horizon policy. It uses the same horizon-to-loss chain as the advice path. ``horizon_years`` is the horizon the client stated; nothing is read from their profile or records. Band edges close at the top, so five years falls in the 3-5 band. ``max_monthly_loss`` (0.10 = 10%) can only lower the ceiling; with both, the lower wins. This is a calculator, not a suitability assessment: it does not consider the client's appetite, capacity or experience, and records nothing.

get_risk_ceiling_for_horizon

Volatility, bad month, risk level, diversification and risk contributions. Called by the widget. The scenario pair measures the account WITH that addition; see ``preview_scenario``. ``simulations`` applies saved simulations instead.

get_portfolio_risk

Start a backtest of a strategy the client built, and return its key at once. Writes: the backtest publishes the strategy's holdings and transaction ledger. Takes a minute or two; returns a ``key`` and an ETA, and ``get_backtest_status(key)`` (free) follows it. Each run spends the backtest allowance, except that the same definition on the same day reuses the earlier run. The window is the history the strategy was built with, 5 years by default; ``history_years`` first moves the strategy's start (back to 2006 at most) and backtests over the new window, leaving the definition as it is. For a strategy already backtested, ``describe_portfolio_series`` reads the result. A strategy on a fixed list (``asset_ids``) holds that list through its whole history, so a list picked today, from a screen or from today's holdings, has hindsight bias in its backtest; a screened strategy picks its names as of each date.

run_strategy_backtest

Save changes to one account as a simulation that the dashboard can compare against. Takes the changes ``preview_scenario`` takes, on one account: ``strategy_id`` + ``amount``, or ``changes``. Sales and resizes must be on ``account_id``, and purchases land in it. The saved holdings are the account's own plus the changes as of the latest price date, with no optimisation, so they measure what the preview measured. Returns the simulation id and the same before/after measurement as ``preview_scenario``. ``open_dashboard`` takes it in ``simulations``, on the account or on any node above it, alongside other accounts' simulations. It also shows in the web app. A name already on the account is refused; ``delete_simulation`` removes simulations.

save_simulation

The saved simulations on an account, for the comparison picker. Called by the widget.

get_portfolio_simulations

Screen stocks by hand: list the companies that pass a screen, unweighted and unsaved. For exploring stocks before anything is saved. The ways to build a portfolio, including when the screener is one of them, are in ``describe_build_options``; a ready-made strategy on a theme or sector is found with ``find_portfolios``. Each company comes with its country, sector and, under a factor tilt, the score it was ranked on (its fit to the tilts) and each factor on its own axis. Factors are axes, not styles: valuation high is expensive and low is cheap ('value'); size low is small caps ('size'); for quality pass the one factor 'quality', which splits its share between its parts. ``maximum_number_of_assets`` keeps the largest by market cap; a size tilt scores every large cap the same. A company with several share classes is listed once, by its most traded line, unless ``asset_ids`` names the classes. ``request`` echoes the arguments, which ``solve_equity_weights`` and ``build_equity_strategy`` take unchanged; a strategy built from them re-runs the screen at every rebalance. The listed ids are this date's selection only. Where a card is drawn it lists every company that passed, so one screen is one call. ``sizes`` defaults to large and mid; a theme usually needs small caps too, and micro caps where that finds nothing. An empty theme screen says whether the region has no members at any size. The funnel says how many names each stage kept. ``date`` screens as of a past date; data before 2022 is sparse enough to reorder a universe, and nothing can be screened before 2005, or with micro caps before 2021-01-29.

screen_equities

Find strategies or accounts by what they are, without the whole list. The lookup counterpart to ``list_portfolios``: narrows the same rows and draws nothing. Suited to assembling an allocation from existing pieces ("the European bond one", "something I built at around risk 5"). ``query`` matches all of its words anywhere in a row, on the name and on the row's facts (asset class, region, style, wrapper, owner), so "swedish equity" finds "Sweden Large Cap". ``group`` is 'mine' (strategies this client built), 'analyzera' (provider catalogue) or 'accounts' (money the client holds; accounts are not usable as build components). A risk bound keeps only rows with a risk target, which means blends. Returned strategy ids are ones this client may use as sleeves in ``build_allocation_strategy``. A result flagged as a partial match did not match the whole query. The catalogue holds factor styles (value, quality, momentum and others) side by side and ranks none: Analyzera does not recommend either direction of any factor tilt. A case for one is yours, from your own sources; the client chooses.

find_portfolios

Send the Analyzera team a bug report or feature request, by email. The text is sent as written, with the sender recorded automatically. Returns a reference for the report.

send_feedback

Email alerts, as one daily digest, on a strategy ('rebalance', 'risk') or an account ('risk', 'drift' from the strategy it tracks). Replaces the kinds set on that subject; [] turns them off. ``threshold``: a risk-level step (default 0.5) or a drift share (default 0.05). 'pre_rebalance' on a strategy emails its next target weights from 12:00 Stockholm on the weekday before it trades. A linked account gets it without asking; leaving it out of ``kinds`` turns it off.

set_alerts

Called by the screener card, not the model: a public link to this screen's list. Takes the ``request`` the screen echoed. The screen is run again on the server and the list is kept as it was; the link never changes afterwards.

share_screen

A public link to one card view, for WhatsApp, SMS, mail or Slack. ``kind`` picks what it shows: - ``portfolio``: one dashboard tab (default 'returns') of strategy or account ``portfolio_id``. ``compare_id`` draws a market benchmark or another strategy beside it; ``lookthrough`` shows holdings with funds resolved; ``all_tabs``, only when asked, shares every tab. - ``comparison``: ``portfolio_id`` with ``against_id`` beside it, as ``open_dashboard`` with ``compare_id`` draws them. - ``instruments``: one of ``asset_ids`` opens its page on ``tab`` (default 'performance'); several open the table ``describe_assets`` draws. The link opens the card fixed on that view, read-only, with live figures in weights and percentages only, never values, amounts or units. Nothing is copied into the viewer's account and they cannot change it. The same view reuses its link; ``revoke_share`` turns it off.

share_view

Start a backtest and return immediately. Called by the widget, not the model. The widget then polls ``get_portfolio_series``, which reports the run as in progress until the curve is there. Today's run comes back as itself. **This writes**: the simulation that produces the series is the one that writes the portfolio's ledger and transaction history.

start_strategy_backtest

The browser's accounts, strategies and catalogue, and where to open. Called by the widget. The tools that open the browser send only where to open, so the lists never enter the conversation on any host.

get_portfolio_list

A strategy's long-run expected return and what builds it, as figures with no widget. For reasoning with the number, such as comparing two strategies or checking a savings plan's required return. ``open_dashboard(portfolio_id, tab='outlook')`` shows the same figures with their build-up and disclosures. The figure is a long-run average from a factor model: per annum, nominal (it includes inflation) and BEFORE FEES: no fund charge, platform, custody or advice fee is taken off it. It is not a forecast for any one year. The ranges returned are part of the figure. Below the horizon floor stated in the result the model has essentially no predictive power. ``coverage`` below 100% means part of the strategy is not in the figure. For a strategy with a glide path, ``glide`` adds the expected return year by year along the path, over the whole path, and the yearly rates ``project_savings_plan`` takes as ``per_annum_by_year``.

describe_portfolio_outlook