hiddifypanel 10.85.0b12__py3-none-any.whl → 10.85.0b14__py3-none-any.whl

hiddifypanel/VERSION

@@ -1 +1 @@
-10.85.0b12
+10.85.0.b14

hiddifypanel/VERSION.py

@@ -1,6 +1,6 @@
 # import importlib.metadata
 from datetime import datetime
 
-__version__ = '10.85.0b12'
-__release_time__= datetime.strptime('2025-04-29T02:16:29','%Y-%m-%dT%H:%M:%S')
+__version__ = '10.85.0.b14'
+__release_time__= datetime.strptime('2025-06-28T13:07:47','%Y-%m-%dT%H:%M:%S')
 is_released_version=True

hiddifypanel/database.py

@@ -79,6 +79,7 @@ def init_app(app):
 
 
 def db_execute(query: str, return_val: bool = False, commit: bool = False, **params: dict):
+    # print(params)
     q = db.session.execute(text(query), params)
     if commit:
         db.session.commit()

hiddifypanel/drivers/abstract_driver.py

@@ -1,7 +1,7 @@
 
 
 class DriverABS:
-    def get_all_usage(self, users): pass
+    def get_all_usage(self): pass
     def get_enabled_users(self): pass
     def add_client(self, user): pass
     def remove_client(self, user): pass

hiddifypanel/drivers/singbox_api.py

@@ -38,17 +38,17 @@ class SingboxApi(DriverABS):
     def remove_client(self, user):
         pass
 
-    def get_all_usage(self, users):
+    def get_all_usage(self):
         xray_client = self.get_singbox_client()
         usages = xray_client.stats_query('user', reset=True)
-        uuid_user_map = {u.uuid: u for u in users}
+        
         res = defaultdict(int)
         for use in usages:
             if "user>>>" not in use.name:
                 continue
             # print(use.name, use.value)
             uuid = use.name.split(">>>")[1].split("@")[0]
-            res[uuid_user_map[uuid]] += use.value  # uplink + downlink
+            res[uuid] += use.value  # uplink + downlink
         return res
         # return {u: self.get_usage_imp(u.uuid) for u in users}
 

hiddifypanel/drivers/ssh_liberty_bridge_api.py

@@ -41,12 +41,13 @@ class SSHLibertyBridgeApi(DriverABS):
         redis_client.hdel(USERS_USAGE, f'{user.uuid}')
         redis_client.save()
 
-    def get_all_usage(self, users):
+    def get_all_usage(self):
         redis_client = self.get_ssh_redis_client()
         allusage = redis_client.hgetall(USERS_USAGE)
         redis_client.delete(USERS_USAGE)
-        return {u: int(allusage.get(u.uuid) or 0) for u in users}
-        return {u: self.get_usage_imp(u.uuid) for u in users}
+        return allusage
+        # return {u: int(allusage.get(u.uuid) or 0) for u in users}
+        # return {u: self.get_usage_imp(u.uuid) for u in users}
 
     def get_usage_imp(self, client_uuid: str, reset: bool = True) -> int:
         redis_client = self.get_ssh_redis_client()

hiddifypanel/drivers/user_driver.py

@@ -17,16 +17,17 @@ def enabled_drivers():
 def get_users_usage(reset=True):
     res = {}
     from hiddifypanel.database import db
-    
-    users = db.session.query(User).all()
+
+    # users = db.session.query(User).all()
     # users = list(User.query.all())
     res = defaultdict(lambda: {'usage': 0, 'devices': ''})
     for driver in enabled_drivers():
         try:
-            all_usage = driver.get_all_usage(users)
-            for user, usage in all_usage.items():
+            all_usage = driver.get_all_usage()
+            for uuid, usage in all_usage.items():
+                # print(f"{driver.__class__.__name__} {uuid} usage={usage}")
                 if usage:
-                    res[user]['usage'] += usage
+                    res[uuid]['usage'] += usage
                 # res[user]['devices'] +=usage
         except Exception as e:
             print(driver)

hiddifypanel/drivers/wireguard_api.py

@@ -22,7 +22,25 @@ class WireguardApi(DriverABS):
 
     def __init__(self) -> None:
         super().__init__()
-
+        self.pub_uuid_map={}
+    def __load_pubkey_uuid_map(self):
+        from hiddifypanel.database import db
+        users = db.session.query(User).all()
+        self.pub_uuid_map={u.wg_pub: u.uuid for u in users}
+
+    def __convert_pub_key_to_uuid(self,pubkeys):
+        res={}
+        can_reload_map=True
+        for key in pubkeys:
+            if uuid:=self.pub_uuid_map.get(key):
+                res[key]=uuid
+            elif can_reload_map:
+                self.__load_pubkey_uuid_map()
+                can_reload_map=False
+                if uuid:=self.pub_uuid_map.get(key):
+                    res[key]=uuid
+        return res
+            
     def __get_wg_usages(self) -> dict:
         raw_output = commander(Command.update_wg_usage, run_in_background=False)
         data = {}
@@ -36,6 +54,7 @@ class WireguardApi(DriverABS):
                 'down': int(sections[1]),
                 'up': int(sections[2]),
             }
+        
         return data
 
     def __get_local_usage(self) -> dict:
@@ -45,22 +64,25 @@ class WireguardApi(DriverABS):
 
         return {}
 
-    def __sync_local_usages(self, users) -> dict:
+    def __sync_local_usages(self) -> dict:
         local_usage = self.__get_local_usage()
         wg_usage = self.__get_wg_usages()
+        
         res = {}
         # remove local usage that is removed from wg usage
         for local_wg_pub in local_usage.copy().keys():
             if local_wg_pub not in wg_usage:
                 del local_usage[local_wg_pub]
-        uuid_map = {u.wg_pub: u for u in users}
+
+        
+        uuid_map = self.__convert_pub_key_to_uuid(wg_usage.keys())
         for wg_pub, wg_usage in wg_usage.items():
-            user = uuid_map.get(wg_pub)
-            uuid = user.uuid if user else None
+            uuid = uuid_map.get(wg_pub)
+            
             if not local_usage.get(wg_pub):
                 local_usage[wg_pub] = {"uuid": uuid, "usage": wg_usage}
                 continue
-            res[wg_pub] = self.calculate_reset(local_usage[wg_pub]['usage'], wg_usage)
+            res[uuid] = self.calculate_reset(local_usage[wg_pub]['usage'], wg_usage)
             local_usage[wg_pub] = {"uuid": uuid, "usage": wg_usage}
 
         self.get_redis_client().set(USERS_USAGE, json.dumps(local_usage))
