# coding=utf-8 
import json
import os
import sys
import ujson
import time
import requests
from loguru import logger
from datetime import datetime, timedelta
from easybitcoinrpc import RPC
import csv
import sqlite3
from bitcoinutils.script import Script
from bitcoinutils.keys import P2wpkhAddress, P2wshAddress, P2shAddress, PrivateKey, PublicKey, SegwitAddress, P2pkhAddress
from bitcoinutils.setup import setup
import pymysql
import pymongo
from urllib import parse

import btc_historical_price


class UtxosIf:
    def __init__(self):
        self.balance_0 = 0
        self.balance_001 = 0
        self.balance_01 = 0
        self.balance_1 = 0
        self.balance_10 = 0
        self.balance_100 = 0
        self.balance_1000 = 0
        self.balance_10000 = 0

        self.balance_amount_0 = 0
        self.balance_amount_001 = 0
        self.balance_amount_01 = 0
        self.balance_amount_1 = 0
        self.balance_amount_10 = 0
        self.balance_amount_100 = 0
        self.balance_amount_1000 = 0
        self.balance_amount_10000 = 0

        self.profit_addresses = 0
        self.loss_addresses = 0
        self.profit_ratio = 0
        self.lth_supply = 0
        self.sth_supply = 0
        self.realized_price = 0
        self.relative_lth_sth = 0
        self.lth_profit_supply = 0
        self.lth_loss_supply = 0
        self.lth_profit_ratio = 0
        self.sth_profit_supply = 0
        self.sth_loss_supply = 0
        self.sth_profit_ratio = 0
        self.slrv_ratio = 0
        self.slrv_24h = 0
        self.slrv_6m1y = 0

        self.total_address = 0
        self.miner_address = 0
        self.miner_balance = 0
        self.total_balance = 0
        self.total_rcap = 0
        self.holder_0 = 0
        self.holder_1 = 0
        self.holder_2 = 0
        self.holder_3 = 0
        self.holder_4 = 0
        self.holder_5 = 0
        self.holder_6 = 0
        self.holder_7 = 0
        self.holder_15 = 0
        self.holder_30 = 0
        self.holder_60 = 0
        self.holder_90 = 0
        self.holder_180 = 0
        self.holder_360 = 0
        self.holder_540 = 0
        self.holder_720 = 0
        self.holder_1080 = 0
        self.holder_1440 = 0
        self.holder_1800 = 0
        self.holder_2160 = 0
        self.holder_2520 = 0
        self.holder_2880 = 0
        self.holder_3240 = 0
        self.holder_3600 = 0
        self.holder_3960 = 0

        self.holder_balance_0 = 0
        self.holder_balance_1 = 0
        self.holder_balance_2 = 0
        self.holder_balance_3 = 0
        self.holder_balance_4 = 0
        self.holder_balance_5 = 0
        self.holder_balance_6 = 0
        self.holder_balance_7 = 0
        self.holder_balance_15 = 0
        self.holder_balance_30 = 0
        self.holder_balance_60 = 0
        self.holder_balance_90 = 0
        self.holder_balance_180 = 0
        self.holder_balance_360 = 0
        self.holder_balance_540 = 0
        self.holder_balance_720 = 0
        self.holder_balance_1080 = 0
        self.holder_balance_1440 = 0
        self.holder_balance_1800 = 0
        self.holder_balance_2160 = 0
        self.holder_balance_2520 = 0
        self.holder_balance_2880 = 0
        self.holder_balance_3240 = 0
        self.holder_balance_3600 = 0
        self.holder_balance_3960 = 0

        self.price_buy = {}  # step 500
        self.price_buy_amount = {}  # step 500
        self.diff_sell = {}  # step 500
        self.diff_sell_amount = {}
        self.profit_sell = {}  # step 5000
        self.profit_sell_amount = {}

        self.balance_0_days = {}
        self.balance_001_days = {}
        self.balance_01_days = {}
        self.balance_1_days = {}
        self.balance_10_days = {}
        self.balance_100_days = {}
        self.balance_1000_days = {}
        self.balance_10000_days = {}

        self.balance_amount_0_days = {}
        self.balance_amount_001_days = {}
        self.balance_amount_01_days = {}
        self.balance_amount_1_days = {}
        self.balance_amount_10_days = {}
        self.balance_amount_100_days = {}
        self.balance_amount_1000_days = {}
        self.balance_amount_10000_days = {}

        '''
        self.current_dt = time.time()
        self.current_dt2 = time.gmtime(int(self.current_dt))
        self.current_daystr = time.strftime("%d %b %Y", self.current_dt2)
        self.current_dayutc = int(time.mktime(time.strptime(self.current_daystr, "%d %b %Y")))
        '''

        self.mc = pymongo.MongoClient("mongodb://10.168.3.192:27018/")
        self.mdb = self.mc["btcutxos2"]
        # self.mdb.authenticate("root", "123456")

        self.uprofit = 0
        self.uloss = 0
        self.lth_nupl = 0
        self.sth_nupl = 0
        self.lth_mv = 0
        self.sth_mv = 0
        self.lth_rcap = 0
        self.sth_rcap = 0
        self.lth_mvrv = 0
        self.sth_mvrv = 0
#     此“UtxosIf”类使用默认值初始化大量属性。以下是属性的摘要：
#
#     - 与平衡相关的属性：
#     - 'balance_0'， 'balance_001'， ...， 'balance_10000'：这些是不同面额比特币的余额计数器。
#     - 'balance_amount_0'， 'balance_amount_001'， ...， 'balance_amount_10000'：这些是与余额计数器相对应的余额金额。
#
#     - 与地址和利润相关的属性：
#     - 'profit_addresses'：利润计数器地址。
#     - 'loss_addresses'： 丢失地址的计数器。
#     - 与利润率、供应、已实现价格等相关的各种其他属性
#
#
# - 与持有人及其余额相关的属性：
# - 不同时间间隔的持有者计数器（'holder_0'、'holder_1'、...、'holder_3960'）。
# - 每个持有人的相应余额属性。
#
# - 与价格和交易相关的属性：
# - 用于存储价格和交易金额的字典（'price_buy'、'price_buy_amount'、'diff_sell'、'diff_sell_amount'、'profit_sell'、'profit_sell_amount'）。
#
# - 与余额随时间变化相关的属性：
# - 用于存储不同时间间隔的余额变化的字典（'balance_0_days'、'balance_001_days'、...、'balance_amount_10000_days'）。
#
# - 与
# MongoDB
# 连接和其他指标相关的属性：
# - 连接到MongoDB数据库（'mc'，'mdb'）。
# - 与利润、亏损、已实现资本化等相关的指标
#
# 此类似乎用于管理与比特币UTXO（未花费的交易输出）相关的各种指标和数据
    def init_db(self):
        return pymysql.connect(host="172.17.0.1", port=4419, user="root", password="IeQcJNnagkaFP1Or", database="btcdb",
                               cursorclass=pymysql.cursors.DictCursor)
# 'init_dbpymysql库来建立连接。
    #
    # 以下是该方法的作用的细分
    #
    # 它使用提供的主机、端口、用户名、密码和数据库名称建立与
    # MySQL
    # 数据库的连接。
    def get_vout_addr(self, rpc, txid, vout):
        addr = None
        addrtype = None
        ip = "127.0.0.1"
        port = "8332"
        user = "user"
        password = "password"
        timeout=100
        if rpc is None:
            rpc = RPC(ip, port, user, password)
        tx = None
        while True:
            try:
                tx = rpc.transactions.get_raw_transaction(txid, True)
                #break
            except:
                time.sleep(1)
                #print("reconnect")
                rpc = RPC(ip, port, user, password)
                continue

            txouts = tx["vout"]
            txout = None
            for outone in txouts:
                # print(outone, vout)
                if outone["n"] == vout:
                    txout = outone
                    break
            scriptPubKey = txout["scriptPubKey"]
            addrtype = scriptPubKey["type"]

            #print("get_vout_addr", txid, vout, tx, scriptPubKey, addrtype)
            if "address" not in scriptPubKey:
                addr = scriptPubKey["hex"]
                if scriptPubKey["type"] == "pubkey":
                    temphex = scriptPubKey["hex"]
                    try:
                        if temphex[2:4] == "04":
                            addr = PublicKey(temphex[2:132]).get_address(False).to_string()
                        else:
                            addr = PublicKey(temphex[2:68]).get_address().to_string()
                        print("pubkey", txid, temphex, addr)
                    except Exception as e:
                        print("pubkey exception", txid, vout, temphex, addr, e)
                else:
                    print(scriptPubKey)
            else:
                addr = scriptPubKey["address"]
                # print(addr)

            break

        return rpc, addr, addrtype
