Rekt pps? problem? => piker.accounting

config/conf.toml

@@ -0,0 +1,4 @@
+[network]
+tsdb.backend = 'marketstore'
+tsdb.host = 'localhost'
+tsdb.grpc_port = 5995

dockering/ib/docker-compose.yml

@@ -2,8 +2,21 @@
 # https://github.com/waytrade/ib-gateway-docker/blob/master/docker-compose.yml
 version: "3.5"
 
+
 services:
+
   ib_gw_paper:
+
+    # apparently java is a mega cukc:
+    # https://stackoverflow.com/a/56895801
+    # https://bugs.openjdk.org/browse/JDK-8150460
+    ulimits:
+      # nproc: 65535
+      nproc: 6000
+      nofile:
+        soft: 2000
+        hard: 3000
+
     # other image tags available:
     # https://github.com/waytrade/ib-gateway-docker#supported-tags
     # image: waytrade/ib-gateway:981.3j

piker/_cacheables.py

@@ -1,5 +1,5 @@
 # piker: trading gear for hackers
-# Copyright (C) Tyler Goodlet (in stewardship for piker0)
+# Copyright (C) Tyler Goodlet (in stewardship for pikers)
 
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as published by
@@ -14,14 +14,20 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-"""
+'''
 Cacheing apis and toolz.
 
-"""
+'''
 
 from collections import OrderedDict
 from contextlib import (
-    asynccontextmanager,
+    asynccontextmanager as acm,
+)
+from typing import (
+    Awaitable,
+    Callable,
+    ParamSpec,
+    TypeVar,
 )
 
 from tractor.trionics import maybe_open_context
@@ -32,19 +38,54 @@
 
 log = get_logger(__name__)
 
-
-def async_lifo_cache(maxsize=128):
-    """Async ``cache`` with a LIFO policy.
+T = TypeVar("T")
+P = ParamSpec("P")
+
+
+# TODO: move this to `tractor.trionics`..
+# - egs. to replicate for tests: https://github.com/aio-libs/async-lru#usage
+# - their suite as well:
+#   https://github.com/aio-libs/async-lru/tree/master/tests
+# - asked trio_util about it too:
+#   https://github.com/groove-x/trio-util/issues/21
+def async_lifo_cache(
+    maxsize=128,
+
+    # NOTE: typing style was learned from:
+    # https://stackoverflow.com/a/71132186
+) -> Callable[
+    Callable[P, Awaitable[T]],
+    Callable[
+        Callable[P, Awaitable[T]],
+        Callable[P, Awaitable[T]],
+    ],
+]:
+    '''
+    Async ``cache`` with a LIFO policy.
 
     Implemented my own since no one else seems to have
     a standard. I'll wait for the smarter people to come
     up with one, but until then...
