abstract-math 0.0.0.10__tar.gz → 0.0.0.12__tar.gz

{abstract_math-0.0.0.10 → abstract_math-0.0.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: abstract_math
-Version: 0.0.0.10
+Version: 0.0.0.12
 Author: putkoff
 Author-email: partners@abstractendeavors.com
 Classifier: Development Status :: 3 - Alpha
@@ -10,5 +10,11 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-python
 
 Safe math for delicate Processes, paralell in use case to SafeMath For SmartContracts in that it is designed to circumvent fatal errors for low level MDAS. 

{abstract_math-0.0.0.10 → abstract_math-0.0.0.12}/setup.py

@@ -4,7 +4,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
     long_description = fh.read()
 setuptools.setup(
     name='abstract_math',
-    version='0.0.0.10',
+    version='0.0.0.12',
     author='putkoff',
     author_email='partners@abstractendeavors.com',
     description="",

{abstract_math-0.0.0.10 → abstract_math-0.0.0.12}/src/abstract_math/derive_tokens.py

@@ -59,7 +59,7 @@ def get_token_amount(*args,**kwargs):
     return proper_args[0] if proper_args else proper_args
 def get_token_amount_ui(*args,**kwargs):
     token_amount = get_token_amount(*args,**kwargs)
-    token_decimals = derive_token_decimals(*args,**kwargs)
+    token_decimals = derive_decimals_from_vars(*args,**kwargs)
     return exponential(token_amount,exp=token_decimals)
 #token derivision
 def derive_token_decimals_from_token_variables(**variables):
@@ -94,4 +94,15 @@ def update_token_variables(variables):
     variables = derive_token_decimals_from_token_variables(**variables)
     variables['tokenAmountUi'] = get_token_amount_ui(**variables)
     return variables
+# get the liquidity and sqrt of price 
+pool_contract = web3.eth.contract(address=pool_address, abi=v3_pool_abi)
+slot0 = pool_contract.functions.slot0().call()
+sqrt_price_x96 = slot0[0]
+liquidity = pool_contract.functions.liquidity().call()
 
+# compute the virtual reserves
+Q96 = 2 ** 96
+Q192 = 2 ** 192
+reserve0_x96 = liquidity * Q192 / sqrt_price_x96
+reserve1_x96 = liquidity * sqrt_price_x96
+token_decimals = math.log10((int(data['virtualTokenReserves']["data"]) * (10**int(9) / (int(data['virtualSolReserves']["data"])) * (int(data['tokenAmount']["data"]) / int(data['solAmount']["data"])))))

abstract_math-0.0.0.12/src/abstract_math/safe_math.py

@@ -0,0 +1,101 @@
+from abstract_utilities import *
+import math
+#math functions ------------------------------------------------------------------------------------------------------
+def exponential(value,exp=9,num=-1):
+    return multiply_it(value,exp_it(10,exp,num))
+
+def return_0(*args):
+    for arg in args:
+        if arg == None or not is_number(arg) or arg in [0,'0','','null',' ']:
+            return float(0)
+        
+def exp_it(number,integer,mul):
+    if return_0(number,integer,mul)==float(0):
+        return float(0)
+    return float(number)**float(float(integer)*int(mul))
+
+def divide_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 multiply_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 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 get_proper_args(strings,*args,**kwargs):
+    properArgs = [] 
+    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):
+        raise ValueError("All inputs must be positive.")
+    derived_token_amount = proper_args[0] / price
+    ratio = derived_token_amount / proper_args[1]
+    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)
+def update_token_variables(variables):
+    variables['solAmountUi'] = getSolAmountUi(**variables)
+    variables['solDecimals'] = 9
+    variables = derive_token_decimals_from_token_variables(variables)
+    variables['tokenAmountUi'] = exponential(variables['tokenAmount'],exp=-variables["tokenDecimals"],num=1)
+    return variables
+

{abstract_math-0.0.0.10 → abstract_math-0.0.0.12}/src/abstract_math.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: abstract_math
-Version: 0.0.0.10
+Version: 0.0.0.12
 Author: putkoff
 Author-email: partners@abstractendeavors.com
 Classifier: Development Status :: 3 - Alpha
@@ -10,5 +10,11 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-python
 
 Safe math for delicate Processes, paralell in use case to SafeMath For SmartContracts in that it is designed to circumvent fatal errors for low level MDAS. 

abstract_math-0.0.0.10/src/abstract_math/safe_math.py