@@ -101,14 +123,14 @@ class WireguardApi(DriverABS):
     def remove_client(self, user):
         pass
 
-    def get_all_usage(self, users, reset=True):
+    def get_all_usage(self, reset=True):
         if not hconfig(ConfigEnum.wireguard_enable):
             return {}
-        all_usages = self.__sync_local_usages(users)
+        all_usages = self.__sync_local_usages()
         res = {}
-        for u in users:
-            if use := all_usages.get(u.wg_pub):
-                res[u] = use['up'] + use['down']
-            else:
-                res[u] = 0
+        for uuid,use in all_usages.items():
+            # if use := all_usages.get(u.wg_pub):
+                res[uuid] = use['up'] + use['down']
+            # else:
+            #     res[u] = 0
         return res

hiddifypanel/drivers/xray_api.py

@@ -16,36 +16,41 @@ class XrayApi(DriverABS):
         return self.xray_client
 
     def get_enabled_users(self):
-        xray_client = self.get_xray_client()
-        usages = xray_client.stats_query('user', reset=True)
-        res = defaultdict(int)
-        tags = set(self.get_inbound_tags())
-        for use in usages:
-            if "user>>>" not in use.name:
-                continue
-            uuid = use.name.split(">>>")[1].split("@")[0]
-
-            for t in tags.copy():
-                try:
-                    self.__add_uuid_to_tag(uuid, t)
-                    self._remove_client(uuid, [t], False)
-                    # print(f"Success add  {uuid} {t}")
-                    res[uuid] = 0
-                except ValueError:
-                    # tag invalid
-                    tags.remove(t)
-                    pass
-                except xtlsapi.xtlsapi.exceptions.EmailAlreadyExists as e:
-                    res[uuid] = 1
-                except Exception as e:
-                    print(f"error {e}")
-                    res[uuid] = 0
-
-        return res
+        return {u:1 for u in self.get_enabled_users_terminal()}
+        # xray_client = self.get_xray_client()
+        # usages = xray_client.stats_query('user', reset=True)
+        # res = defaultdict(int)
+        # tags = set(self.get_inbound_tags())
+        # for use in usages:
+        #     if "user>>>" not in use.name:
+        #         continue
+        #     uuid = use.name.split(">>>")[1].split("@")[0]
+        #     res[uuid]=1
+
+        #     #TODO use xtls api
+        #     for t in tags.copy():
+        #         try:
+        #             self.__add_uuid_to_tag(uuid, t)
+        #             self._remove_client(uuid, [t], False)
+        #             # print(f"Success add  {uuid} {t}")
+        #             res[uuid] = 0
+        #             break
+        #         except ValueError:
+        #             # tag invalid
+        #             tags.remove(t)
+        #             pass
+        #         except xtlsapi.xtlsapi.exceptions.EmailAlreadyExists as e:
+        #             res[uuid] = 1
+        #             break
+        #         except Exception as e:
+        #             print(f"error {e}")
+        #             # res[uuid] = 1
+        #             break
+
+        # return res
 
         # xray_client = self.get_xray_client()
-        # users = User.query.all()
-        # t = "xtls"
+        # users = User.query.all() # t = "xtls"
         # protocol = "vless"
         # enabled = {}
         # for u in users:
@@ -101,8 +106,7 @@ class XrayApi(DriverABS):
         if (protocol == "vless" and p != "xtls" and p != "realityin") or "realityingrpc" in t:
             xray_client.add_client(t, f'{uuid}', f'{uuid}@hiddify.com', protocol=protocol, flow='\0',)
         else:
-            xray_client.add_client(t, f'{uuid}', f'{uuid}@hiddify.com', protocol=protocol,
-                                   flow='xtls-rprx-vision', alter_id=0, cipher='chacha20_poly1305')
+            xray_client.add_client(t, f'{uuid}', f'{uuid}@hiddify.com', protocol=protocol, flow='xtls-rprx-vision', alter_id=0, cipher='chacha20_poly1305')
 
     def add_client(self, user):
         uuid = user.uuid
@@ -130,26 +134,26 @@ class XrayApi(DriverABS):
         for t in tags:
             try:
                 xray_client.remove_client(t, f'{uuid}@hiddify.com')
-                if dolog:
-                    logger.info(f"Success remove  {uuid} {t}")
+                # if dolog:
+                #     logger.info(f"Success remove  {uuid} {t}")
             except Exception as e:
                 if dolog:
                     logger.info(f"error in remove  {uuid} {t} {e}")
                 pass
 
-    def get_all_usage(self, users):
+    def get_all_usage(self)->dict:
         xray_client = self.get_xray_client()
         usages = xray_client.stats_query('user', reset=True)
-        uuid_user_map = {u.uuid: u for u in users}
+        # uuid_user_map = {u.uuid: u for u in users}
         res = defaultdict(int)
         for use in usages:
             if "user>>>" not in use.name:
                 continue
             uuid = use.name.split(">>>")[1].split("@")[0]
-            if u := uuid_user_map.get(uuid):
-                res[u] += use.value
-            else:
-                self._remove_client(uuid)
+            # if u := uuid_user_map.get(uuid):
+            res[uuid] += use.value
+            # else:
+            #     self._remove_client(uuid)
         return res
 
     def get_usage_imp(self, uuid):
@@ -167,3 +171,36 @@ class XrayApi(DriverABS):
         if res:
             logger.debug(f"Xray usage {uuid} d={d} u={u} sum={res}")
         return res
+
+
+
+
+    def get_enabled_users_terminal(self):
+        import subprocess
+        import json
+        tags=self.get_inbound_tags()
+        for t in tags:
+        # Command to execute
+            cmd = [
+                'xray',
+                'api',
+                'inbounduser',
+                '--server=127.0.0.1:10085',
+                f'-tag={t}'
+            ]
+
+            try:
+                result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+
+                # Parse JSON output
+                data = json.loads(result.stdout)
+                users= [splt[0] for splt in [u.get('email','').split("@") for u in data.get('users',[])] if len(splt)==2 and splt[1]=="hiddify.com"]
+                if len(data)>0:
+                    return users
+
+            except subprocess.CalledProcessError as e:
+                print("Command failed:", e)
+                print("Error output:", e.stderr)
+            except json.JSONDecodeError as e:
+                print("Failed to parse JSON:", e)
+        return []

hiddifypanel/hutils/flask.py