# “UtxosIf”类中的“get_vout_addr”方法旨在检索与给定事务 （txid） 中的特定事务输出 （vout） 相对应的地址和地址类型。以下是其功能的细分：
    #
    # -参数：
    #  - 'rpc'：用于与比特币网络交互的 RPC 类的实例。
    #  - 'txid'：交易 ID。
    #  - 'vout'：事务输出的索引。
    #
    # -初始化：
    #  - 它初始化用于 RPC 连接的 IP 地址、端口、用户名和密码的变量。
    #
    # - RPC连接：
    #  - 如果 'rpc' 参数为 'None'，则使用默认 IP、端口、用户名和密码初始化 RPC 连接。
    #
    # - 交易检索：
    #  - 它尝试使用 'get_raw_transaction' 方法从 RPC 对象中检索原始事务详细信息。
    #  - 如果在此过程中出现异常（可能是由于连接问题），它会等待 1 秒钟并重试。
    #
    # - 提取地址：
    #  - 一旦获得交易详细信息，它就会遍历交易的输出（'vout'）以找到特定的输出。
    #  - 它从输出中提取“scriptPubKey”及其类型。
    #  - 如果“scriptPubKey”不直接包含地址，它会尝试解析它（例如，如果它是一个公钥脚本）。
    #
    # - 返回结果：
    #  - 最后，它返回 RPC 实例、地址和地址类型。
    #
    # 方法如下：
    #
    # '''蟒蛇
    # def get_vout_addr（self、rpc、txid、vout）：
    #  addr = 无
    #  addrtype = 无
    #  ip = “127.0.0.1”
    #  端口 =“8332”
    #  user = “用户”
    #  password = “密码”
    #  如果 rpc 为 None：
    #  rpc = RPC（ip， port， user， password）
    #  tx = 无
    #  而 True：
    #  尝试：
    #  tx = rpc.transactions.get_raw_transaction（txid， 真）
    #  除了：
    #  时间睡眠（1）
    #  rpc = RPC（ip， port， user， password）
    #  继续
    #
    # txouts = tx[“vout”]
    #  txout = 无
    #  对于 TXOUTS 中的 Outone：
    #  if outone[“n”] == vout：
    #  txout = outone
    #  破
    #  scriptPubKey = txout[“scriptPubKey”]
    #  addrtype = scriptPubKey[“类型”]
    #
    # 如果 “address” 不在 scriptPubKey 中：
    #  addr = scriptPubKey[“十六进制”]
    #  if scriptPubKey[“type”] == “pubkey”：
    #  temphex = scriptPubKey[“十六进制”]
    #  尝试：
    #  如果 temphex[2：4] == “04”：
    #  addr = PublicKey（temphex[2：132]）.get_address（False）.to_string（）
    #  还：
    #  addr = PublicKey（temphex[2：68]）.get_address（）.to_string（）
    #  print（“pubkey”， txid， temphex， addr）
    #  除了 Exception as e：
    #  print（“pubkey exception”， txid， vout， temphex， addr， e）
    #  还：
    #  print（scriptPubKey）
    #  还：
    #  addr = scriptPubKey[“地址”]
    #
    # 破
    #
    # 返回 RPC、ADDR、ADdrType
    # '''
    #
    # 此方法可确保从事务输出中正确提取地址和地址类型，从而处理检索过程中的潜在错误
    def summary_toplist(self, txid, vout, coinbase, value, height, scriptpubkey, dt, price, dt2):
        if value >= 100:
            rpc = None
            rpc, addr, addrtype = self.get_vout_addr(rpc, txid, vout)
            if addrtype is None:
                addrtype = "unknown"
            if addr is None:
                addr = "unknown"
            toplist = {}
            toplist["txid"] = txid
            toplist["vout"] = vout
            toplist["coinbase"] = coinbase
            toplist["value"] = value
            toplist["height"] = height
            toplist["scriptpubkey"] = scriptpubkey
            toplist["dt"] = dt
            toplist["price"] = price
            toplist["dt2"] = dt2
            toplist["addr"] = addr
            toplist["type"] = addrtype

            result = self.mdbc_toplist.find_one(toplist)
            if result is None or len(result) > 0:

                self.mdbc_toplist.insert_one(toplist)
                #print(self.mdbc_toplist.find_one())
# 该类中的方法似乎用于汇总和存储有关满足特定条件的事务的信息。以下是该方法的作用：summary_toplistUtxosIf
    #
    # 它需要与交易相关的几个参数（、、、）。txidvoutcoinbasevalueheightscriptpubkeydtpricedt2
    # 它首先检查事务输出 （） 的值是否大于或等于100。value
    # 如果该值满足条件，则将变量初始化为None。rpc
    # 然后，它调用该方法来检索与事务输出对应的地址和地址类型。get_vout_addr
    # 它创建一个名为的字典，其中包含有关交易的各种信息，包括其ID、输出索引、是否是
    # coinbase交易、其值、区块高度、scriptPubKey、日期时间信息、价格、地址和地址类型。toplist
    # 它检查MongoDB集合中是否存在具有相同事务ID和输出索引的记录。如果没有，它会将字典插入到集合中。mdbc_toplisttoplist
    def summary_balance_days(self, dt, dt2, value, days_out, balance_out):
        daysecs = 3600 * 24
        days = (dt - dt2)/daysecs
        if days < 1:
            if "day_0" in days_out:
                days_out["day_0"]+=1
                balance_out["day_0"] += value
            else:
                days_out["day_0"]=1
                balance_out["day_0"] = value
        elif days < 1 * 2:
            if "day_1" in days_out:
                days_out["day_1"] += 1
                balance_out["day_1"] += value
            else:
                days_out["day_1"] = 1
                balance_out["day_1"] = value
        elif days < 1 * 3:
            if "day_2" in days_out:
                days_out["day_2"] += 1
                balance_out["day_2"] += value
            else:
                days_out["day_2"] = 1
                balance_out["day_2"] = value
        elif days < 1 * 4:
            if "day_3" in days_out:
                days_out["day_3"] += 1
                balance_out["day_3"] += value
            else:
                days_out["day_3"] = 1
                balance_out["day_3"] = value
        elif days < 1 * 5:
            if "day_4" in days_out:
                days_out["day_4"] += 1
                balance_out["day_4"] += value
            else:
                days_out["day_4"] = 1
                balance_out["day_4"] = value
        elif days < 1 * 6:
            if "day_5" in days_out:
                days_out["day_5"] += 1
                balance_out["day_5"] += value
            else:
                days_out["day_5"] = 1
                balance_out["day_5"] = value
        elif days < 1 * 7:
            if "day_6" in days_out:
                days_out["day_6"] += 1
                balance_out["day_6"] += value
            else:
                days_out["day_6"] = 1
                balance_out["day_6"] = value
        elif days < 1 * 8:
            if "day_7" in days_out:
                days_out["day_7"] += 1
                balance_out["day_7"] += value
            else:
                days_out["day_7"] = 1
                balance_out["day_7"] = value
        elif days < 1 * 9:
            if "day_8" in days_out:
                days_out["day_8"] += 1
                balance_out["day_8"] += value
            else:
                days_out["day_8"] = 1
                balance_out["day_8"] = value
        elif days < 1 * 10:
            if "day_9" in days_out:
                days_out["day_9"] += 1
                balance_out["day_9"] += value
            else:
                days_out["day_9"] = 1
                balance_out["day_9"] = value
        elif days < 1 * 11:
            if "day_10" in days_out:
                days_out["day_10"] += 1
                balance_out["day_10"] += value
            else:
                days_out["day_10"] = 1
                balance_out["day_10"] = value
        elif days < 1 * 12:
            if "day_11" in days_out:
                days_out["day_11"] += 1
                balance_out["day_11"] += value
            else:
                days_out["day_11"] = 1
                balance_out["day_11"] = value
        elif days < 1 * 13:
            if "day_12" in days_out:
                days_out["day_12"] += 1
                balance_out["day_12"] += value
            else:
                days_out["day_12"] = 1
                balance_out["day_12"] = value
        elif days < 1 * 14:
            if "day_13" in days_out:
                days_out["day_13"] += 1
                balance_out["day_13"] += value
            else:
                days_out["day_13"] = 1
                balance_out["day_13"] = value
        elif days < 1 * 15:
            if "day_14" in days_out:
                days_out["day_14"] += 1
                balance_out["day_14"] += value
            else:
                days_out["day_14"] = 1
                balance_out["day_14"] = value
        elif days < 1 * 16:
            if "day_15" in days_out:
                days_out["day_15"] += 1
                balance_out["day_15"] += value
            else:
                days_out["day_15"] = 1
                balance_out["day_15"] = value
        elif days < 1 * 17:
            if "day_16" in days_out:
                days_out["day_16"] += 1
                balance_out["day_16"] += value
            else:
                days_out["day_16"] = 1
                balance_out["day_16"] = value
        elif days < 1 * 18:
            if "day_17" in days_out:
                days_out["day_17"] += 1
                balance_out["day_17"] += value
            else:
                days_out["day_17"] = 1
                balance_out["day_17"] = value
        elif days < 1 * 19:
            if "day_18" in days_out:
                days_out["day_18"] += 1
                balance_out["day_18"] += value
            else:
                days_out["day_18"] = 1
                balance_out["day_18"] = value
        elif days < 1 * 20:
            if "day_19" in days_out:
                days_out["day_19"] += 1
                balance_out["day_19"] += value
            else:
                days_out["day_19"] = 1
                balance_out["day_19"] = value
        elif days < 1 * 21:
            if "day_20" in days_out:
                days_out["day_20"] += 1
                balance_out["day_20"] += value
            else:
                days_out["day_20"] = 1
                balance_out["day_20"] = value
        elif days < 1 * 22:
            if "day_21" in days_out:
                days_out["day_21"] += 1
                balance_out["day_21"] += value
            else:
                days_out["day_21"] = 1
                balance_out["day_21"] = value
        elif days < 1 * 23:
            if "day_22" in days_out:
                days_out["day_22"] += 1
                balance_out["day_22"] += value
            else:
                days_out["day_22"] = 1
                balance_out["day_22"] = value
        elif days < 1 * 24:
            if "day_23" in days_out:
                days_out["day_23"] += 1
                balance_out["day_23"] += value
            else:
                days_out["day_23"] = 1
                balance_out["day_23"] = value
        elif days < 1 * 25:
            if "day_24" in days_out:
                days_out["day_24"] += 1
                balance_out["day_24"] += value
            else:
                days_out["day_24"] = 1
                balance_out["day_24"] = value
        elif days < 1 * 26:
            if "day_25" in days_out:
                days_out["day_25"] += 1
                balance_out["day_25"] += value
            else:
                days_out["day_25"] = 1
                balance_out["day_25"] = value
        elif days < 1 * 27:
            if "day_26" in days_out:
                days_out["day_26"] += 1
                balance_out["day_26"] += value
            else:
                days_out["day_26"] = 1
                balance_out["day_26"] = value
        elif days < 1 * 28:
            if "day_27" in days_out:
                days_out["day_27"] += 1
                balance_out["day_27"] += value
            else:
                days_out["day_27"] = 1
                balance_out["day_27"] = value
        elif days < 1 * 29:
            if "day_28" in days_out:
                days_out["day_28"] += 1
                balance_out["day_28"] += value
            else:
                days_out["day_28"] = 1
                balance_out["day_28"] = value
        elif days < 1 * 30:
            if "day_29" in days_out:
                days_out["day_29"] += 1
                balance_out["day_29"] += value
            else:
                days_out["day_29"] = 1
                balance_out["day_29"] = value
        elif days < 1 * 31:
            if "day_30" in days_out:
                days_out["day_30"] += 1
                balance_out["day_30"] += value
            else:
                days_out["day_30"] = 1
                balance_out["day_30"] = value
        elif days < 1 * 60:
            if "day_60" in days_out:
                days_out["day_60"] += 1
                balance_out["day_60"] += value
            else:
                days_out["day_60"] = 1
                balance_out["day_60"] = value
        elif days < 1 * 90:
            if "day_90" in days_out:
                days_out["day_90"] += 1
                balance_out["day_90"] += value
            else:
                days_out["day_90"] = 1
                balance_out["day_90"] = value
        elif days < 1 * 180:
            if "day_180" in days_out:
                days_out["day_180"] += 1
                balance_out["day_180"] += value
            else:
                days_out["day_180"] = 1
                balance_out["day_180"] = value
        elif days < 1 * 360:
            if "day_360" in days_out:
                days_out["day_360"] += 1
                balance_out["day_360"] += value
            else:
                days_out["day_360"] = 1
                balance_out["day_360"] = value
        elif days < 1 * 540:
            if "day_540" in days_out:
                days_out["day_540"] += 1
                balance_out["day_540"] += value
            else:
                days_out["day_540"] = 1
                balance_out["day_540"] = value
        elif days < 1 * 720:
            if "day_720" in days_out:
                days_out["day_720"] += 1
                balance_out["day_720"] += value
            else:
                days_out["day_720"] = 1
                balance_out["day_720"] = value
        elif days < 1 * 1080:
            if "day_1080" in days_out:
                days_out["day_1080"] += 1
                balance_out["day_1080"] += value
            else:
                days_out["day_1080"] = 1
                balance_out["day_1080"] = value
        elif days < 1 * 1440:
            if "day_1440" in days_out:
                days_out["day_1440"] += 1
                balance_out["day_1440"] += value
            else:
                days_out["day_1440"] = 1
                balance_out["day_1440"] = value
        elif days < 1 * 1880:
            if "day_1880" in days_out:
                days_out["day_1880"] += 1
                balance_out["day_1880"] += value
            else:
                days_out["day_1880"] = 1
                balance_out["day_1880"] = value
        elif days < 1 * 2160:
            if "day_2160" in days_out:
                days_out["day_2160"] += 1
                balance_out["day_2160"] += value
            else:
                days_out["day_2160"] = 1
                balance_out["day_2160"] = value
        elif days < 1 * 2520:
            if "day_2520" in days_out:
                days_out["day_2520"] += 1
                balance_out["day_2520"] += value
            else:
                days_out["day_2520"] = 1
                balance_out["day_2520"] = value
        elif days < 1 * 2880:
            if "day_2880" in days_out:
                days_out["day_2880"] += 1
                balance_out["day_2880"] += value
            else:
                days_out["day_2880"] = 1
                balance_out["day_2880"] = value
        elif days < 1 * 3240:
            if "day_3240" in days_out:
                days_out["day_3240"] += 1
                balance_out["day_3240"] += value
            else:
                days_out["day_3240"] = 1
                balance_out["day_3240"] = value
        elif days < 1 * 3600:
            if "day_3600" in days_out:
                days_out["day_3600"] += 1
                balance_out["day_3600"] += value
            else:
                days_out["day_3600"] = 1
                balance_out["day_3600"] = value
        else:
            if "day_3960" in days_out:
                days_out["day_3960"] += 1
                balance_out["day_3960"] += value
            else:
                days_out["day_3960"] = 1
                balance_out["day_3960"] = value
        return days_out, balance_out