@@ -1,209 +0,0 @@
-#abstract_bots.py
-import os
-import re
-import json
-import shutil
-import logging
-logging.basicConfig(level=logging.INFO)
-logging.basicConfig(level=logging.DEBUG,format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-from abstract_utilities import (safe_dump_to_file,
-                                safe_read_from_json,
-                                get_any_value,
-                                make_list,
-                                eatAll)
-#json functions-----------------------------------------------------------------------------------------------------------------------------------------
-def safe_json_loads(data):
-    if not isinstance(data, (dict, str)):
-        data = str(data)
-    if not isinstance(data, dict):
-        try:
-            data = json.loads(data)
-        except json.JSONDecodeError:
-            logger.error("Error parsing data with json, data might not be in correct format.")
-            data = None
-    return data
-
-def load_json_data(file_path):
-    try:
-        with file_path.open('r') as file:
-            return json.load(file)
-    except json.JSONDecodeError as e:
-        logger.error(f"Error reading JSON file: {e}")
-        return None
-    
-def safe_list(obj,keys):
-    keys = make_list(keys)
-    for key in keys:
-        if obj and isinstance(obj,list) and is_number(key) and len(obj)>key:
-            obj = obj[int(key)]
-        else:
-            return obj
-    return obj
-
-def safe_get(obj,keys):
-    keys = make_list(keys)
-    new_obj = obj
-    for i,key in enumerate(keys):
-        if isinstance(new_obj,dict):
-            new_obj = new_obj.get(key,None if len(keys)-1 == i else {})
-        elif isinstance(new_obj,list):
-            new_obj = safe_list(new_obj,key)
-        else:
-            return new_obj
-    return new_obj
-
-def get_all_keys(dict_data,keys=[]):
-  if isinstance(dict_data,dict):
-    for key,value in dict_data.items():
-      keys.append(key)
-      keys = get_all_keys(value,keys=keys)
-  return keys
-#address sanitation-----------------------------------------------------------------------------------------------
-def get_data(file_path):
-    if os.path.isfile(file_path):
-        return safe_read_from_json(file_path)
-    
-#directory functions --------------------------------------------------------------------------------------------
-def move_file(src_path,dst_file_path):
-    shutil.move(str(src_path), str(dst_file_path))
-    logger.info(f"Moved {src_path.name} to errored messages directory.")
-
-def secure_delete(file_path):
-    try:
-        if os.path.exists(file_path):
-            os.remove(file_path)
-            logger.info(f"File {file_path} has been deleted.")
-        else:
-            logger.warning(f"File {file_path} does not exist.")
-    except OSError as e:
-        logger.error(f"Error deleting file {file_path}: {e.strerror}")
-
-def make_directory(file_path):
-    os.makedirs(file_path, exist_ok=True)
-    return file_path
-
-def get_create_data(file_path,data={}):
-    if not os.path.isfile(file_path):
-        safe_dump_to_file(data=data,file_path=file_path)
-    return safe_read_from_json(file_path)
-
-#type functions --------------------------------------------------------------------------------------------------
-def get_args_send_args(function, *args):
-    if not args:
-        return args
-    input_type = type(args[0])
-    flattened_args = []
-    for arg in args:
-        if isinstance(arg, (list, set, tuple)):
-            flattened_args.extend(arg)
-        else:
-            flattened_args.append(arg)
-    processed_items = [function(item) for item in flattened_args]
-    if input_type is list:
-        return processed_items
-    elif input_type is set:
-        return set(processed_items)
-    elif input_type is tuple:
-        return tuple(processed_items)
-    else:
-        # Assuming if_single_obj is a function that handles single objects
-        return if_single_obj(processed_items)
-    
-def list_set(obj):
-    obj = obj or []
-    return list(set(obj))
-
-def get_symetric_difference(obj_1,obj_2):
-    set1 = set(obj_1)
-    set2 = set(obj_2)
-    # Find elements that are unique to each list
-    unique_elements = set1.symmetric_difference(set2)
-    # Convert the set back to a list, if needed
-    return list(unique_elements)
-
-def if_single_obj(list_obj):
-    if list_obj and isinstance(list_obj,list) and len(list_obj)==1:
-        list_obj = list_obj[0]
-    return list_obj
-
-def list_set(obj):
-    try:
-        obj = list(set(obj))
-    except Exception as e:
-        print(f"{e}")
-    return obj
-
-def str_lower(obj):
-    try:
-        obj=str(obj).lower()
-    except Exception as e:
-        print(f"{e}")
-    return obj
-
-def is_number(obj):
-    try:
-        float(obj)
-        return True
-    except (ValueError, TypeError):
-        return False
-#address functions-------------------------------------------------------------------------------------------------
-def normalize_address(address):
-    address =str(address).lower()
-    if address.startswith('0x'):
-        address = address[2:]
-    return address
-
-def normalize_all_addresses(*args):
-    return get_args_send_args(normalize_address,*args)
-
-def serialize_all_addresses(*args):
-    return get_args_send_args(check_and_reserialize_solana_address, *args)
-
-def make_directory(data_path):
-    os.makedirs(data_path, exist_ok=True)
-    return data_path
-
-def get_amount_dict(amount,decimals=9):
-    if amount!= None:
-        if isinstance(amount,dict):
-            amount_dict = get_any_value(amount,'uiTokenAmount')
-            amount = get_any_value(amount_dict,'amount')
-            decimals = get_any_value(amount_dict,'decimals')
-        return exponential(amount,decimals,-1)
-#math functions ------------------------------------------------------------------------------------------------------
-def exponential(value,exp=9,num=-1):
-    return multiply_it(value,exp_it(10,exp,num))
-
-def return_0(*args):
-    for arg in args:
-        if arg == None or not is_number(arg) or arg in [0,'0','','null',' ']:
-            return float(0)
-        
-def exp_it(number,integer,mul):
-    if return_0(number,integer,mul)==float(0):
-        return float(0)
-    return float(number)**float(float(integer)*int(mul))
-
-def divide_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 multiply_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 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 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)
-
- 
-