abstract-math 0.0.0.21__py3-none-any.whl → 0.0.0.23__py3-none-any.whl

abstract_math/derive_tokens.py

@@ -1,5 +1,7 @@
 from decimal import Decimal, getcontext
 from .safe_math import *
+def exponentials(value,exp=9,num=-1):
+    return multiply_it(value,exp_it(10,exp,num))
 
 # High precision for decimal ops
 getcontext().prec = 50

abstract_math/safe_math.py

@@ -1,56 +1,44 @@
 from abstract_utilities import *
 import math
-#math functions ------------------------------------------------------------------------------------------------------
-
-def add_it(number_1,number_2):
-    if return_0(number_1,number_2)==float(0):
-        return float(0)
-    return float(number_1)+float(number_2)
-
-def subtract_it(number_1,number_2):
-    if return_0(number_1,number_2)==float(0):
-        return float(0)
-    return float(number_1)-float(number_2)
-
-def get_percentage(owner_balance,address_balance):
-    retained_div = divide_it(owner_balance,address_balance)
-    retained_mul = multiply_it(retained_div,100)
-    return round(retained_mul,2)
-
-def return_0(*args):
-    """Return True if *any* arg is “falsy” (None, non-number, or zero‐like)."""
-    for arg in args:
-        if arg is None or not is_number(arg) or str(arg).strip().lower() in ('0', '', 'null'):
-            return True
-    return False
+import operator
+from functools import reduce
+
+# -------------------------------
+# Core numeric hygiene
+# -------------------------------
+def _is_bad(x):
+    return (x is None) or (not is_number(x)) or (str(x).strip().lower() in ('', 'null'))
 
 def gather_0(*args):
-    """Convert any “falsy” arg into float(0), leave others alone."""
-    cleaned = []
-    for arg in args:
-        if arg is None or not is_number(arg) or str(arg).strip().lower() in ('0', '', 'null'):
-            cleaned.append(0.0)
-        else:
-            cleaned.append(float(arg))
-    return cleaned
+    """Convert any bad / empty / 'null' to 0.0, keep others as float."""
+    out = []
+    for a in args:
+        out.append(0.0 if _is_bad(a) else float(a))
+    return out
 
+# -------------------------------
+# Basic ops (single definitions)
+# -------------------------------
 def add_it(*args):
-    """Sum together any number of args, treating bad values as 0."""
+    """Sum all args; bad values become 0."""
+    return float(sum(gather_0(*args)))
+
+def subtract_it(*args):
+    """a0 - a1 - a2 - ... ; bad values become 0."""
     nums = gather_0(*args)
-    return float(sum(nums))
+    if not nums:
+        return 0.0
+    return float(reduce(operator.sub, nums))
 
 def multiply_it(*args):
-    """Multiply any number of args, but return 0 if any input is ‘bad’ or zero-like."""
+    """Multiply all args; if any becomes 0 (bad or literal zero), result is 0."""
     nums = gather_0(*args)
     if any(n == 0.0 for n in nums):
         return 0.0
     return float(reduce(operator.mul, nums, 1.0))
 
 def divide_it(*args):
-    """
-    Divide args[0] by args[1] by args[2]… 
-    If any input is bad or you hit a zero‐division, return 0.
-    """
+    """a0 / a1 / a2 / ... ; bad => 0, safe against ZeroDivisionError (returns 0)."""
     nums = gather_0(*args)
     try:
         return float(reduce(operator.truediv, nums))
@@ -58,106 +46,162 @@ def divide_it(*args):
         return 0.0
 
 def floor_divide_it(*args):
-    """
-    Floor‐divide args[0] by args[1] by args[2]…
-    If any input is bad or you hit a zero‐division, return 0.
-    """
+    """a0 // a1 // a2 // ... ; bad => 0, safe against ZeroDivisionError (returns 0)."""
     nums = gather_0(*args)
     try:
         return float(reduce(operator.floordiv, nums))
     except ZeroDivisionError:
         return 0.0
 
-def subtract_it(*args):
-    """
-    Subtract all subsequent args from the first:
-       args[0] - args[1] - args[2] - …
-    Bad values become 0.
-    """
-    nums = gather_0(*args)
-    if not nums:
-        return 0.0
-    return float(reduce(operator.sub, nums))
-
+# -------------------------------
+# Exponent helpers (deduplicated)
+# -------------------------------
 def exp_it(base, *factors):
     """
     Raise `base` to the power of (product of all `factors`).
-    e.g. exp_it(10, 2, 3) → 10**(2*3) == 10**6
-    Bad values become 0 (and so the result is 0).
+    exp_it(10, 2, 3) -> 10 ** (2*3) == 10**6
+    If any input is bad or no factors given, returns 0.0 (consistent with other helpers).
     """
     nums = gather_0(base, *factors)
     b, *f = nums