# “summary_balance_days”功能似乎旨在根据持有余额的天数对余额进行分类。以下是其工作原理的细分：
    #
    # -参数：
    # - 'dt'：当前日期。
    # - “dt2”：获取余额的日期。
    # - 'value'：余额的值。
    # - 'days_out'：用于存储不同时期余额计数的字典。
    # - 'balance_out'：存储不同时期累计余额的字典。
    #
    # - 计算天数：
    # - 它通过从当前日期 （'dt'） 中减去购置日期 （'dt2'） 来计算余额持有的天数。此值存储在“days”变量中。
    #
    # - 对余额进行分类：
    # - 根据计算的天数，该函数将余额分配给特定类别 （'day_X'），其中
    # 'X'
    # 表示天数。
    # - 如果余额持有时间少于一天，则将其归类为“day_0”。
    # - 如果余额已持有
    # 1
    # 到
    # 30
    # 天，则分别归类为“day_1”至“day_30”。
    # - 如果余额已持有
    # 31
    # 到
    # 60
    # 天，则将其归类为“day_60”。
    # - 如果余额已持有超过
    # 3600
    # 天（约
    # 10
    # 年），则将其归类为“day_3960”。
    #
    # - 累积余额：
    # - 对于每个类别，该函数递增余额计数 （'days_out'） 并将余额值添加到累计余额 （'balance_out'）。
    #
    # - 返回结果：
    # - 返回更新的“days_out”和“balance_out”字典。
    # 0.01,0.1,1,10,100,1000,10000,total balance
    # new addr, total address
    def summary_utxos(self, current_price, txid, vout, coinbase, value, height, scriptpubkey, dt, price, dt2):

        self.total_address += 1
        self.total_balance += value

        self.total_rcap += (value * price)

        if coinbase == 1:
            self.miner_address += 1
            self.miner_balance += value

        if current_price > price:
            self.uprofit +=(value*(current_price-price))
            self.profit_addresses += 1
        if current_price <= price:
            self.uloss += (value*(price - current_price))
            self.loss_addresses += 1

        n = int(price / 1000)
        n = n * 1000

        keystr = "buy" + str(n)
        if keystr in self.price_buy:
            self.price_buy[keystr] += 1
        else:
            self.price_buy[keystr] = 1

        keystr = "buy_amount" + str(n)
        if keystr in self.price_buy_amount:
            self.price_buy_amount[keystr] += value
        else:
            self.price_buy_amount[keystr] = value

        diff = current_price - price
        n = int(diff / 1000)
        n = n * 1000
        keystr = "diff" + str(n)
        if keystr in self.diff_sell:
            self.diff_sell[keystr] += 1
        else:
            self.diff_sell[keystr] = 1

        keystr = "diff_amount" + str(n)
        if keystr in self.diff_sell_amount:
            self.diff_sell_amount[keystr] += value
        else:
            self.diff_sell_amount[keystr] = value


        try:
            profit = (current_price - price)/(price)*10
        except:
            profit = current_price*10

        if int(profit) < 100:
            n = int(profit)
            keystr = "profit" + str(n)
            if keystr in self.profit_sell:
                self.profit_sell[keystr] += 1
            else:
                self.profit_sell[keystr] = 1

            keystr = "profit_amount" + str(n)
            if keystr in self.profit_sell_amount:
                self.profit_sell_amount[keystr] += value
            else:
                self.profit_sell_amount[keystr] = value
        else:
            profit = profit/100
            n = int(profit)
            keystr = "profit10" + str(n)
            if keystr in self.profit_sell:
                self.profit_sell[keystr] += 1
            else:
                self.profit_sell[keystr] = 1

            keystr = "profit_amount10" + str(n)
            if keystr in self.profit_sell_amount:
                self.profit_sell_amount[keystr] += value
            else:
                self.profit_sell_amount[keystr] = value

        if value < 0.01:
            self.balance_0 += 1
            self.balance_amount_0 += value
            self.balance_0_days, self.balance_amount_0_days = self.summary_balance_days(self.current_dayutc, dt2, value, self.balance_0_days,
                                                                         self.balance_amount_0_days)
        elif value < 0.1:
            self.balance_001 += 1
            self.balance_amount_001 += value
            self.balance_001_days, self.balance_amount_001_days = self.summary_balance_days(self.current_dayutc, dt2, value,
                                                                             self.balance_001_days,
                                                                             self.balance_amount_001_days)
        elif value < 1:
            self.balance_01 += 1
            self.balance_amount_01 += value
            self.balance_01_days, self.balance_amount_01_days = self.summary_balance_days(self.current_dayutc, dt2, value, self.balance_01_days,
                                                                           self.balance_amount_01_days)
        elif value < 10:
            self.balance_1 += 1
            self.balance_amount_1 += value
            self.balance_1_days, self.balance_amount_1_days = self.summary_balance_days(self.current_dayutc, dt2, value, self.balance_1_days,
                                                                         self.balance_amount_1_days)
        elif value < 100:
            self.balance_10 += 1
            self.balance_amount_10 += value
            self.balance_10_days, self.balance_amount_10_days = self.summary_balance_days(self.current_dayutc, dt2, value, self.balance_10_days,
                                                                           self.balance_amount_10_days)
        elif value < 1000:
            self.balance_100 += 1
            self.balance_amount_100 += value
            self.balance_100_days, self.balance_amount_100_days = self.summary_balance_days(self.current_dayutc, dt2, value,
                                                                             self.balance_100_days,
                                                                             self.balance_amount_100_days)
        elif value < 10000:
            self.balance_1000 += 1
            self.balance_amount_1000 += value
            self.balance_1000_days, self.balance_amount_1000_days = self.summary_balance_days(self.current_dayutc, dt2, value,
                                                                               self.balance_1000_days,
                                                                               self.balance_amount_1000_days)
        else:
            self.balance_10000 += 1
            self.balance_amount_10000 += value
            self.balance_10000_days, self.balance_amount_10000_days = self.summary_balance_days(self.current_dayutc, dt2, value,
                                                                                 self.balance_10000_days,
                                                                                 self.balance_amount_10000_days)

        daysecs = 3600 * 24

        if self.current_dayutc - dt2 >= 180 * daysecs:
            if self.current_dayutc - dt2 <= 365 * daysecs:
                self.slrv_6m1y += (value*price)

        if self.current_dayutc - dt2 <= daysecs:
            self.slrv_24h += (value*price)

        if self.current_dayutc - dt2 >= 155*daysecs:
            self.lth_nupl += (value*(current_price-price))
            self.lth_rcap += (value*price)
            self.lth_mv += (value*current_price)
            self.lth_supply += value
            if current_price > price:
                self.lth_profit_supply += value
            if current_price < price:
                self.lth_loss_supply += value
        else:
            self.sth_nupl += (value*(price - current_price))
            self.sth_rcap += (value * price)
            self.sth_mv += (value * current_price)
            self.sth_supply += value
            if current_price > price:
                self.sth_profit_supply += value
            if current_price < price:
                self.sth_loss_supply += value

        if self.current_dayutc - dt2 < daysecs:
            self.holder_0 += 1
            self.holder_balance_0 += value
        elif self.current_dayutc - dt2 < daysecs * 2:
            self.holder_1 += 1
            self.holder_balance_1 += value
        elif self.current_dayutc - dt2 < daysecs * 3:
            self.holder_2 += 1
            self.holder_balance_2 += value
        elif self.current_dayutc - dt2 < daysecs * 4:
            self.holder_3 += 1
            self.holder_balance_3 += value
        elif self.current_dayutc - dt2 < daysecs * 5:
            self.holder_4 += 1
            self.holder_balance_4 += value
        elif self.current_dayutc - dt2 < daysecs * 6:
            self.holder_5 += 1
            self.holder_balance_5 += value
        elif self.current_dayutc - dt2 < daysecs * 7:
            self.holder_6 += 1
            self.holder_balance_6 += value
        elif self.current_dayutc - dt2 < daysecs * 8:
            self.holder_7 += 1
            self.holder_balance_7 += value
        elif self.current_dayutc - dt2 < daysecs * 15:
            self.holder_15 += 1
            self.holder_balance_15 += value
        elif self.current_dayutc - dt2 < daysecs * 30:
            self.holder_30 += 1
            self.holder_balance_30 += value
        elif self.current_dayutc - dt2 < daysecs * 60:
            self.holder_60 += 1
            self.holder_balance_60 += value
        elif self.current_dayutc - dt2 < daysecs * 90:
            self.holder_90 += 1
            self.holder_balance_90 += value
        elif self.current_dayutc - dt2 < daysecs * 180:
            self.holder_180 += 1
            self.holder_balance_180 += value
        elif self.current_dayutc - dt2 < daysecs * 360:
            self.holder_360 += 1
            self.holder_balance_360 += value
        elif self.current_dayutc - dt2 < daysecs * 540:
            self.holder_540 += 1
            self.holder_balance_540 += value
        elif self.current_dayutc - dt2 < daysecs * 720:
            self.holder_720 += 1
            self.holder_balance_720 += value
        elif self.current_dayutc - dt2 < daysecs * 1080:
            self.holder_1080 += 1
            self.holder_balance_1080 += value
        elif self.current_dayutc - dt2 < daysecs * 1440:
            self.holder_1440 += 1
            self.holder_balance_1440 += value
        elif self.current_dayutc - dt2 < daysecs * 1880:
            self.holder_1800 += 1
            self.holder_balance_1800 += value
        elif self.current_dayutc - dt2 < daysecs * 2160:
            self.holder_2160 += 1
            self.holder_balance_2160 += value
        elif self.current_dayutc - dt2 < daysecs * 2520:
            self.holder_2520 += 1
            self.holder_balance_2520 += value
        elif self.current_dayutc - dt2 < daysecs * 2880:
            self.holder_2880 += 1
            self.holder_balance_2880 += value
        elif self.current_dayutc - dt2 < daysecs * 3240:
            self.holder_3240 += 1
            self.holder_balance_3240 += value
        elif self.current_dayutc - dt2 < daysecs * 3600:
            self.holder_3600 += 1
            self.holder_balance_3600 += value
        else:
            self.holder_3960 += 1
            self.holder_balance_3960 += value