-    """
+
+    NOTE: when decorating, due to this simple/naive implementation, you
+    MUST call the decorator like,
+
+    .. code:: python
+
+        @async_lifo_cache()
+        async def cache_target():
+
+    '''
     cache = OrderedDict()
 
-    def decorator(fn):
+    def decorator(
+        fn: Callable[P, Awaitable[T]],
+    ) -> Callable[P, Awaitable[T]]:
 
-        async def wrapper(*args):
+        async def decorated(
+            *args: P.args,
+            **kwargs: P.kwargs,
+        ) -> T:
             key = args
             try:
                 return cache[key]
@@ -53,16 +94,20 @@ async def wrapper(*args):
                     # discard last added new entry
                     cache.popitem()
 
-                # do it
-                cache[key] = await fn(*args)
+                # call underlying
+                cache[key] = await fn(
+                    *args,
+                    **kwargs,
+                )
                 return cache[key]
 
-        return wrapper
+        return decorated
 
     return decorator
 
 
-@asynccontextmanager
+# TODO: move this to `.brokers.utils`..
+@acm
 async def open_cached_client(
     brokername: str,
 ) -> 'Client':  # noqa

piker/accounting/__init__.py

@@ -0,0 +1,115 @@
+# piker: trading gear for hackers
+# Copyright (C) Tyler Goodlet (in stewardship for pikers)
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+'''
+"Accounting for degens": count dem numberz that tracks how much you got
+for tendiez.
+
+'''
+from ..log import get_logger
+
+from ._ledger import (
+    iter_by_dt,
+    Transaction,
+    TransactionLedger,
+    open_trade_ledger,
+)
+from ._pos import (
+    load_pps_from_ledger,
+    open_pps,
+    Position,
+    PpTable,
+)
+from ._mktinfo import (
+    Asset,
+    dec_digits,
+    digits_to_dec,
+    MktPair,
+    Symbol,
+    unpack_fqme,
+)
+from ._allocate import (
+    mk_allocator,
+    Allocator,
+)
+
+log = get_logger(__name__)
+
+__all__ = [
+    'Allocator',
+    'Asset',
+    'MktPair',
+    'Position',
+    'PpTable',
+    'Symbol',
+    'Transaction',
+    'TransactionLedger',
+    'dec_digits',
+    'digits_to_dec',
+    'iter_by_dt',
+    'load_pps_from_ledger',
+    'mk_allocator',
+    'open_pps',
+    'open_trade_ledger',
+    'unpack_fqme',
+]
+
+
+def get_likely_pair(
+    src: str,
+    dst: str,
+    bs_mktid: str,
+
+) -> str | None:
+    '''
+    Attempt to get the likely trading pair matching a given destination
+    asset `dst: str`.
+
+    '''
+    try:
+        src_name_start = bs_mktid.rindex(src)
+    except (
+        ValueError,   # substr not found
+    ):
+        # TODO: handle nested positions..(i.e.
+        # positions where the src fiat was used to
+        # buy some other dst which was furhter used
+        # to buy another dst..)
+        # log.warning(
+        #     f'No src fiat {src} found in {bs_mktid}?'
+        # )
+        return
+
+    likely_dst = bs_mktid[:src_name_start]
+    if likely_dst == dst:
+        return bs_mktid
+
+
+if __name__ == '__main__':
+    import sys
+    from pprint import pformat
+
+    args = sys.argv
+    assert len(args) > 1, 'Specifiy account(s) from `brokers.toml`'
+    args = args[1:]
+    for acctid in args:
+        broker, name = acctid.split('.')
+        trans, updated_pps = load_pps_from_ledger(broker, name)
+        print(
+            f'Processing transactions into pps for {broker}:{acctid}\n'
+            f'{pformat(trans)}\n\n'
+            f'{pformat(updated_pps)}'
+        )

piker/clearing/_allocate.py → piker/accounting/_allocate.py

@@ -23,9 +23,9 @@
 
 from bidict import bidict
 
-from ..data._source import Symbol
+from ._pos import Position
+from . import MktPair
 from ..data.types import Struct
-from ..pp import Position
 
 
 _size_units = bidict({
@@ -42,7 +42,7 @@
 
 class Allocator(Struct):
 
-    symbol: Symbol
+    mkt: MktPair
 
     # TODO: if we ever want ot support non-uniform entry-slot-proportion
     # "sizes"
@@ -114,8 +114,8 @@ def next_order_info(
         depending on position / order entry config.
 
         '''
-        sym = self.symbol
-        ld = sym.lot_size_digits
+        mkt: MktPair = self.mkt
+        ld: int = mkt.size_tick_digits
 
         size_unit = self.size_unit
         live_size = live_pp.size
@@ -125,13 +125,13 @@ def next_order_info(
         u_per_slot, currency_per_slot = self.step_sizes()
 
         if size_unit == 'units':
-            slot_size = u_per_slot
-            l_sub_pp = self.units_limit - abs_live_size
+            slot_size: float = u_per_slot
+            l_sub_pp: float = self.units_limit - abs_live_size
 
         elif size_unit == 'currency':
-            live_cost_basis = abs_live_size * live_pp.ppu
-            slot_size = currency_per_slot / price
-            l_sub_pp = (self.currency_limit - live_cost_basis) / price
+            live_cost_basis: float = abs_live_size * live_pp.ppu
+            slot_size: float = currency_per_slot / price
+            l_sub_pp: float = (self.currency_limit - live_cost_basis) / price
 
         else:
             raise ValueError(
@@ -141,8 +141,14 @@ def next_order_info(
         # an entry (adding-to or starting a pp)
         if (
             live_size == 0
-            or (action == 'buy' and live_size > 0)
-            or action == 'sell' and live_size < 0
+            or (
+                action == 'buy'
+                and live_size > 0
+            )
+            or (
+                action == 'sell'
+                and live_size < 0
+            )
         ):
             order_size = min(
                 slot_size,
@@ -178,7 +184,7 @@ def next_order_info(
             order_size = max(slotted_pp, slot_size)
 
             if (
-                abs_live_size < slot_size or
+                abs_live_size < slot_size
 
                 # NOTE: front/back "loading" heurstic:
                 # if the remaining pp is in between 0-1.5x a slot's
@@ -187,14 +193,17 @@ def next_order_info(
                 # **without** going past a net-zero pp. if the pp is
                 # > 1.5x a slot size, then front load: exit a slot's and
                 # expect net-zero to be acquired on the final exit.
-                slot_size < pp_size < round((1.5*slot_size), ndigits=ld) or
-
-                # underlying requires discrete (int) units (eg. stocks)
-                # and thus our slot size (based on our limit) would
-                # exit a fractional unit's worth so, presuming we aren't
-                # supporting a fractional-units-style broker, we need
-                # exit the final unit.
-                ld == 0 and abs_live_size == 1
+                or slot_size < pp_size < round((1.5*slot_size), ndigits=ld)
+                or (
+
+                    # underlying requires discrete (int) units (eg. stocks)
+                    # and thus our slot size (based on our limit) would
+                    # exit a fractional unit's worth so, presuming we aren't
+                    # supporting a fractional-units-style broker, we need
+                    # exit the final unit.
+                    ld == 0
+                    and abs_live_size == 1
+                )
             ):
                 order_size = abs_live_size
 
@@ -203,13 +212,14 @@ def next_order_info(
             # compute a fractional slots size to display
             slots_used = self.slots_used(
                 Position(
-                    symbol=sym,
+                    mkt=mkt,
                     size=order_size,
                     ppu=price,
-                    bsuid=sym,
+                    bs_mktid=mkt.bs_mktid,
                 )
             )
 
+        # TODO: render an actual ``Executable`` type here?
         return {
             'size': abs(round(order_size, ndigits=ld)),
             'size_digits': ld,
@@ -249,7 +259,7 @@ def slots_used(
 
 def mk_allocator(
 
-    symbol: Symbol,
+    mkt: MktPair,
     startup_pp: Position,
 
     # default allocation settings
@@ -276,6 +286,6 @@ def mk_allocator(
     defaults.update(user_def)
 
     return Allocator(
-        symbol=symbol,
+        mkt=mkt,
         **defaults,
     )