-    if return_0(*nums) or not f:
+    if not f or any(n == 0.0 for n in nums):
         return 0.0
-    exponent = reduce(operator.mul, f, 1.0)
+    exponent = float(reduce(operator.mul, f, 1.0))
     return float(b) ** exponent
 
+def pow10(exp):
+    """10**exp with float output; bad exp -> 0.0^? -> return 1.0 (neutral for scaling)."""
+    if _is_bad(exp):
+        return 1.0
+    return 10.0 ** float(exp)
+
+def scale_pow10(value, exp):
+    """Scale value by 10**exp. Neutral if exp is bad."""
+    return multiply_it(value, pow10(exp))
+
+# Canonical public API for “multiply by 10^…”:
 def exponential(value, *exp_factors):
     """
-    Multiply `value` by 10 to the power of (product of exp_factors).
-    e.g. exponential(5, 2, 3) → 5 * (10**(2*3)) == 5 * 1_000_000
-    If you give no exp_factors, it just returns value.
+    Multiply `value` by 10 ** (product(exp_factors)).
+    exponential(5, 2, 3) -> 5 * 10**(2*3) == 5e6
+    If no exp_factors are given, returns value.
+    """
+    if not exp_factors:
+        return float(value) if not _is_bad(value) else 0.0
+    exp_prod = multiply_it(*exp_factors)
+    if exp_prod == 0.0 and all(not _is_bad(x) for x in exp_factors):
+        # valid inputs produced 0 exponent => scale by 1
+        return float(value) if not _is_bad(value) else 0.0
+    return scale_pow10(value, exp_prod)
+
+# Back-compat alias for legacy callers:
+def exponentials(value, exp=9, num=1):
+    """
+    Legacy alias: multiply `value` by 10 ** (exp * num).
+    Prefer: exponential(value, exp, num) or scale_pow10(value, exp*num).
     """
-    power = exp_it(10, *exp_factors) or 1.0
-    return multiply_it(value, power)
+    return exponential(value, exp, num)
 
-def get_proper_args(strings,*args,**kwargs):
-    properArgs = [] 
+# -------------------------------
+# Argument picker
+# -------------------------------
+def get_proper_args(strings, *args, **kwargs):
+    """
+    Extract values by key order from kwargs first; if missing, consume positional args in order.
+    Example: get_proper_args(["a","b"], 1, b=3) -> [1, 3]
+    """
+    proper = []
+    args = list(args)
     for key in strings:
-        kwarg = kwargs.get(key)
-        if kwarg == None and args:
-            kwarg = args[0]
-            args = [] if len(args) == 1 else args[1:]
-        properArgs.append(kwarg)
-    return properArgs
-def get_lamp_difference(*args,**kwargs):
-    sol_lamports =int(exponential(1,exp=9,num=1))
-    proper_args = get_proper_args(["virtualSolReserves"],*args,**kwargs)
-    virtualLamports = len(str(proper_args[0]))
-    virtual_sol_lamports =int(exponential(1,exp=virtualLamports,num=1))
-    return int(exponential(1,exp=len(str(int(virtual_sol_lamports/sol_lamports))),num=1))
-def get_price(*args,**kwargs):
-    proper_args = get_proper_args(["virtualSolReserves","virtualTokenReserves"],*args,**kwargs)
-    return divide_it(*proper_args)/get_lamp_difference(*args,**kwargs)
-def get_amount_price(*args,**kwargs):
-    proper_args = get_proper_args(["solAmount","tokenAmount"],*args,**kwargs)
-    return divide_it(*proper_args) 
-def getSolAmountUi(*args,**kwargs):
-    proper_args = get_proper_args(["solAmount"],*args,**kwargs)
-    return exponential(proper_args[0],9)
-def getTokenAmountUi(*args,**kwargs):
-    solAmountUi = getSolAmountUi(*args,**kwargs)
-    price = get_price(*args,**kwargs)
-    return solAmountUi/price
-def derive_token_decimals(*args,**kwargs):
-    proper_args = get_proper_args(["virtualTokenReserves","tokenAmount"],*args,**kwargs)
-    price = get_price(*args,**kwargs)
-    if not (proper_args[1] > 0 and proper_args[0] > 0 and price > 0):
+        if key in kwargs:
+            proper.append(kwargs[key])
+        elif args:
+            proper.append(args.pop(0))
+        else:
+            proper.append(None)
+    return proper
+
+# -------------------------------
+# Your SOL / token helpers (using the unified expo)
+# -------------------------------
+SOL_DECIMAL_PLACE = 9
+SOL_LAMPORTS = int(pow10(SOL_DECIMAL_PLACE))  # 10**9
+
+def get_lamp_difference(*args, **kwargs):
+    """
+    Keep behavior: compute a lamport “scale” based on digit length of virtualSolReserves.
+    """
+    sol_lamports = SOL_LAMPORTS
+    [virtualSolReserves] = get_proper_args(["virtualSolReserves"], *args, **kwargs)
+    if _is_bad(virtualSolReserves):
+        return 0
+    virtual_len = len(str(int(float(virtualSolReserves))))
+    virtual_sol_lamports = int(pow10(virtual_len))  # 10**virtual_len
+    scale_len = len(str(int(virtual_sol_lamports / sol_lamports))) if sol_lamports else 0
+    return int(pow10(scale_len))
+
+def get_price(*args, **kwargs):
+    """
+    price = virtualSolReserves / virtualTokenReserves / lamp_difference
+    """
+    virtualSolReserves, virtualTokenReserves = get_proper_args(
+        ["virtualSolReserves", "virtualTokenReserves"], *args, **kwargs
+    )
+    base = divide_it(virtualSolReserves, virtualTokenReserves)
+    return divide_it(base, get_lamp_difference(*args, **kwargs))
+
+def get_amount_price(*args, **kwargs):
+    solAmount, tokenAmount = get_proper_args(["solAmount", "tokenAmount"], *args, **kwargs)
+    return divide_it(solAmount, tokenAmount)
+
+def getSolAmountUi(*args, **kwargs):
+    [solAmount] = get_proper_args(["solAmount"], *args, **kwargs)
+    # scale by 10**9
+    return exponential(solAmount, SOL_DECIMAL_PLACE)
+
+def getTokenAmountUi(*args, **kwargs):
+    solAmountUi = getSolAmountUi(*args, **kwargs)
+    price = get_price(*args, **kwargs)
+    return divide_it(solAmountUi, price)
+
+def derive_token_decimals(*args, **kwargs):
+    virtualTokenReserves, tokenAmount = get_proper_args(
+        ["virtualTokenReserves", "tokenAmount"], *args, **kwargs
+    )
+    price = get_price(*args, **kwargs)
+    if not (virtualTokenReserves and tokenAmount and price) or any(
+        float(x) <= 0 for x in [virtualTokenReserves, tokenAmount, price]
+    ):
         raise ValueError("All inputs must be positive.")