# “summary_utxos”功能似乎是用于分析交易及其相关余额的更大系统的一部分。以下是该函数的功能细分：
    #
    # - ** 更新计数器和总计： **
    # - 'self.total_address'：递增
    # 1
    # 以计算地址总数。
    # - “self.total_balance”：累积总余额。
    # - 'self.total_rcap'：累计已实现的总资本化（余额 * 价格）。
    # - “self.miner_address”和“self.miner_balance”：如果交易是
    # coinbase
    # 交易（“coinbase == 1”），则增加矿工地址计数并累积矿工余额。
    #
    # - ** 盈亏计算： **
    # - 'self.uprofit'
    # 和
    # 'self.uloss'：如果当前价格分别高于或低于成交价格，则计算并累计未实现损益。
    # - “self.profit_addresses”和“self.loss_addresses”：统计有未实现盈亏的地址。
    #
    # - ** 价格分析： **
    # - 'n'：将价格四舍五入到最接近的千位。
    # - 'keystr'：根据四舍五入的价格生成密钥。
    # - 更新买入价格（“self.price_buy”）及其相应金额（“self.price_buy_amount”）的计数器。
    # - 计算当前价格和交易价格之间的差额 （'diff'），将其四舍五入到最接近的千位，并更新价格差异计数器（'self.diff_sell'
    # 和
    # 'self.diff_sell_amount'）。
    #
    # - ** 利润百分比分析： **
    # - 根据当前价格和交易价格之间的差额计算利润百分比（“利润”）。
    # - 将利润分类为不同的范围，并相应地更新计数器（“self.profit_sell”和“self.profit_sell_amount”）。
    #
    # - ** 余额分类： **
    # - 根据余额的值将余额分类为不同的范围，并相应地更新计数器。
    # - 对于每个范围，更新地址计数 （'self.balance_X'） 和累计余额 （'self.balance_amount_X'） 的计数器。
    #
    # - ** 基于时间的分析： **
    # - 分析余额被持有的时间（“self.summary_balance_days”）并相应地更新计数器。
    #
    # - ** 其他指标： **
    # - 根据余额持有的时间长度更新各种指标，例如短期和长期已实现资本化、市场价值、供应、利润和损失。
    #
    # - ** 持有人分析： **
    # - 根据持有余额的时间对持有人进行分类，并更新相应的计数器，以显示持有人的数量及其累计余额。
    #
    # 总体而言，此功能似乎提供了对交易数据的全面分析，包括与余额、价格、利润和持有人行为相关的各种指标。
    def save_db(self):
        db_conn = self.init_db()
        with db_conn.cursor() as cursor:

            sql_insert = 'REPLACE INTO `utxosv3` (`unixdt`, `total_address`, `total_balance`, `total_rcap`, `miner_address`,`miner_balance`, `balance_0`, `balance_001`, `balance_01`, `balance_1`, `balance_10`,`balance_100`, `balance_1000`, `balance_10000`, uprofit, uloss, lthnupl, sthnupl, lthmarketcap, lthrcap, sthmarketcap, sthrcap, lthmvrv, sthmvrv) VALUES (FROM_UNIXTIME(%s), %s, %s, %s, %s, %s,%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)'
            cursor.execute(sql_insert, (
                self.current_dayutc, self.total_address, self.total_balance, self.total_rcap, self.miner_address, self.miner_balance, self.balance_0,
                self.balance_001,
                self.balance_01, self.balance_1, self.balance_10, self.balance_100, self.balance_1000, self.balance_10000, self.uprofit, self.uloss, self.lth_nupl, self.sth_nupl, self.lth_mv, self.lth_rcap, self.sth_mv, self.sth_rcap, self.lth_mvrv, self.sth_mvrv))
            sql_insert = 'REPLACE INTO `utxos3nd` (`unixdt`, `balance_amount_0`, `balance_amount_001`, `balance_amount_01`, `balance_amount_1`, `balance_amount_10`,`balance_amount_100`, `balance_amount_1000`, `balance_amount_10000`) VALUES (FROM_UNIXTIME(%s), %s, %s, %s, %s, %s,%s, %s, %s)'
            cursor.execute(sql_insert, (
                self.current_dayutc, self.balance_amount_0,
                self.balance_amount_001,
                self.balance_amount_01, self.balance_amount_1, self.balance_amount_10, self.balance_amount_100, self.balance_amount_1000,
                self.balance_amount_10000))
            sql_insert = 'REPLACE INTO `holder3` (`unixdt`,`holder_0`,`holder_1`,`holder_2`,`holder_3`,`holder_4`,`holder_5`,`holder_6`,`holder_7`,`holder_15`,`holder_30`,`holder_60`,`holder_90`,`holder_180`,`holder_360`,`holder_540`,`holder_720`,`holder_1080`,`holder_1440`,`holder_1800`,`holder_2160`,`holder_2520`,`holder_2880`,`holder_3240`,`holder_3600`,`holder_3960`) VALUES(FROM_UNIXTIME(%s), %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)'
            cursor.execute(sql_insert, (
                self.current_dayutc, self.holder_0, self.holder_1, self.holder_2, self.holder_3, self.holder_4, self.holder_5, self.holder_6, self.holder_7,
                self.holder_15,
                self.holder_30, self.holder_60, self.holder_90, self.holder_180, self.holder_360, self.holder_540, self.holder_720, self.holder_1080,
                self.holder_1440,
                self.holder_1800, self.holder_2160, self.holder_2520, self.holder_2880, self.holder_3240, self.holder_3600, self.holder_3960))
            sql_insert = 'REPLACE INTO `holder_balance3` (`unixdt`,`holder_balance_0`,`holder_balance_1`,`holder_balance_2`,`holder_balance_3`,`holder_balance_4`,`holder_balance_5`,`holder_balance_6`,`holder_balance_7`,`holder_balance_15`,`holder_balance_30`,`holder_balance_60`,`holder_balance_90`,`holder_balance_180`,`holder_balance_360`,`holder_balance_540`,`holder_balance_720`,`holder_balance_1080`,`holder_balance_1440`,`holder_balance_1800`,`holder_balance_2160`,`holder_balance_2520`,`holder_balance_2880`,`holder_balance_3240`,`holder_balance_3600`,`holder_balance_3960`) VALUES(FROM_UNIXTIME(%s), %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)'
            cursor.execute(sql_insert, (
                self.current_dayutc, self.holder_balance_0, self.holder_balance_1, self.holder_balance_2, self.holder_balance_3,
                self.holder_balance_4,
                self.holder_balance_5, self.holder_balance_6, self.holder_balance_7, self.holder_balance_15,
                self.holder_balance_30, self.holder_balance_60, self.holder_balance_90, self.holder_balance_180, self.holder_balance_360,
                self.holder_balance_540, self.holder_balance_720, self.holder_balance_1080, self.holder_balance_1440,
                self.holder_balance_1800, self.holder_balance_2160, self.holder_balance_2520, self.holder_balance_2880, self.holder_balance_3240,
                self.holder_balance_3600, self.holder_balance_3960))


            #v2
            if self.loss_addresses > 0:
                self.profit_ratio = self.profit_addresses/self.loss_addresses
            if self.total_balance > 0:
                self.realized_price = self.total_rcap/self.total_balance
            if self.sth_loss_supply > 0:
                self.sth_profit_ratio = self.sth_profit_supply/self.sth_loss_supply
            if self.lth_loss_supply > 0:
                self.lth_profit_ratio = self.lth_profit_supply / self.lth_loss_supply
            if self.sth_profit_ratio > 0:
                self.relative_lth_sth = self.lth_profit_ratio/self.sth_profit_ratio
            if self.slrv_6m1y > 0:
                self.slrv_ratio = self.slrv_24h/self.slrv_6m1y

            sql_insert = 'REPLACE INTO `utxosv4` (`unixdt`,`profit_addresses`,`loss_addresses`,`profit_ratio`,`lth_supply`,`sth_supply`,`realized_price`,`relative_lth_sth`,`lth_profit_supply`,`lth_loss_supply`,`lth_profit_ratio`,`sth_profit_supply`,`sth_loss_supply`,`sth_profit_ratio`,`slrv_ratio`) VALUES(FROM_UNIXTIME(%s), %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)'
            cursor.execute(sql_insert, (self.current_dayutc, self.profit_addresses, self.loss_addresses, self.profit_ratio, self.lth_supply, self.sth_supply, self.realized_price, self.relative_lth_sth, self.lth_profit_supply, self.lth_loss_supply, self.lth_profit_ratio, self.sth_profit_supply, self.sth_loss_supply, self.sth_profit_ratio, self.slrv_ratio))
            db_conn.commit()


        mc = pymongo.MongoClient("mongodb://10.168.3.192:27018/")
        mdb = mc["btcutxos2"]
        # mdb.authenticate("root", "123456")

        self.price_buy["unixdt"] = int(self.current_dt)
        mdbc_buy = mdb["buy"]
        mdbc_buy.insert_one(self.price_buy)
        print(mdbc_buy.find_one())
        self.price_buy_amount["unixdt"] = int(self.current_dt)
        mdbc_buy_amount = mdb["buy_amount"]
        mdbc_buy_amount.insert_one(self.price_buy_amount)
        print(mdbc_buy_amount.find_one())

        self.diff_sell["unixdt"] = int(self.current_dt)
        mdbc_diff = mdb["diff"]
        mdbc_diff.insert_one(self.diff_sell)
        print(mdbc_diff.find_one())
        self.diff_sell_amount["unixdt"] = int(self.current_dt)
        mdbc_diff_amount = mdb["diff_amount"]
        mdbc_diff_amount.insert_one(self.diff_sell_amount)
        print(mdbc_diff_amount.find_one())

        self.profit_sell["unixdt"] = int(self.current_dt)
        mdbc_profit = mdb["profit"]
        mdbc_profit.insert_one(self.profit_sell)
        print(mdbc_profit.find_one())
        self.profit_sell_amount["unixdt"] = int(self.current_dt)
        mdbc_profit_amount = mdb["profit_amount"]
        mdbc_profit_amount.insert_one(self.profit_sell_amount)
        print(mdbc_profit_amount.find_one())

        self.balance_0_days["unixdt"] = int(self.current_dt)
        mdbc_balance_days = mdb["balance_0_days"]
        mdbc_balance_days.insert_one(self.balance_0_days)
        print(mdbc_balance_days.find_one())
        self.balance_amount_0_days["unixdt"] = int(self.current_dt)
        mdbc_balance_amount_days = mdb["balance_amount_0_days"]
        mdbc_balance_amount_days.insert_one(self.balance_amount_0_days)
        print(mdbc_balance_amount_days.find_one())

        self.balance_001_days["unixdt"] = int(self.current_dt)
        mdbc_balance_days = mdb["balance_001_days"]
        mdbc_balance_days.insert_one(self.balance_001_days)
        print(mdbc_balance_days.find_one())
        self.balance_amount_001_days["unixdt"] = int(self.current_dt)
        mdbc_balance_amount_days = mdb["balance_amount_001_days"]
        mdbc_balance_amount_days.insert_one(self.balance_amount_001_days)
        print(mdbc_balance_amount_days.find_one())

        self.balance_01_days["unixdt"] = int(self.current_dt)
        mdbc_balance_days = mdb["balance_01_days"]
        mdbc_balance_days.insert_one(self.balance_01_days)
        print(mdbc_balance_days.find_one())
        self.balance_amount_01_days["unixdt"] = int(self.current_dt)
        mdbc_balance_amount_days = mdb["balance_amount_01_days"]
        mdbc_balance_amount_days.insert_one(self.balance_amount_01_days)
        print(mdbc_balance_amount_days.find_one())

        self.balance_1_days["unixdt"] = int(self.current_dt)
        mdbc_balance_days = mdb["balance_1_days"]
        mdbc_balance_days.insert_one(self.balance_1_days)
        print(mdbc_balance_days.find_one())
        self.balance_amount_1_days["unixdt"] = int(self.current_dt)
        mdbc_balance_amount_days = mdb["balance_amount_1_days"]
        mdbc_balance_amount_days.insert_one(self.balance_amount_1_days)
        print(mdbc_balance_amount_days.find_one())

        self.balance_10_days["unixdt"] = int(self.current_dt)
        mdbc_balance_days = mdb["balance_10_days"]
        mdbc_balance_days.insert_one(self.balance_10_days)
        print(mdbc_balance_days.find_one())
        self.balance_amount_10_days["unixdt"] = int(self.current_dt)
        mdbc_balance_amount_days = mdb["balance_amount_10_days"]
        mdbc_balance_amount_days.insert_one(self.balance_amount_10_days)
        print(mdbc_balance_amount_days.find_one())

        self.balance_100_days["unixdt"] = int(self.current_dt)
        mdbc_balance_days = mdb["balance_100_days"]
        mdbc_balance_days.insert_one(self.balance_100_days)
        print(mdbc_balance_days.find_one())
        self.balance_amount_100_days["unixdt"] = int(self.current_dt)
        mdbc_balance_amount_days = mdb["balance_amount_100_days"]
        mdbc_balance_amount_days.insert_one(self.balance_amount_100_days)
        print(mdbc_balance_amount_days.find_one())

        self.balance_1000_days["unixdt"] = int(self.current_dt)
        mdbc_balance_days = mdb["balance_1000_days"]
        mdbc_balance_days.insert_one(self.balance_1000_days)
        print(mdbc_balance_days.find_one())
        self.balance_amount_1000_days["unixdt"] = int(self.current_dt)
        mdbc_balance_amount_days = mdb["balance_amount_1000_days"]
        mdbc_balance_amount_days.insert_one(self.balance_amount_1000_days)
        print(mdbc_balance_amount_days.find_one())

        self.balance_10000_days["unixdt"] = int(self.current_dt)
        mdbc_balance_days = mdb["balance_10000_days"]
        mdbc_balance_days.insert_one(self.balance_10000_days)
        print(mdbc_balance_days.find_one())
        self.balance_amount_10000_days["unixdt"] = int(self.current_dt)
        mdbc_balance_amount_days = mdb["balance_amount_10000_days"]
        mdbc_balance_amount_days.insert_one(self.balance_amount_10000_days)
        print(mdbc_balance_amount_days.find_one())