@@ -244,7 +244,7 @@ def validate_domain_exist(form, field):
 
 
 def get_proxy_stats_url():
-    proxy_stats_url = f'{request.host_url}{g.proxy_path}/proxy-stats/'
+    proxy_stats_url = f'{request.host_url}{g.proxy_path}/proxy-stats/'.replace("http://","https://")
     params = f'hostname={proxy_stats_url}api/&port=443&secret=hiddify'
     return f'{proxy_stats_url}?{params}'
 

hiddifypanel/hutils/proxy/shared.py

@@ -361,7 +361,7 @@ def make_proxy(hconfigs: dict, proxy: Proxy, domain_db: Domain, phttp=80, ptls=4
         return base
     elif "shadowsocks" in proxy.transport:
         return base
-    if ProxyTransport.XTLS in proxy.transport:
+    if proxy.l3 in [ProxyL3.reality] and  proxy.transport in [ProxyTransport.XTLS,ProxyTransport.xhttp]:
         base['flow'] = 'xtls-rprx-vision'
         return {**base, 'transport': 'tcp'}
 

hiddifypanel/panel/init_db.py

@@ -17,6 +17,63 @@ from loguru import logger
 MAX_DB_VERSION = 120
 
 
+def _v102(child_id):
+
+    add_usage_proc=    """
+DROP PROCEDURE IF EXISTS add_usage_json;
+
+CREATE PROCEDURE add_usage_json(IN usage_data JSON)
+BEGIN
+  DECLARE u_id INT DEFAULT NULL;
+  DECLARE u_uuid CHAR(36) DEFAULT NULL;
+  DECLARE u_usage BIGINT;
+  DECLARE done BOOL DEFAULT FALSE;
+
+  DECLARE cur CURSOR FOR
+    SELECT jt.id, jt.uuid, jt.usage FROM JSON_TABLE(
+      usage_data,
+      '$[*]' COLUMNS (
+        id INT PATH '$.id' NULL ON ERROR,
+        uuid CHAR(36) PATH '$.uuid' NULL ON ERROR,
+        `usage` BIGINT PATH '$.usage'
+      )
+    ) AS jt;
+
+  DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;
+
+  OPEN cur;
+
+  read_loop: LOOP
+    FETCH cur INTO u_id, u_uuid, u_usage;
+    IF done THEN
+      LEAVE read_loop;
+    END IF;
+
+    IF u_id IS NOT NULL THEN
+      UPDATE user
+      SET current_usage = current_usage + u_usage,
+          last_online = NOW(),
+          start_date = CASE WHEN start_date IS NULL THEN CURDATE() ELSE start_date END
+      WHERE id = u_id;
+    ELSEIF u_uuid IS NOT NULL THEN
+      UPDATE user
+      SET current_usage = current_usage + u_usage,
+          last_online = NOW(),
+          start_date = CASE WHEN start_date IS NULL THEN CURDATE() ELSE start_date END
+
+      WHERE uuid = u_uuid;
+    END IF;
+
+    COMMIT;
+  END LOOP;
+
+  CLOSE cur;
+END
+
+    """
+
+    db_execute(add_usage_proc,commit=True)
+    
 
 def _v101(child_id):
     add_config_if_not_exist(ConfigEnum.path_xhttp, hutils.random.get_random_string(7, 15))
@@ -660,7 +717,7 @@ def make_proxy_rows(cfgs):
                 continue
             if l3 in ["kcp", 'reality'] and cdn != "direct":
                 continue
-            if l3 == "reality" and ((transport not in ['tcp', 'grpc', 'XTLS']) or proto != 'vless'):
+            if l3 == "reality" and ((transport not in ['tcp', 'grpc', 'XTLS',ProxyTransport.xhttp]) or proto != 'vless'):
                 continue
             if proto == "trojan" and l3 not in ["tls", 'xtls', 'tls_h2', 'h3_quic']:
                 continue
@@ -668,6 +725,11 @@ def make_proxy_rows(cfgs):
                 continue
             if transport in ["h2"] and l3 != "reality":
                 continue
+            if l3 in [ProxyL3.h3_quic,ProxyL3.tls_h2] and transport in [ProxyTransport.httpupgrade, ProxyTransport.WS]:
+                continue
+
+            
+
             # if l3 == "tls_h2" and transport =="grpc":
             #     continue
             enable = l3 != "http" or proto == "vmess"
@@ -805,6 +867,7 @@ def upgrade_database():
 def init_db():
     # set_hconfig(ConfigEnum.db_version, 71)
     db_version = current_db_version()
+    # set_hconfig(ConfigEnum.db_version,101)
     if db_version == latest_db_version():
         return
     

hiddifypanel/panel/usage.py

@@ -1,4 +1,5 @@
 
+from celery import shared_task
 from sqlalchemy import func
 from typing import Dict
 import datetime
@@ -6,12 +7,12 @@ import datetime
 from hiddifypanel.drivers import user_driver
 from hiddifypanel.models import *
 from hiddifypanel.panel import hiddify
-from hiddifypanel.database import db
+from hiddifypanel.database import db, db_execute, text
 from hiddifypanel import cache, hutils
 from loguru import logger
+import json
 to_gig_d = 1024**3
 
-from celery import shared_task
 
 @shared_task(ignore_result=False)
 def update_local_usage():
@@ -19,9 +20,9 @@ def update_local_usage():
     # if not cache.redis_client.set(lock_key, "locked", nx=True, ex=600):
     #     return {"msg": "last update task is not finished yet."}
     try:
-        res=update_local_usage_not_lock()
+        res = update_local_usage_not_lock()
         cache.redis_client.set(lock_key, "locked", nx=False, ex=60)
-        
+
         return res
     except Exception as e:
         cache.redis_client.set(lock_key, "locked", nx=False, ex=60)
@@ -30,147 +31,242 @@ def update_local_usage():
         return {"msg": f"Exception in update usage: {e}"}
 
     # return {"status": 'success', "comments":res}
+
+
 def update_local_usage_not_lock():
-    
+
     try:
         res = user_driver.get_users_usage(reset=True)
-        return _add_users_usage(res, child_id=0)
+        return add_users_usage_new([{'uuid': uuid, "usage": uinfo['usage']} for uuid, uinfo in res.items()], child_id=0)
+        # add_users_usage_uuid({"66ac79b8-8c03-4084-81c7-a2b1b3e9eefe":{"usage":1000000000}},child_id=0)
+        # json_data=json.dumps([{ "uuid": uuid, "usage": uinfo["usage"]}for uuid, uinfo in {"66ac79b8-8c03-4084-81c7-a2b1b3e9eefe":{"usage":1000000000}}.items()])
+        # db_execute("CALL add_usage_json(:usage_data)", usage_data= json_data, commit=True)
     except Exception as e:
         raise
-        
 
 
 def add_users_usage_uuid(uuids_bytes: Dict[str, Dict], child_id, sync=False):
-    uuids_bytes = {u: v for u, v in uuids_bytes.items() if v}
+    uuids_bytes = {u: v for u, v in uuids_bytes.items() if v and v.get('usage', 0) > 0}
     uuids = uuids_bytes.keys()
     users = db.session.query(User).filter(User.uuid.in_(uuids))
-    dbusers_bytes = {u: uuids_bytes.get(u.uuid, 0) for u in users}
+    dbusers_bytes = {u: uuids_bytes.get(u.uuid, {"usage": 0}) for u in users}
     _add_users_usage(dbusers_bytes, child_id, sync)  # type: ignore
 
 
-def _reset_priodic_usage():
+def _reset_priodic_usage() -> bool:
+    apply_changes = False
     last_usage_check: int = hconfig(ConfigEnum.last_priodic_usage_check) or 0
     import time
     current_time = int(time.time())
-    if current_time - last_usage_check < 60 * 60 * 6:
-        return
-    # reset as soon as possible in the day
-    if datetime.datetime.now().hour > 5 and current_time - last_usage_check < 60 * 60 * 24:
-        return
+    # if current_time - last_usage_check < 60 * 60 * 6:
+    #     return apply_changes
+    # # reset as soon as possible in the day
+    # if datetime.datetime.now().hour > 5 and current_time - last_usage_check < 60 * 60 * 24:
+    #     return apply_changes
     logger.debug("reseting user usage if needed")
-    for user in db.session.query(User).filter(User.mode != UserMode.no_reset).all():
+    # for user in db.session.query(User).filter(User.mode != UserMode.no_reset).all():
+    #     if user.user_should_reset():
+    #         logger.info(f"reseting user usage for {user.uuid}")
+    #         user.reset_usage(commit=False)
+
+    today = datetime.date.today()
+
+    db_change = False
+    for user in db.session.query(User).filter(User.mode != UserMode.no_reset, User.start_date != None, User.start_date+User.package_days >= today).all():
         if user.user_should_reset():
             logger.info(f"reseting user usage for {user.uuid}")
+            old_active = user.is_active
             user.reset_usage(commit=False)
-    set_hconfig(ConfigEnum.last_priodic_usage_check, current_time)
+            db_change = True
 
+            if not old_active and user.is_active:
+                logger.info(f"adding enabled client {user.uuid} ")
+                user_driver.add_client(user)
+                apply_changes = True
+                send_bot_message(user)
 
-def _add_users_usage(users_usage_data: Dict[User, Dict], child_id, sync=False):
-    '''
-    sync: when enabled, it means we have received usages from the parent panel
-    '''
-    res = {}
-    have_change = False
+    if db_change:
+        db.session.commit()
+
+    for user in db.session.query(User).filter(User.start_date != None, User.start_date+User.package_days < today).all():
+        logger.info(f"Removing enabled client {user.uuid} ")
+        if not user.is_active:
+            user_driver.remove_client(user)
+            apply_changes = True
+
+    set_hconfig(ConfigEnum.last_priodic_usage_check, current_time, commit=True)
+    return apply_changes
+
+
+def add_users_usage_new(usages: list[dict], child_id, sync=False):
+    usages = [use for use in usages if use['usage'] > 0]
+    # usages[0]['usage']=1000000000000
     before_enabled_users = user_driver.get_enabled_users()
 
     daily_usage = {}
     today = datetime.date.today()
-    changes = False
+    db_changes = False
     for adm in db.session.query(AdminUser).all():
         daily_usage[adm.id] = db.session.query(DailyUsage).filter(DailyUsage.date == today, DailyUsage.admin_id == adm.id, DailyUsage.child_id == child_id).first()
         if daily_usage[adm.id] is None:
             logger.info(f"creating a new daily usage {today} admin={adm.id} child={child_id}")
-            daily_usage[adm.id] = DailyUsage(date=today, admin_id=adm.id, child_id=child_id)
+            daily_usage[adm.id] = DailyUsage(date=today, admin_id=adm.id, child_id=child_id, usage=0)
             db.session.add(daily_usage[adm.id])
-            changes = True
+            db_changes = True
         daily_usage[adm.id].online = db.session.query(User).filter(User.added_by == adm.id).filter(func.DATE(User.last_online) == today).count()
-    if changes:
+    if db_changes:
         db.session.commit()
-    _reset_priodic_usage()
-
-    # userDetails = {p.user_id: p for p in UserDetail.query.filter(UserDetail.child_id == child_id).all()}
-    for user, uinfo in users_usage_data.items():
-        usage_bytes = uinfo['usage']
-
-        # UserDetails things
-        # detail = UserDetail(user_id=user.id, child_id=child_id)
-        # detail = userDetails.get(user.id)
-        # if not detail:
-        #     detail = UserDetail(user_id=user.id, child_id=child_id)
-        #     db.session.add(detail)
-        # if uinfo['devices'] != detail.connected_devices:
-        #     detail.connected_devices = uinfo['devices']
-
-        # Enable the user if isn't already
-        if not before_enabled_users[user.uuid] and user.is_active:
+
+    apply_changes = _reset_priodic_usage()
+
+    db_execute("CALL add_usage_json(:usage_data)", usage_data=json.dumps(usages), commit=True)
+
+    usage_map = {u['uuid']: u for u in usages}
+    
+    users = db.session.query(User).filter(User.uuid.in_(set(usage_map.keys()))).all()
+
+    all_users_uuids = set()
+    for user in users:
+        all_users_uuids.add(user.uuid)
+
+        user_before_active = before_enabled_users.get(user.uuid,False)
+        user_active = user.is_active
+
+        if not user_before_active and user_active:
             logger.info(f"Enabling disabled client {user.uuid} ")
             user_driver.add_client(user)
             send_bot_message(user)
-            have_change = True
-
-        # Check if there's new usage value
-        if not isinstance(usage_bytes, int) or usage_bytes == 0:
-            res[user.uuid] = "No usage"
-        else:
-            # Set new daily usage of the user
-            if sync and daily_usage.get(user.added_by, daily_usage[1]).usage != usage_bytes:
-                daily_usage.get(user.added_by, daily_usage[1]).usage = usage_bytes
-            else:
-                daily_usage.get(user.added_by, daily_usage[1]).usage += usage_bytes
-
-            in_bytes = usage_bytes
-
-            # Set new current usage of the user
-            if sync and user.current_usage != in_bytes:
-                user.current_usage = in_bytes
-                # detail.current_usage_GB = in_gig
-            else:
-                user.current_usage += in_bytes
-                # detail.current_usage = detail.current_usage or 0
-                # detail.current_usage += in_bytes
-
-            # Change last online time of the user
-            user.last_online = datetime.datetime.now()
-            # detail.last_online = datetime.datetime.now()
-
-            # Set start date of user to the current datetime if it hasn't been set already
-            if user.start_date is None:
-                user.start_date = datetime.date.today()
-
-            res[user.uuid] = f'{in_bytes/1000000:0.3f}MB'
-
-        # Remove user from drivers(singbox, xray, wireguard etc.) if they're inactive
-        # print(before_enabled_users[user.uuid], user.is_active)
-        if before_enabled_users[user.uuid] and not user.is_active:
+            apply_changes = True
+        elif user_before_active and not user_active:
             logger.info(f"Removing enabled client {user.uuid} ")
-
             user_driver.remove_client(user)
-            have_change = True
-            res[user.uuid] = f"{res[user.uuid]} !OUT of USAGE! Client Removed"
+            send_bot_message(user)
+            apply_changes = True
+
+        daily_usage.get(user.added_by, daily_usage[1]).usage += usage_map[user.uuid]['usage']
 
-    db.session.commit()  # type: ignore
+    db.session.commit()
 
-    # Remove invalid users
-    for uuid in before_enabled_users:
-        if uuid in res:
-            continue
+    if len(users) != len(usage_map):
+        # check for zombie-users
+        check_users = set(before_enabled_users.keys())-all_users_uuids
+        all_db_users = {u.uuid for u in db.session.query(User).filter(User.uuid.in_(check_users)).all()}
+        zombie_users = check_users-all_db_users
 
-        user = db.session.query(User).filter(User.uuid == uuid).first()
-        if not user:
+        for uuid in zombie_users:
+            logger.info(f"Remove zombiee users {uuid} ")
             user_driver.remove_client(User(uuid=uuid))
-        elif not user.is_active:
-            user_driver.remove_client(user)
+            apply_changes = True
 
-    # print("------------------", res)
-    # Apply the changes to the drivers
-    if have_change:
+    if apply_changes:
         hiddify.quick_apply_users()
 
-    # Sync the new data with the parent node if the data has not been set by the parent node itself and the current panel is a child panel
-    if not sync and hutils.node.is_child():
-        hutils.node.child.sync_users_usage_with_parent()
+    return {"status": 'success', "comments": usages, "date": hutils.convert.time_to_json(datetime.datetime.now())}
+
+
+# def _add_users_usage(users_usage_data: Dict[User, Dict], child_id, sync=False):
+#     '''
+#     sync: when enabled, it means we have received usages from the parent panel
+#     '''
+#     res = {}
+#     have_change = False
+#     before_enabled_users = user_driver.get_enabled_users()
+#     daily_usage = {}
+#     today = datetime.date.today()
+#     changes = False
+#     for adm in db.session.query(AdminUser).all():
+#         daily_usage[adm.id] = db.session.query(DailyUsage).filter(DailyUsage.date == today, DailyUsage.admin_id == adm.id, DailyUsage.child_id == child_id).first()
+#         if daily_usage[adm.id] is None:
+#             logger.info(f"creating a new daily usage {today} admin={adm.id} child={child_id}")
+#             daily_usage[adm.id] = DailyUsage(date=today, admin_id=adm.id, child_id=child_id)
+#             db.session.add(daily_usage[adm.id])
+#             changes = True
+#         daily_usage[adm.id].online = db.session.query(User).filter(User.added_by == adm.id).filter(func.DATE(User.last_online) == today).count()
+#     if changes:
+#         db.session.commit()
+#     _reset_priodic_usage()
+
+#     # userDetails = {p.user_id: p for p in UserDetail.query.filter(UserDetail.child_id == child_id).all()}
+#     for user, uinfo in users_usage_data.items():
+#         usage_bytes = uinfo['usage']
+
+#         # UserDetails things
+#         # detail = UserDetail(user_id=user.id, child_id=child_id)
+#         # detail = userDetails.get(user.id)
+#         # if not detail:
+#         #     detail = UserDetail(user_id=user.id, child_id=child_id)
+#         #     db.session.add(detail)
+#         # if uinfo['devices'] != detail.connected_devices:
+#         #     detail.connected_devices = uinfo['devices']
+
+#         # Enable the user if isn't already
+#         if not before_enabled_users[user.uuid] and user.is_active:
+#             logger.info(f"Enabling disabled client {user.uuid} ")
+#             user_driver.add_client(user)
+#             send_bot_message(user)
+#             have_change = True
+
+#         # Check if there's new usage value
+#         if not isinstance(usage_bytes, int) or usage_bytes == 0:
+#             res[user.uuid] = "No usage"
+#         else:
+#             # Set new daily usage of the user
+#             if sync and daily_usage.get(user.added_by, daily_usage[1]).usage != usage_bytes:
+#                 daily_usage.get(user.added_by, daily_usage[1]).usage = usage_bytes
+#             else:
+#                 daily_usage.get(user.added_by, daily_usage[1]).usage += usage_bytes
+
+#             # Set new current usage of the user
+#             if sync and user.current_usage != usage_bytes:
+#                 user.current_usage = usage_bytes
+#                 # detail.current_usage_GB = in_gig
+#             else:
+#                 user.current_usage += usage_bytes
+#                 # detail.current_usage = detail.current_usage or 0
+#                 # detail.current_usage += usage_bytes
+
+#             # Change last online time of the user
+#             user.last_online = datetime.datetime.now()
+#             # detail.last_online = datetime.datetime.now()
+
+#             # Set start date of user to the current datetime if it hasn't been set already
+#             if user.start_date is None:
+#                 user.start_date = datetime.date.today()
+
+#             res[user.uuid] = f'{usage_bytes/1000000:0.3f}MB'
+
+#         # Remove user from drivers(singbox, xray, wireguard etc.) if they're inactive
+#         # print(before_enabled_users[user.uuid], user.is_active)
+#         if before_enabled_users[user.uuid] and not user.is_active:
+#             logger.info(f"Removing enabled client {user.uuid} ")
+
+#             user_driver.remove_client(user)
+#             have_change = True
+#             res[user.uuid] = f"{res[user.uuid]} !OUT of USAGE! Client Removed"
+
+#     db.session.commit()  # type: ignore
+
+#     # Remove invalid users
+#     for uuid in before_enabled_users:
+#         if uuid in res:
+#             continue
+
+#         user = db.session.query(User).filter(User.uuid == uuid).first()
+#         if not user:
+#             user_driver.remove_client(User(uuid=uuid))
+#         elif not user.is_active:
+#             user_driver.remove_client(user)
+
+#     # print("------------------", res)
+#     # Apply the changes to the drivers
+#     if have_change:
+#         hiddify.quick_apply_users()
+
+#     # Sync the new data with the parent node if the data has not been set by the parent node itself and the current panel is a child panel
+#     if not sync and hutils.node.is_child():
+#         hutils.node.child.sync_users_usage_with_parent()
 
-    return {"status": 'success', "comments": res, "date": hutils.convert.time_to_json(datetime.datetime.now())}
+#     return {"status": 'success', "comments": res, "date": hutils.convert.time_to_json(datetime.datetime.now())}
 
 
 def send_bot_message(user):

{hiddifypanel-10.85.0b12.dist-info → hiddifypanel-10.85.0b14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hiddifypanel
-Version: 10.85.0b12
+Version: 10.85.0b14
 Summary: hiddifypanel multi proxy panel
 Author: hiddify
 License: 

{hiddifypanel-10.85.0b12.dist-info → hiddifypanel-10.85.0b14.dist-info}/RECORD

@@ -1,6 +1,6 @@
 hiddifypanel/Events.py,sha256=AlnRdjVul0jP-NCT4-zoaQgowoOo-JhdQB4ytetAFKA,723
-hiddifypanel/VERSION,sha256=82CenBoXd8N2vI9rzI4bIe63RTxHolQONAAbAhmWwIk,11
-hiddifypanel/VERSION.py,sha256=gJ3sInUzqFfnqSMFjSVEUSVljyx81zsMNzsxAEOI3OQ,190
+hiddifypanel/VERSION,sha256=sKg8vnG-EE180T6hI9d4-w7XaYJpEtaQYHVpwLWzAb4,12
+hiddifypanel/VERSION.py,sha256=RK10T65MIHlBlviFHQpfipvyKaXCPNJaKomq-NPI6Fs,191
 hiddifypanel/__init__.py,sha256=kigwDO8d9jXyPZLvJAWd6zo-GX3pG_xWf-q2aStz80Y,377
 hiddifypanel/__main__.py,sha256=IVchnXpK6bm8T3N--mN17HBQNLMeLAjyP7iwzULexB4,218
 hiddifypanel/auth.py,sha256=LJmH4ROqZv5ej_4m1b0xvbEw2meJTzDR1mFCDm523kE,8041
@@ -8,24 +8,24 @@ hiddifypanel/base.py,sha256=LwEQPv6QVLY6V9EUQ_-C_Sg0p64QRajLTauACIc4m-w,2705
 hiddifypanel/base_setup.py,sha256=W64zORy8BRukhpRXMnCb-SMejQc3bmuwtyWbanGiJ3M,2802
 hiddifypanel/cache.py,sha256=YBogDyZ0jze8IIdPi34YYcbYF4iHsZgpfpt4gZLha0Q,1527
 hiddifypanel/celery.py,sha256=VdU2QOJwerd7pkCQLeDsLpfMWpdARtF7sEEJwud0SDY,3200
-hiddifypanel/database.py,sha256=cC3-zLl320B0pPlztiUtRdGyjBE64Qej5rYPeucNBR0,2614
+hiddifypanel/database.py,sha256=OkFNG9RGdtk3ZXImYjlzpVey7weu5a4Yme3Vo3qsptk,2634
 hiddifypanel/apps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hiddifypanel/apps/asgi_app.py,sha256=Wz1rbJylXxkKthWQI5kUUXkePA8wZ37QO8g1sIbKG5o,181
 hiddifypanel/apps/celery_app.py,sha256=DWDtkbWuAVIJhStnzcTsyo3ker85gm7ZZHWm-Th7cvo,81
 hiddifypanel/apps/celery_app_flask.py,sha256=OlyAUzOOdTNLtNOT_V9hZgCCnTdFOppQaF6lqW58k7g,79
 hiddifypanel/apps/wsgi_app.py,sha256=lyqB3H5jvvfDqi5P34PDw64rsJKhwE8qwYbUiya89BQ,119
-hiddifypanel/drivers/abstract_driver.py,sha256=HpWkgbWVWF8n3WhDe0BlxsIF1WTWO57AQEAEb2ZVCPM,223
-hiddifypanel/drivers/singbox_api.py,sha256=-NNVJtDsZ_e2NhczaEm3Vw7kbiylPferI-NP7vTG84c,2307
-hiddifypanel/drivers/ssh_liberty_bridge_api.py,sha256=J6NvRW3GQbIc2PH3aVZr73YnTGECnWE9M9iFUhVrM20,2242
-hiddifypanel/drivers/user_driver.py,sha256=UC0PIjnptlJwbjdIUv5zqFm4R989CoeH44BoZD7adaI,2786
-hiddifypanel/drivers/wireguard_api.py,sha256=pFAFe-mPUjFOM6DYx-PWhmAQrUPU2D-2aI2qe1VkB78,3619
-hiddifypanel/drivers/xray_api.py,sha256=fade_jDRaXRQamE_9pVKcp9ZqQBVRujEEgmIWJwqrXE,5916
+hiddifypanel/drivers/abstract_driver.py,sha256=BWHWA-5btPTyUSRm0n4gulqeqA4CsEnVY3bV5OOO8U0,216
+hiddifypanel/drivers/singbox_api.py,sha256=dropF7Cfi4i9fMit2omSZ62IQv30B70oH6MZfgfj5bY,2243
+hiddifypanel/drivers/ssh_liberty_bridge_api.py,sha256=urB2HzFUhQQytbPz28_rMgOthwVGip2Od_tsXVbVHWQ,2263
+hiddifypanel/drivers/user_driver.py,sha256=XYgvmXe2CiLAUnX3weldnGHcb8aDwQqF7TIPRjSUnIM,2856
+hiddifypanel/drivers/wireguard_api.py,sha256=qeuh835tSA75npJ2AzW9NhRlAKtaljX1qK-Wjugd5bI,4291
+hiddifypanel/drivers/xray_api.py,sha256=Kk7FDpNFITP085gx_yLqM7hw5vCpoF2bATrZYCXy_JE,7174
 hiddifypanel/hutils/__init__.py,sha256=P0JLvth-yJza_xpSGWlU7Hmtj_Ym9oyDimo4YpURdLQ,1447
 hiddifypanel/hutils/auth.py,sha256=Ci3_lBfLXx1yi2M6HvYX3ceHYtOf-cfX092evcs8528,3030
 hiddifypanel/hutils/convert.py,sha256=mPEDzR64hKeQ4B_tZRk2Ci8-Ybod0bjX0BbxLHOmLZA,2075
 hiddifypanel/hutils/crypto.py,sha256=C32Wj-SpjOSycmmnWD0q8g_ZG4puzJNX9T9hSkTut08,2591
 hiddifypanel/hutils/encode.py,sha256=-A1VknNmtsw-YfV-h8mz6QLtlYjg2MB_ZWbUj6MSil4,837
-hiddifypanel/hutils/flask.py,sha256=5vc_VCl1ojcuDHvS7K_aXlimosv6qPLTZWsFbP6z3ZY,11919
+hiddifypanel/hutils/flask.py,sha256=QE-u0FJpRdxVtg4u9hYkFafEvvL3-EwmqB46LfAKoX8,11949
 hiddifypanel/hutils/github_issue.py,sha256=LSJCDVC_UEFDIXG4JdQReLDUnF_WmfhH7eFB-iZKwdg,6609
 hiddifypanel/hutils/model.py,sha256=ajlJ-Tx0Mq68S9y5qEj0lwlDbF2xj0niZBQyw7UU670,1320
 hiddifypanel/hutils/random.py,sha256=KrsarmRNL05PYzwMxDaDyv-_QcKS0YsZR2z7BnllAqI,1789
@@ -44,7 +44,7 @@ hiddifypanel/hutils/node/parent.py,sha256=UbyfvfP4fTSn6HN9oZDjYsKYIejiqW6eApKIfP
 hiddifypanel/hutils/node/shared.py,sha256=FDSj3e-i3pb3mEv5vcUeX0Km1nxYg1CeAruIq7RwFmU,2540
 hiddifypanel/hutils/proxy/__init__.py,sha256=V2dGkYT3tji__5YOSmKOMChFYXtlENe1fX6eHqK70Pc,129
 hiddifypanel/hutils/proxy/clash.py,sha256=V9Y2UIw-CYTXD_Q73Oeq3WLw6chsPrMIiNxYnlWyNbg,7065
-hiddifypanel/hutils/proxy/shared.py,sha256=Zg4qMqp-fzWXHMqZsE1stluVDgT71AlFVlJAxQwMtfQ,22203
+hiddifypanel/hutils/proxy/shared.py,sha256=MRfdDjfijZxJwoUA6wg9FROdf_wFp9JuJZgMo8SaLnM,22261
 hiddifypanel/hutils/proxy/singbox.py,sha256=Fmmzoake-gpnRB5yfTyQvd1dB-10WKwhJt4vhiKzJZQ,11722
 hiddifypanel/hutils/proxy/wireguard.py,sha256=gij01BYXII-RxAh3Yky0o3yce20HJKeHtu1KNwb0Uzk,934
 hiddifypanel/hutils/proxy/xray.py,sha256=0vEHL9yq5Si7W_fgI8tn9zwNAWhwBE7djun05cAUDF8,10808
@@ -72,9 +72,9 @@ hiddifypanel/panel/common.py,sha256=pMxdgt37ubIZroFBuvHfN5qXNp8kytVTIzVxzZA_X_I,
 hiddifypanel/panel/custom_widgets.py,sha256=_zA0WZRZOCyh6Z1gW62aRQLMAOM_m85B2oZoIOU59Ys,2637
 hiddifypanel/panel/hiddify.py,sha256=nwLTMYa_LyNuS26BPOO8jfyrslHX2MbQxN0o4lxCTd4,15687
 hiddifypanel/panel/hlogger.py,sha256=1AQQCs1lg0Y1AYIASRjxWAdFE92HENeg3z1rFycOoY0,1215
-hiddifypanel/panel/init_db.py,sha256=YfBn1c_NSvGFKC9JemUdsFrIIFAnhRGtVIMzLk_yAd0,38564
+hiddifypanel/panel/init_db.py,sha256=eBh6K35zfxrvUA7t3UrIeo704ELx7lgl4NGEqfj08WQ,40133
 hiddifypanel/panel/run_commander.py,sha256=cXCFVvZ6iTzab3EOZ-Eq3aOeIqfgzgt2ppNaxm_3OJI,3205
-hiddifypanel/panel/usage.py,sha256=o_VPALSd_40m_PEpNnCUggP2sZXXVf1mNjHI249cJOY,7437
+hiddifypanel/panel/usage.py,sha256=Cz7KRJkHIQ6XEkbzwbL4GIzG5ycT-bCDqYmsJK0Gsxk,11923
 hiddifypanel/panel/admin/Actions.py,sha256=o_ENbphriVrbRJkx9nvrkpaliuMIfp34sscMkZJ3P5s,8578
 hiddifypanel/panel/admin/AdminstratorAdmin.py,sha256=X8MI3DtW62vJqFRp97M_CxSdB-NFNMlZOSDsd5hn8HA,10482
 hiddifypanel/panel/admin/Backup.py,sha256=BKSoAZgw1j16P1Jh9vMqGj7ZfB2m-WafDK0C5vil5FY,3634
@@ -842,17 +842,17 @@ hiddifypanel/templates/redirect.html,sha256=K9x_O4P96vEkqBhOXIhoGrWw1KIqd2bL0BjI
 hiddifypanel/templates/static.html,sha256=jp6q4wtx-k2A_cjqJoNiMS7Ee30arE45qI3ev4d5ky4,165
 hiddifypanel/templates/hiddify-flask-admin/actions.html,sha256=2NeITe2e-lPKCk_o511tCIqVtrPu8LYHE1wTCtrFUrI,1331
 hiddifypanel/templates/hiddify-flask-admin/list.html,sha256=MBGrTqZpzNLe4sZy0RozvXNr8seFUQc2C6v88BJtNWc,11095
-hiddifypanel/translations/en/LC_MESSAGES/messages.mo,sha256=cBQIYGzYgsQBRoT-74-vW71ysHvuECbuUo2r2czTWdY,80248
+hiddifypanel/translations/en/LC_MESSAGES/messages.mo,sha256=GncyHCVs1iGb4Vs7YRNX9bB1RQlQXBnbcslMKTr74uE,80248
 hiddifypanel/translations/en/LC_MESSAGES/messages.po,sha256=ZQn1-QHu0FwpHIluExU9U1p738DrpK_vBaucF1ndyvo,83564
-hiddifypanel/translations/fa/LC_MESSAGES/messages.mo,sha256=Np947t6zwnP8qSyc6hsGl5kT7DhgAn3mV0ikZ0zU4Cs,102665
+hiddifypanel/translations/fa/LC_MESSAGES/messages.mo,sha256=155uBY6WCbMhRCW8VzOgd5OoQMeO7Awt1b6tuOTGhQg,102665
 hiddifypanel/translations/fa/LC_MESSAGES/messages.po,sha256=xEU_jSeWnc70mvoPJ7f0d_9lG5U-mvo3BQzcRRvB4o8,107420
-hiddifypanel/translations/my/LC_MESSAGES/messages.mo,sha256=69DQSUGkaW-9tSgyvHNUVnGFof0HsQQhLwK9dMCNFCo,139090
+hiddifypanel/translations/my/LC_MESSAGES/messages.mo,sha256=S0gROMPq8mtA0QxWpf2trNWvf_PxBElc6ZaGIQolC1w,139090
 hiddifypanel/translations/my/LC_MESSAGES/messages.po,sha256=GcrOHDJC2wjo1L8lLmwLOs_dwoqcf0f6rXXjDv8JnsE,141985
-hiddifypanel/translations/pt/LC_MESSAGES/messages.mo,sha256=s_KKmA26HVmsB6qJIcHDLGCDfniyf9DZ__XS_foPzGw,80797
+hiddifypanel/translations/pt/LC_MESSAGES/messages.mo,sha256=8pIwiaprVdRPIX6ND1ZGOtqtNn4RvZVFlVfTKWdKTs0,80797
 hiddifypanel/translations/pt/LC_MESSAGES/messages.po,sha256=pX1dG9wcQEYRBpxU3mL-gY_q2YNkVwbRmrI6wNHjkm8,85364
-hiddifypanel/translations/ru/LC_MESSAGES/messages.mo,sha256=85ZcJyBWVKPk2u--UJtbEqQVeOf5oxyOA5t0Xaf1c6k,108594
+hiddifypanel/translations/ru/LC_MESSAGES/messages.mo,sha256=qtQ7GqRYXF1YCTk0ys9y5dlESPrE6npvzmJVjDm2iYA,108594
 hiddifypanel/translations/ru/LC_MESSAGES/messages.po,sha256=mc8TFxwLUu8iBH8iK-aGUpQoKDRCjb2sh6fZK1w1inU,113367
-hiddifypanel/translations/zh/LC_MESSAGES/messages.mo,sha256=X3lqgn-O1ZZJ89lwpvYLQhijeD-iVWTW40SBJdm0oRU,75296
+hiddifypanel/translations/zh/LC_MESSAGES/messages.mo,sha256=cqDYHg2b5nAcsj0As6V2wQ4mmyV1Dt1hmiiub8jdKQs,75296
 hiddifypanel/translations/zh/LC_MESSAGES/messages.po,sha256=ze5ipeKdB4ISOMkT0ERufBPdlWDT5m3xUj0OSeBdkpk,79474
 hiddifypanel/translations.i18n/en.json,sha256=4rDoVjPSUqs8OCh8dHf923wjHmgJNguelTN3b1EwLqA,72605
 hiddifypanel/translations.i18n/fa.json,sha256=3WMq36rLV-1E9GTVTovDlEPIoOJ5cedOBDdke-OcyXE,96515
@@ -861,9 +861,9 @@ hiddifypanel/translations.i18n/my.json,sha256=QAXg__5TCqfx3Ck0cw5YQsSXX_3kqUhMOd
 hiddifypanel/translations.i18n/pt.json,sha256=bO1-qEZJ9yf6Pz_6Vz18xDLezp3pCYwK8_aTLMJA1Iw,74570
 hiddifypanel/translations.i18n/ru.json,sha256=kCI1TBgj1T0VnvRfrgxCnLt_fA6ZuD9kjRt0vkmyvb0,102357
 hiddifypanel/translations.i18n/zh.json,sha256=A50l-_uQ4lsZwcF3UyGcyZxsR3hAjmvnMrJLnTcVZbI,69103
-hiddifypanel-10.85.0b12.dist-info/licenses/LICENSE.md,sha256=oDrt-cUsyiDGnRPjEJh-3dH2ddAuK_bIVBD8ntkOtZw,19807
-hiddifypanel-10.85.0b12.dist-info/METADATA,sha256=WeRn6SOBIZlgIYl1miQNggtAlHLhEprpt5WiMXtAoik,25628
-hiddifypanel-10.85.0b12.dist-info/WHEEL,sha256=ck4Vq1_RXyvS4Jt6SI0Vz6fyVs4GWg7AINwpsaGEgPE,91
-hiddifypanel-10.85.0b12.dist-info/entry_points.txt,sha256=Xzpqlh3nwBtZhoV9AANJykano056VJvYzaujxPztJaM,60
-hiddifypanel-10.85.0b12.dist-info/top_level.txt,sha256=rv-b3qFWUZQTBy0kyBfsr7L6tPpeO7AaQlLHXn-HI5M,13
-hiddifypanel-10.85.0b12.dist-info/RECORD,,
+hiddifypanel-10.85.0b14.dist-info/licenses/LICENSE.md,sha256=oDrt-cUsyiDGnRPjEJh-3dH2ddAuK_bIVBD8ntkOtZw,19807
+hiddifypanel-10.85.0b14.dist-info/METADATA,sha256=VqhyecYpa68_bak3AEuGmztdV0EjbDgGQcsI0W5PMf0,25628
+hiddifypanel-10.85.0b14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+hiddifypanel-10.85.0b14.dist-info/entry_points.txt,sha256=Xzpqlh3nwBtZhoV9AANJykano056VJvYzaujxPztJaM,60
+hiddifypanel-10.85.0b14.dist-info/top_level.txt,sha256=rv-b3qFWUZQTBy0kyBfsr7L6tPpeO7AaQlLHXn-HI5M,13
+hiddifypanel-10.85.0b14.dist-info/RECORD,,

{hiddifypanel-10.85.0b12.dist-info → hiddifypanel-10.85.0b14.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.0.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any