-    derived_token_amount = proper_args[0] / price
-    ratio = derived_token_amount / proper_args[1]
+    derived_token_amount = divide_it(virtualTokenReserves, price)
+    ratio = divide_it(derived_token_amount, tokenAmount)
+    # count decimal places needed to make ratio an integer (tolerant to fp noise)
     decimals = -1
     while abs(ratio - round(ratio)) > 1e-9:
         ratio *= 10
         decimals += 1
     return decimals
+
 def derive_token_decimals_from_token_variables(variables):
-  variables["price"] = get_price(**variables)
-  derived_token_amount = variables["virtualTokenReserves"] / variables["price"]
-  ratio = derived_token_amount / variables["tokenAmount"]
-  decimals = -1
-  while abs(ratio - round(ratio)) > 1e-9:
-      ratio *= 10
-      decimals += 1
-  variables["tokenDecimals"] = decimals
-  return variables
-def get_token_amount_ui(*args,**kwargs):
-  proper_args = get_proper_args(["tokenAmount"],*args,**kwargs)
-  return exponential(proper_args[0],exp=-derive_token_decimals(*args,**kwargs),num=1)
+    variables["price"] = get_price(**variables)
+    derived_token_amount = divide_it(variables["virtualTokenReserves"], variables["price"])
+    ratio = divide_it(derived_token_amount, variables["tokenAmount"])
+    decimals = -1
+    while abs(ratio - round(ratio)) > 1e-9:
+        ratio *= 10
+        decimals += 1
+    variables["tokenDecimals"] = decimals
+    return variables
+
+def get_token_amount_ui(*args, **kwargs):
+    [tokenAmount] = get_proper_args(["tokenAmount"], *args, **kwargs)
+    # scale by 10**(-token_decimals)
+    dec = derive_token_decimals(*args, **kwargs)
+    return exponential(tokenAmount, -dec, 1)
+
 def update_token_variables(variables):
     variables['solAmountUi'] = getSolAmountUi(**variables)
-    variables['solDecimals'] = 9
+    variables['solDecimals'] = SOL_DECIMAL_PLACE
     variables = derive_token_decimals_from_token_variables(variables)
-    variables['tokenAmountUi'] = exponential(variables['tokenAmount'],exp=-variables["tokenDecimals"],num=1)
+    variables['tokenAmountUi'] = exponential(variables['tokenAmount'], -variables["tokenDecimals"], 1)
     return variables
-

abstract_math/solar_math/src/imports.py

@@ -1,5 +1,5 @@
 import math
 from typing import Dict, Callable, Optional, Any