# “save_db”方法负责将分析期间收集的数据保存到数据库和MongoDB实例中。以下是它的作用的细分：
    # - MySQL数据库： **
    # - 使用'init_db'方法连接到MySQL数据库。
    # - 使用SQL查询将记录插入或替换到多个表（'utxosv1'、'utxos2nd'、'holder'、'holder_balance'和'utxosv2'）中。这些表包含用于分析的各种指标和汇总数据。
    # - ** MongoDB： **
    # - 连接到MongoDB实例。
    # - 将数据插入多个集合（'buy'、'buy_amount'、'diff'、'diff_amount'、'profit'、'profit_amount'、'balance_0_days'、'balance_amount_0_days'
    # 等）中，以进行不同类型的分析。
    # 对于MongoDB中的每个集合，该方法将数据插入到集合中，并打印插入的文档以进行验证。
    # 此外，该方法还会计算和更新一些其他指标（如利润率、实现价格、短期和长期持有者的利润率、相对比率等），并将它们插入“utxosv2”表中。
    # 总体而言，这种方法有助于将分析的数据存储到关系数据库 （MySQL） 和NoSQL数据库 （MongoDB） 中，从而便于检索和进一步分析。
    def get_history_price(self, batch_size=5000):
        """获取数据库中的 Nasdaq 数据，存入字典"""
        db_config = {
            "host": "192.168.194.240",
            "user": "root",
            "password": "2GS@bPYcgiMyL14A",
            "database": "btcdb",
            "port": 4423,
            "connect_timeout": 60,
            "read_timeout": 60,
            "write_timeout": 60,
            "charset": "utf8mb4"
        }

        offset = 0
        self.pricedict = {}

        while True:
            connection = pymysql.connect(**db_config)
            try:
                with connection.cursor() as cursor:
                    sql = "SELECT timestamp, price FROM btc_prices WHERE source = 'Nasdaq' ORDER BY timestamp LIMIT %s OFFSET %s"
                    cursor.execute(sql, (batch_size, offset))
                    rows = cursor.fetchall()
                    if not rows:
                        break
                    for timestamp, price in rows:
                        self.pricedict[str(int(timestamp))] = float(price)
            finally:
                connection.close()

            offset += batch_size
            if len(rows) < batch_size:
                break  # 最后一页读取完成

        return self.pricedict
        #prices = {}
        #response_price = requests.get(
        #    'https://data.nasdaq.com/api/v3/datatables/QDL/BCHAIN?code=MKPRU;api_key=FZqXog4sR-b7cYnXcRVV')
        #if response_price.status_code == 200:
        #    #print(response_price.content)
        #    priceweb = ujson.loads(response_price.content)
        #    if "datatable" in priceweb:
        #        priceset = priceweb["datatable"]
        #        if "data" in priceset:
        #            pricedata = priceset["data"]
        #            for price in pricedata:
        #                daystr = price[1]
        #                p = price[2]
        #                dayutc = time.mktime(time.strptime(daystr, "%Y-%m-%d"))
        #                prices[str(int(dayutc))] = float(p)
        #                #print(price, int(dayutc), g_prices[str(int(dayutc))])
        #return prices
# “get_history_price”方法似乎用于从WebAPI终结点检索历史价格数据。以下是它的作用的细分：
    # - 初始化一个空字典“prices”来存储历史价格数据。
    # - 向指定的API端点发送HTTP GET请求，该端点可能提供历史比特币价格数据。
    # - 检查响应状态代码是否为200（表示响应成功）。
    # - 如果响应成功：
    # - 使用“ujson”库解析JSON响应。
    # - 检查解析的JSON响应中是否存在键'“dataset''。
    # - 如果'“dataset”'存在：
    # - 检索“data”' 字段，该字段可能包含历史价格数据点的列表。
    # - 遍历列表中的每个价格数据点。
    # - 使用'strptime'将日期字符串 （'daystr'） 解析为Unix时间戳 （'dayutc'）。
    # - 将Unix 时间戳作为键存储在“prices”字典中，并将相应的price （'p'） 作为值。
    # 最后，它返回包含历史价格数据的“prices”字典，其中Unix时间戳作为键，价格作为值
    def get_history_price2(self, batch_size=5000):
        #pricedict = {}
        """获取数据库中的 Messari 数据，存入字典"""
        db_config = {
            "host": "192.168.194.240",
            "user": "root",
            "password": "2GS@bPYcgiMyL14A",
            "database": "btcdb",
            "port": 4423,
            "connect_timeout": 60,
            "read_timeout": 60,
            "write_timeout": 60,
            "charset": "utf8mb4"
        }

        offset = 0
        self.pricedict = {}

        while True:
            connection = pymysql.connect(**db_config)
            try:
                with connection.cursor() as cursor:
                    sql = """
                                    SELECT timestamp, price
                                    FROM btc_prices
                                    WHERE source = 'CryptoCompare'
                                    ORDER BY timestamp
                                    LIMIT %s OFFSET %s
                                """
                    cursor.execute(sql, (batch_size, offset))
                    rows = cursor.fetchall()
                    if not rows:
                        break
                    for timestamp, price in rows:
                        self.pricedict[str(int(timestamp))] = float(price)
            finally:
                connection.close()

            offset += batch_size
            if len(rows) < batch_size:
                break  # 数据已全部读取

        return self.pricedict
        #dayt = time.gmtime()
        #daystr = time.strftime("%Y", dayt)
        #year = int(daystr)
        #end_year = year
        #while True:
        #    url = ""
        #    if end_year != year:
        #        start_year = end_year
        #        url = "https://data.messari.io/api/v1/assets/bitcoin/metrics/price/time-series?start="
        #    else:
        #        url = "https://data.messari.io/api/v1/assets/bitcoin/metrics/price/time-series?after=" + str(
        #            year) + "-01-01&order=descending&interval=1d"
#
#            if end_year != year:
#                url = url + str(start_year) + "-01-01&end=" + str(end_year) + "-12-31&order=descending&interval=1d"
#            header_set = {}
#            header_set["x-messari-api-key"] = "aH2pyj5i4QGo1k1gLxXEbIJ5RJr+FYKLEWk6cRT6RuSc6lRY"
#            # header_set["Content-Type"] = "application/json"
#            print(header_set, url)
#            response_price = requests.get(url, headers=header_set)
#            # print(response_price)
#            if response_price.status_code == 200:
#                # print(response_price.content)
#                priceweb = ujson.loads(response_price.content)
#                if "data" in priceweb:
#                    priceset = priceweb["data"]
#                    if "values" in priceset:
#                        valueset = priceset["values"]
#                        if valueset is not None:
#                            for supply in valueset:
#                                dayutc = int(supply[0] / 1000)
#                                s = supply[1]
#                                ret_time = time.gmtime(dayutc)
#                                ret_daystr = time.strftime("%d %b %Y", ret_time)
#                                ret_dayutc = int(time.mktime(time.strptime(ret_daystr, "%d %b %Y")))
#                                pricedict[str(ret_dayutc)] = float(s)
#                                # print(s, dayutc, pricedict[str(dayutc)])
#                                # break
#                        else:
#                            break
#            else:
#                break
#            end_year -= 1
#            time.sleep(2)
#        print(pricedict)
#        return pricedict
# 'get_history
    # 初始化与时间相关的变量，包括当前年份。
    # 进入一个循环，从当前年份开始，向后循环访问年份。
    # 根据当前年份和端点构造一个URL，用于获取比特币价格数据。
    # 向构造的URL发送HTTP
    # GET请求，包括标头中的特定API密钥。
    # 检查响应状态代码是否为
    # 2
    # 使用'u 解析 JSON 响应
    # 从JSON响应中提取相关价格数据，并将其添加到“pricedict”
    # 将时间戳转换为人类可读的日期字符串，然后转换回Unix时间戳，并将它们作为键存储在'pricedic 中
    # 在发出下一个请求之前暂停执行2秒，以避免API过载。
    # 继续此过程，直到遍历所有年份或发生错误。
    # 最后，它返回“pricedict”
    def get_current_price(self):
        price = 0
        DB_CONFIG = {
            "host": "192.168.194.240",
            "user": "root",
            "password": "2GS@bPYcgiMyL14A",
            "database": "btcdb",
            "port": 4423
        }
        connection = pymysql.connect(**DB_CONFIG)
        try:
            with connection.cursor() as cursor:
                for source in ("binance", "coinbase"):
                    cursor.execute("""
                                            SELECT price FROM btc_realtime_prices
                                            WHERE source=%s
                                            ORDER BY timestamp DESC
                                            LIMIT 1
                                        """, (source,))
                    row = cursor.fetchone()
                    if row:
                        price = float(row[0])
                        break
        finally:
            connection.close()
        return price
        #price = 0
        #try:
        #    response_price = requests.get(
        #        'https://api.binance.com/api/v3/ticker/price?symbol=BTCUSDT')
        #    prices = ujson.loads(response_price.text)
        #    price = float(prices["price"])
        #    print(response_price.text, price)
        #    response_price.close()
        #    # print("price", price)
        #    return price
        #except:
        #    response_price = requests.get("https://api.coinpaprika.com/v1/tickers/btc-bitcoin")
        #    prices = ujson.loads(response_price.text)
        #    price = float(prices["quotes"]["USD"]["price"])
        #    response_price.close()
        #    return price
# 该函数似乎是一种从特定
    # API端点检索比特币当前价格的方法。以下是其功能的细分：get_current_price
    # 初始化默认值为0的变量。price
    # 向指定的URL （） 发送HTTP
    # GET请求，以获取当前以美元为单位的比特币价格。'https://bitcoinexplorer.org/api/price/usd'
    # 检查响应状态代码是否为200，表示响应成功。
    # 如果响应成功，它将打印响应文本（大概是当前价格），并在删除逗号并将其转换为浮点数后将其分配给变量。price
    # 关闭响应对象。
    # 打印检索到的价格以进行调试。
    # 返回检索到的价格。
    # 此函数实质上是从指定的API端点检索和处理当前比特币价格，并将其作为浮点数返回
    def get_ht(self):
        try:
            with open('height_time.csv', mode='r') as f:
                reader = csv.reader(f)
                height_time = {rows[0]: rows[1] for rows in reader}
                '''for key in height_time.keys():
                    print(key, height_time[key])
                    break'''
                return height_time
            return None
        except:
            return None
# 这get_ht函数似乎从名为“height_time.csv”
    # 的CSV文件中读取数据并将其转换为字典，其中键取自第一列，值取自第二列。以下是其功能的细分：
    # 尝试在读取模式下打开文件“height_time.csv”
    # 初始化名为“height”的字典
    # 使用“csv.reade”循环访问CSV文件中的每一行
    # 构造一个字典，其中每个键值对对应于CSV文件中的一行，键取自第一列，值取自第二列。
    # 返回“height_time
    # 如果在文件读取或字典构造过程中发生异常，该函数将返回“无”
    # 此函数实质上是从CSV文件中读取数据并将其作为字典返回，该字典可能在代码中的其他位置用于进一步处理或分析
    def get_day_utc(self, utc_time):
        t = time.gmtime(utc_time)
        daystr = time.strftime("%d %b %Y", t)
        dayutc = int(time.mktime(time.strptime(daystr, "%d %b %Y")))
        return dayutc