-from ....safe_math import (
+from ...safe_math import (
     multiply_it as mul, divide_it as div, add_it as add, subtract_it as sub, exp_it as exp
 )

{abstract_math-0.0.0.21.dist-info → abstract_math-0.0.0.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_math
-Version: 0.0.0.21
+Version: 0.0.0.23
 Author: putkoff
 Author-email: partners@abstractendeavors.com
 Classifier: Development Status :: 3 - Alpha

{abstract_math-0.0.0.21.dist-info → abstract_math-0.0.0.23.dist-info}/RECORD

@@ -1,13 +1,13 @@
 abstract_math/__init__.py,sha256=wr-kwaB8micSsR1nCHuDXRlsL59DWlqZQFN7M_rfZys,80
-abstract_math/derive_tokens.py,sha256=Ts_Jh-UnVQEgo3cfkIhpbaXGPmLG148pGqksnuOtJxk,4498
-abstract_math/safe_math.py,sha256=sJvGIMj2urcsAeWcc72WBjzrpkaKIRJoZUBYdaC9tzA,5961
+abstract_math/derive_tokens.py,sha256=mVzwkLv1Jo76R-SGR0hZbO5MPOr7vZpDC44eyxUvfzU,4585
+abstract_math/safe_math.py,sha256=9T1-n6dcMYzJtem8xEIGEKOLR5X4DOIj_h9aotvyzdE,7347
 abstract_math/flask_scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 abstract_math/flask_scripts/flask_utils.py,sha256=z6gpPshiOeqNANBQkZMZPkegCzj-GK3OpSOi1lN19Sc,28483
 abstract_math/solar_math/__init__.py,sha256=FfPkmWi3cQ3BLvUUUf6k22rGBE8scDL1EoM5l24biVo,39
 abstract_math/solar_math/flask_utils.py,sha256=c82LrZ0dKC3Y8LxqOs1zDR6gRy8oXSx9balBD18gNB0,459
 abstract_math/solar_math/main.py,sha256=EtcUmUWj27c7mcnm-hlfeCeYFuPytPevXx5vClVu6Q8,10000
 abstract_math/solar_math/src/__init__.py,sha256=qeal73F-NLu6sO_YSmD_komVpe17f0OFy2IfBR2QU_s,70
-abstract_math/solar_math/src/imports.py,sha256=GfkWfXDc6fzLe7kHYlSdghkN0Nob0xApxhEyRyDcZS0,182
+abstract_math/solar_math/src/imports.py,sha256=UZp2SkF8INamFVwLOIca6w9K-YKXsqhiqcf6bkWuLVo,181
 abstract_math/solar_math/src/constants/__init__.py,sha256=HpRa4MWkJZu3Wcx6KchB8__RL4FfkVqRw78TAnjRRwo,691
 abstract_math/solar_math/src/constants/distance_constants.py,sha256=stM3nWxpANQEtoxFcbxpO0ly_UM4JJ2aH0VK42fHw6s,1985
 abstract_math/solar_math/src/constants/planet_constants.py,sha256=tt2nbFtRtYhUU9D918WK91D-S5Cv0HEJ-1j7f9Yb50w,6602
@@ -16,7 +16,7 @@ abstract_math/solar_math/src/utils/__init__.py,sha256=Vb2bfx1p9YSmhnbqXBjGVPt1OQ
 abstract_math/solar_math/src/utils/escape_velocity.py,sha256=9oixNxWyY4pxa7e1INwbreD8GJEw2BZIgV_IqXiDd9Y,2971
 abstract_math/solar_math/src/utils/geometry_utils.py,sha256=Ij4mASNFp2-CWy425fxMTEuMPuAZHs-E0qvi3BjaNkk,4169
 abstract_math/solar_math/src/utils/velocity_utils.py,sha256=_SyOscVvYsvbm1T1Rh4uqegXdf61mHll5s3UfQcdUnU,1162
-abstract_math-0.0.0.21.dist-info/METADATA,sha256=YkC0CIK7ZbdbL-TkobbbEaIjonlma317OySbl8ShCmE,3081
-abstract_math-0.0.0.21.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-abstract_math-0.0.0.21.dist-info/top_level.txt,sha256=b7jOgD9c0U-CGH-l7yxhMPukzD40kMEQkQRV_sGyVfE,14
-abstract_math-0.0.0.21.dist-info/RECORD,,
+abstract_math-0.0.0.23.dist-info/METADATA,sha256=sE9PH3BoVK35D72oQm4Le2vgRqxmsYxYMcqKz9VuZOU,3081
+abstract_math-0.0.0.23.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+abstract_math-0.0.0.23.dist-info/top_level.txt,sha256=b7jOgD9c0U-CGH-l7yxhMPukzD40kMEQkQRV_sGyVfE,14
+abstract_math-0.0.0.23.dist-info/RECORD,,