# 该函数将
    # UTC时间戳作为输入，并返回表示与该输入时间戳对应的一天 （00：00：00UTC） 开始的
    # UTC时间戳。以下是其功能的细分：get_day_utc
    # 它接收UTC时间戳作为输入。utc_time
    # 它使用将UTC时间戳转换为时间元组。此元组表示UTC中的时间。time.gmtime()
    # 它将时间元组格式化为一个字符串，以“DD Mon YYYY”
    # （例如，“2022年1月1日”）表示日期。
    # 它使用和将此格式化的字符串转换回UTC时间戳。这有效地将时间设置为同一天的
    # 00：00：00UTC。time.strptime()
    # time.mktime()
    # 它返回表示一天开始的UTC时间戳。
    # 总体而言，此函数可用于将任何UTC时间戳转换为UTC中相应日期的开始
    def get_dh_height(self):
        try:
            with open('daily_height.csv', mode='r') as f:
                reader = csv.reader(f)
                daily_height = {rows[0]: rows[1] for rows in reader}
                return daily_height
            return None
        except:
            print("failed open daily_height.csv")
            return None
# 该函数尝试从名为“daily_height.csv”的CSV
    # 文件中读取数据，并将其转换为字典，其中键是日期，值是相应的高度。get_dh_height
    # 其工作原理如下：
    # 它尝试在读取模式下打开文件“daily_height.csv”。
    # 如果文件已成功打开，它将使用函数读取其内容，该函数将返回
    # CSV文件各行的可迭代对象。csv.reader()
    # 然后，它将每行转换为键值对，其中第一列（索引0）表示日期，第二列（索引1）表示高度。这是使用字典理解来完成的。
    # 返回生成的字典。daily_height
    # 如果在此过程中发生任何错误（例如无法打开文件），它会打印一条消息指示失败并返回.
    # None
    # 此函数可用于从CSV文件中检索每日身高数据，以便在程序中进行进一步处理或分析
    def get_dh_hash(self):
        try:
            with open('daily_height.csv', mode='r') as f:
                reader = csv.reader(f)
                daily_hash = {rows[0]: rows[2] for rows in reader}
                return daily_hash
            return None
        except:
            print("failed open daily_height.csv")
            return None
# 该函数类似于 ，但它不是检索高度值，而是从同一个CSV
    # 文件 “daily_height.csv” 中检索哈希值。get_dh_hashget_dh_height
    # 以下是其工作原理的细分：
    # 它尝试在读取模式下打开文件“daily_height.csv”。
    # 如果文件已成功打开，它将使用函数读取其内容，该函数将返回
    # CSV文件各行的可迭代对象。csv.reader()
    # 然后，它将每行转换为键值对，其中第一列（索引0）表示日期，第三列（索引2）表示哈希值。这是使用字典理解来完成的。
    # 返回生成的字典。daily_hash
    # 如果在此过程中发生任何错误（例如无法打开文件），它会打印一条消息指示失败并返回.
    # None与
    # 一样，此函数可用于从CSV文件中检索每日哈希数据，以便在程序中进一步处理或分析。get_dh_height
    def get_daily_height(self):
        height = 1
        last_dayutc = None
        daily_height = self.get_dh_height()
        daily_hash = self.get_dh_hash()
        #print(daily_height)
        #print(daily_hash)
        if daily_height is None:
            daily_height = {}
            daily_hash = {}
        else:
            if len(daily_height) > 0:
                item = daily_height.popitem()
                #print(item, type(item[1]))
                height = int(item[1])+1
                daily_height[item[0]] = int(item[1])

        ip = "127.0.0.1"
        port = "8332"
        user = "user"
        password = "password"

        rpc = RPC(ip, port, user, password)
#        total_height = rpc.blockchain.get_block_count()
        while True:
            try:
                total_height = rpc.blockchain.get_block_count()
                break
            except Exception as e:
                print("rpctimeout")
                time.sleep(10)
                rpc = RPC(ip, port, user, password)
        if height >= total_height:
            return
        prev_height = None
        prev_hash = None
        while True:
            blockh = None
            while True:
                try:
                    blockh = rpc.blockchain.get_block_header(height, True)
                    #print(blockh)
                    break
                except:
                    time.sleep(1)
                    #print("reconnect")
                    rpc = RPC(ip, port, user, password)

            if blockh is not None:
                block_time = blockh["time"]
                block_height = blockh["height"]
                block_hash = blockh["hash"]
                dayutc = self.get_day_utc(block_time)
                if last_dayutc is None:
                    last_dayutc = dayutc
                print(dayutc, last_dayutc)
                if dayutc != last_dayutc:
                    daily_height[str(last_dayutc)] = prev_height
                    daily_hash[str(last_dayutc)] = prev_hash
                    last_dayutc = dayutc
                    #print(dayutc, daily_height[str(dayutc)], daily_hash[str(dayutc)])
                prev_height = block_height
                prev_hash = block_hash
            while True:
                try:
                    total_height = rpc.blockchain.get_block_count()
                    if height == total_height:
                        break
                    else:
                        height += 1
                        print("next height " + str(height))
                        break
                except:
                    time.sleep(1)
                    #print("reconnect")
                    rpc = RPC(ip, port, user, password)

            if height == total_height:
                break

        with open('daily_height.csv', 'w') as f:
            for key in daily_height.keys():
                #print(key)
                #print(daily_height[key])
                #print(daily_hash[key])
                f.write("%s, %s, %s\n" % (key, daily_height[key], daily_hash[key]))
            f.close()
# 该函数负责从区块链中检索每日身高数据并将其存储在名为“daily_height.csv”的CSV文件中。其工作原理如下：
    # get_daily_height
    # 它使用默认值1初始化变量，并将其设置为 。heightlast_dayutcNone
    # 它调用
    # 和
    # 函数以从CSV文件中检索任何现有的每日高度和哈希数据。如果数据不可用，它将初始化空字典。get_dh_heightget_dh_hash
    # 如果存在现有的每日身高数据，它将检索最后一个条目，将身高递增1，并使用新的身高值更新字典。
    # 它设置了与比特币区块链交互的RPC连接细节。
    # 它使用RPC调用检索区块链的总高度。rpc.blockchain.get_block_count()
    # 它进入一个循环来获取每个区块高度的区块头，直到达到区块链的总高度。
    # 在循环中，如果RPC调用期间出现异常，它会尝试重新连接，从而处理网络问题。
    # 对于成功获取的每个区块标头，它都会提取区块时间、高度、哈希值和UTC日。
    # 如果UTC日发生更改，它会使用当天以前的高度和哈希值更新每日高度和哈希字典。
    # 它将每日高度和哈希数据写入“daily_height.csv”文件。
    # 一旦它处理了所有区块高度，直到区块链的总高度，该函数就会结束。
    # 该功能使用最新的区块链信息有效地更新CSV文件中的每日高度和哈希数据，方便历史数据分析或程序内的其他目的。
    def get_height_timestamp(self):
        height = 0
        height_time = self.get_ht()
        if height_time is None:
            height_time = {}
        else:
            height = len(height_time)

        print("exist height", height)

        ip = "127.0.0.1"
        port = "8332"
        user = "user"
        password = "password"

        rpc = RPC(ip, port, user, password)
#        total_height = rpc.blockchain.get_block_count()
        while True:
            try:
                total_height = rpc.blockchain.get_block_count()
                break
            except Exception as e:
                print("rpctimeout")
                time.sleep(10)
                rpc = RPC(ip, port, user, password)
        if height >= total_height:
            return
        #total_height = rpc.blockchain.get_block_count()
        # print("last_height", total_height)

        while True:
            blockh = None
            while True:
                try:
                    blockh = rpc.blockchain.get_block_header(height, True)
                    #print(blockh)
                    break
                except:
                    time.sleep(1)
                    print("reconnect")
                    rpc = RPC(ip, port, user, password)

            if blockh is not None:
                block_time = blockh["time"]
                block_height = blockh["height"]
                height_time[str(block_height)] = block_time
                #print(str(block_height), height_time[str(block_height)])

            while True:
                try:
                    total_height = rpc.blockchain.get_block_count()
                    if height == total_height:
                        break
                    else:
                        height += 1
                        print("next height " + str(height))
                        break
                except:
                    time.sleep(1)
                    #print("reconnect")
                    rpc = RPC(ip, port, user, password)

            if height == total_height:
                break

        with open('height_time.csv', 'w') as f:
            for key in height_time.keys():
                f.write("%s, %s\n" % (key, height_time[key]))
            f.close()
# 该函数从区块链中检索区块高度和相应的时间戳，并将它们存储在名为“height_time.csv”的CSV文件中。以下是其工作原理的细分：
    # get_height_timestamp
    # 它将变量初始化为0，并使用该函数检索现有的高度时间数据。如果不存在任何数据，则初始化一个空字典。heightget_ht
    # 它设置了与比特币区块链交互的RPC连接细节。
    # 它使用RPC调用检索区块链的总高度。rpc.blockchain.get_block_count()
    # 如果存在现有的高度时间数据，则将变量设置为字典中的条目数。height
    # 它进入一个循环来获取每个区块高度的区块头，直到达到区块链的总高度。
    # 在循环中，如果RPC调用期间出现异常，它会尝试重新连接，从而处理网络问题。
    # 对于每个成功获取的块头，它都会提取块时间和高度，并更新高度时间字典。
    # 它将高度时间数据写入“height_time.csv”文件。
    # 循环一直持续到它处理完所有区块高度，直到区块链的总高度。
    # 该功能有效地将CSV文件中的高度时间数据更新为最新的区块链信息，方便程序内的历史数据分析或其他目的。
    def handle_utxos(self, prices, ht, check_dayutc):
        current_price = 0
        #current_price = self.get_current_price()
        #if current_price == 0:
        #    return
        print("handle_utxos initiate")
        connin = sqlite3.connect("utxos.sqlite")
        cin = connin.cursor()
        cursorin = cin.execute("SELECT * from utxos")

        #connout = sqlite3.connect("utxos.db")
        #cout = connout.cursor()
        #cout.execute('CREATE TABLE IF NOT EXISTS utxos(txid TEXT PRIMARY KEY NOT NULL, vout INT, value INT, coinbase INT, height INT, scriptpubkey TEXT, dt TIMESTAMP, price INT, dt2 TIMESTAMP)')
        #connout.commit()
        coin_idx = 0
        rpc = None
        for row in cursorin:
            #print(row)
            txid = row[0]
            vout = row[1]
            value = row[2]
            coinbase = row[3]
            height = row[4]
            scriptpubkey = row[5]
            dt = ht[str(height)]
            #print(dt)
            dt2 = time.gmtime(int(dt))
            daystr = time.strftime("%d %b %Y", dt2)
            dayutc = int(time.mktime(time.strptime(daystr, "%d %b %Y")))
            price = 0
            d_t = datetime.utcfromtimestamp(dayutc) + timedelta(hours=8)
            d_t08am = datetime(d_t.year, d_t.month, d_t.day, 8, 0, 0)
            dayutc=int((d_t08am - timedelta(hours=8)).timestamp())-28800 
            d_t2 = datetime.utcfromtimestamp(check_dayutc) + timedelta(hours=8)
            d_t208am = datetime(d_t2.year, d_t2.month, d_t2.day, 8, 0, 0)
            check_dayutc=int((d_t208am - timedelta(hours=8)).timestamp())-28800
            print("ceshi",5)
            if str(dayutc) in prices:
                price = int(prices[str(dayutc)])
            else:
                print("failed get tx price")
                return

            if str(check_dayutc) in prices:
                current_price = int(prices[str(check_dayutc)])
            else:
                print("failed get check price")
                return

            value = value / 100000000
            #print(self.current_dayutc, txid, value, coinbase, height, daystr, dayutc, price, current_price)

            self.summary_utxos(current_price, txid, vout, coinbase, value, height, scriptpubkey, dt, price, dayutc)
            self.summary_toplist(txid, vout, coinbase, value, height, scriptpubkey, dt, price, dayutc)

            #sql_insert = 'INSERT INTO utxos VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)'
            #insert_data = (txid, vout, value, coinbase, height, scriptpubkey, dt, price, dayutc)
            #cout.execute(sql_insert, insert_data)
            #if coin_idx % (1024 * 1024) == 0:
                #print(coin_idx)
                #connout.commit()
            coin_idx+=1
        #connout.commit()
        if self.lth_rcap > 0:
            self.lth_mvrv = self.lth_mv / self.lth_rcap
        if self.sth_rcap > 0:
            self.sth_mvrv = self.sth_mv / self.sth_rcap
        print("save_db initiate")
        self.save_db()
        print("save_db ok")

        cin.close()
        #cout.close()
        connin.close()
        #connout.close()
# 该方法似乎用于处理来自名为“utxos.sqlite”的
    # SQLite
    # 数据库的未使用的事务输出 （UTXO）。以下是其功能的细分：handle_utxos
    # 它需要三个参数：（包含历史价格的字典）、（包含区块高度和时间戳的字典）和（检查价格的特定日期）。priceshtcheck_dayutc
    # 它初始化为0和0。current_pricecoin_idx
    # 它建立与SQLite
    # 数据库的连接，并检索用于执行SQL查询的游标。
    # 它循环访问从数据库提取的表中的每一行。utxos对于每一行，它提取各种属性，例如交易
    # ID（）、输出索引 （）、值、是否是coinbase交易 （）、区块高度 （）、scriptPubKey （） 和时间戳 （）。txidvoutcoinbaseheightscriptpubkeydt
    # 它将时间戳转换为人类可读的日期字符串，然后转换为UTC时间戳。dtdaystrdayutc
    # 它从字典中获取与对应的历史价格，并将其分配给变量。dayutcpricesprice
    # 它检查字典中是否存在 ，并将其相应的价格分配给 。check_dayutcpricescurrent_price
    # 它将UTXO值除以1000000000以将其转换为比特币单位。
    # 它调用和方法与相关参数来处理UTXO数据。summary_utxossummary_toplist
    # 如有必要，根据某些条件进行计算。lth_mvrvsth_mvrv
    # 最后，它调用该方法将处理后的数据保存到数据库中。save_db
    # 它关闭游标和数据库连接。
    # 此方法有效地处理来自SQLite数据库的UTXO的处理，执行必要的计算和更新，并将处理后的数据保存回数据库
    def utxos(self, check_dayutc):

        self.current_dt = check_dayutc
        self.current_dt2 = time.gmtime(int(self.current_dt))
        self.current_daystr = time.strftime("%d %b %Y", self.current_dt2)
        self.current_dayutc = int(time.mktime(time.strptime(self.current_daystr, "%d %b %Y")))

        topliststr = "toplist" + self.current_daystr
        print(topliststr)
        self.mdbc_toplist = self.mdb[topliststr]

        # prices_temp = self.get_history_price()
        # prices = self.get_history_price2(prices_temp)
        prices_temp=btc_historical_price.prices_temp
        prices=btc_historical_price.prices
        '''for key in prices.keys():
            print(key, prices[key])
            break'''
        print(prices)
        if len(prices) <= 0:
            print("failed get price")
            return
        ht = self.get_ht()
        if ht is None:
            print("failed get height and time")
            return

        self.handle_utxos(prices, ht, check_dayutc)
# 该方法似乎负责处理 表示的特定日期的未使用事务输出 （UTXO）。以下是其功能的摘要：utxoscheck_dayutc
#
# 它根据提供的 .check_dayutc
# 它使用 和 方法检索历史价格数据。get_history_priceget_history_price2
# 该方法从纳斯达克 API 检索历史比特币价格数据。get_history_price
# 该方法从 Messari API 检索其他历史价格数据。get_history_price2
# 它使用该方法检索高度和时间戳数据。get_ht
# 它调用该方法以使用检索到的价格和高度数据处理 UTXO。handle_utxos
# 该方法进一步与 SQLite 数据库交互以处理 UTXO 并执行必要的计算。handle_utxos
# 总体而言，该方法协调了获取历史价格和高度数据并使用它来处理特定日期的 UTXO 的过程。如果成功，它将使用处理后的 UTXO 数据更新相关数据库。utxos
if __name__ == '__main__':
    if len(sys.argv) > 1:
        check_dt = sys.argv[1]
        stats = UtxosIf()
        setup('mainnet')
        stats.get_height_timestamp()
        stats.get_daily_height()
        daily_hash = stats.get_dh_hash()
        #print(daily_hash)
        if daily_hash is None:
            print("failed get daily height")
        else:
            os.system("if [ -e utxos.dat ]; then rm utxos.dat; fi")
            os.system("if [ -e utxos.sqlite ]; then rm utxos.sqlite; fi")
            check_dayutc = int(time.mktime(time.strptime(check_dt, "%Y-%m-%d")))
            cmd = "~/bitcoin-29.0/bin/bitcoin-cli -rpcuser=user -rpcpassword=password -rpcclienttimeout=600 invalidateblock " + daily_hash[str(check_dayutc)]
            os.system(cmd)
            print("select ok",daily_hash[str(check_dayutc)])
            time.sleep(60);
            os.system("~/bitcoin-29.0/bin/bitcoin-cli -rpcuser=user -rpcpassword=password -rpcclienttimeout=1800 dumptxoutset ~/utxos.dat latest")
            print("dumptxoutset ok")
            time.sleep(60);
            #os.system("./utxo_to_sqlite ./utxos.dat ./utxos.sqlite")
            os.system("python3 utxo_to_sqlite.py ./utxos.dat ./utxos.sqlite")
            print("utxo_to_sqlite ok")
            time.sleep(60);
            stats.utxos(check_dayutc)
            print("utxos stat ok")
            cmd = "~/bitcoin-29.0/bin/bitcoin-cli -rpcuser=user -rpcpassword=password reconsiderblock " + daily_hash[str(check_dayutc)]
            os.system(cmd)
            print("reconsiderblock ok")
# 此脚本似乎基于命令行参数执行与比特币 UTXO（未花费的交易输出）相关的几个任务。以下是它的作用的细分：
# 1. 它检查脚本是否直接运行 （'__name__ == '__main__''）。
# 2. 它检查是否提供了命令行参数 （'len（sys.argv） > 1'）。
# 3. 它初始化“UtxosIf”类的实例，可能包含与处理 UTXO 相关的方法。
# 4. 它使用“设置”功能设置比特币网络（假设为“主网”）。
# 5. 它分别使用“get_height_timestamp”和“get_daily_height”方法检索高度和时间戳数据。
# 6. 它使用“get_dh_hash”方法获取每日哈希数据。
# 7. 如果每日哈希数据可用，则继续进行进一步操作：
#  - 如果存在现有的“utxos.dat”和“utxos.sqlite”文件，它会删除它们。
#  - 它使用比特币 CLI 命令“invalidateblock”使区块失效。
#  - 它会等待一段时间（大概是网络处理区块失效）。
#  - 它使用比特币CLI命令'dumptxoutset'转储UTXO集。
#  - 它再次等待。
#  - 它使用“utxo_to_sqlite”脚本将转储的 UTXO 数据转换为 SQLite 数据库。
#  - 它使用“utxos”方法处理指定日期的 UTXO。
#  - 它使用比特币 CLI 命令“reconsiderblock”重新考虑之前失效的区块。
# 8. 每个步骤都附有指示脚本进度的打印语句。
# 这个脚本似乎是一个更大的系统的一部分，该系统与比特币网络交互并执行与UTXO相关的任务。它严重依赖比特币核心软件和命令行界面（“bitcoin-cli”）
