hiddifypanel 10.80.0.dev8__py3-none-any.whl → 10.80.0.dev10__py3-none-any.whl

hiddifypanel/VERSION

@@ -1 +1 @@
-10.80.0.dev8
+10.80.0.dev10

hiddifypanel/VERSION.py

@@ -2,5 +2,5 @@ import importlib.metadata
 from datetime import datetime
 
 __version__ = importlib.metadata.version(__package__ or __name__)
-__release_time__= datetime.strptime('2024-11-10T19:52:20','%Y-%m-%dT%H:%M:%S')
+__release_time__= datetime.strptime('2024-11-16T00:26:32','%Y-%m-%dT%H:%M:%S')
 is_released_version=True

hiddifypanel/apps/asgi_app.py

@@ -0,0 +1,7 @@
+#!/opt/hiddify-manager/.venv/bin/python
+
+from hiddifypanel import create_app_wsgi
+from asgiref.wsgi import WsgiToAsgi
+
+app = create_app_wsgi()  # noqa
+asgi_app = WsgiToAsgi(app)

hiddifypanel/apps/celery_app.py

@@ -0,0 +1,3 @@
+from hiddifypanel.base import create_celery_app
+
+celery_app=create_celery_app()

hiddifypanel/apps/wsgi_app.py

@@ -0,0 +1,5 @@
+#!/opt/hiddify-manager/.venv/bin/python
+
+from hiddifypanel import create_app_wsgi
+
+app =  create_app_wsgi()  # noqa

hiddifypanel/base.py

@@ -1,11 +1,7 @@
 from flask import request, g
 # from hiddifypanel.cache import cache
-from hiddifypanel.models import *
 
-import flask_bootstrap
-import hiddifypanel
-from flask_babel import Babel
-from flask_session import Session
+
 
 import datetime
 
@@ -13,138 +9,54 @@ from dotenv import dotenv_values
 import os
 import sys
 from apiflask import APIFlask
-from werkzeug.middleware.proxy_fix import ProxyFix
 from loguru import logger
-from hiddifypanel.panel.init_db import init_db
-
-
-def logger_dynamic_formatter(record) -> str:
-    fmt = '<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>'
-    if record['extra']:
-        fmt += ' | <level>{extra}</level>'
-    return fmt + '\n'
 
 
-def init_logger(app, cli):
-    # configure logger
-    logger.remove()
-    logger.add(sys.stderr if cli else sys.stdout, format=logger_dynamic_formatter, level=app.config['STDOUT_LOG_LEVEL'],
-               colorize=True, catch=True, enqueue=True, diagnose=False, backtrace=True)
-    logger.trace('Logger initiated :)')
-
-
-# TODO: refactor this function
+from dynaconf import FlaskDynaconf
 
 def create_app(*args, cli=False, **config):
 
     app = APIFlask(__name__, static_url_path="/<proxy_path>/static/", instance_relative_config=True, version='2.2.0', title="Hiddify API",
                    openapi_blueprint_url_prefix="/<proxy_path>/api", docs_ui='elements', json_errors=False, enable_openapi=not cli)
     # app = Flask(__name__, static_url_path="/<proxy_path>/static/", instance_relative_config=True)
-
-    if not cli:
-        
-        from hiddifypanel import auth
-        app.config["PREFERRED_URL_SCHEME"] = "https"
-        app.wsgi_app = ProxyFix(
-            app.wsgi_app, x_for=1, x_proto=1, x_host=1, x_prefix=1,
-        )
-        app.secret_key="asdsad"
-        app.servers = {
-            'name': 'current',
-            'url': '',
-        }  # type: ignore
-        app.info = {
-            'description': 'Hiddify is a free and open source software. It is as it is.',
-            'termsOfService': 'https://hiddify.com',
-            'contact': {
-                'name': 'API Support',
-                'url': 'https://www.hiddify.com/support',
-                'email': 'panel@hiddify.com'
-            },
-            'license': {
-                'name': 'Creative Commons Zero v1.0 Universal',
-                'url': 'https://github.com/hiddify/Hiddify-Manager/blob/main/LICENSE'
-            }
-        }
-        # setup flask server-side session
-        # app.config['APPLICATION_ROOT'] = './'
-        # app.config['SESSION_COOKIE_DOMAIN'] = '/'
-        
-
-        app.jinja_env.line_statement_prefix = '%'
-        from hiddifypanel import hutils
-        app.jinja_env.filters['b64encode'] = hutils.encode.do_base_64
-        app.view_functions['admin.static'] = {}  # fix bug in apiflask
-        flask_bootstrap.Bootstrap4(app)
-
+    # app.asgi_app = WsgiToAsgi(app)
+    
     for c, v in dotenv_values(os.environ.get("HIDDIFY_CFG_PATH", 'app.cfg')).items():
         if v.isdecimal():
             v = int(v)
         else:
             v = True if v.lower() == "true" else (False if v.lower() == "false" else v)
-
         app.config[c] = v
-    init_logger(app, cli)
-    hiddifypanel.database.init_app(app)
-    with app.app_context():
-        init_db()
-        logger.add(app.config['HIDDIFY_CONFIG_PATH'] + "/log/system/panel.log", format=logger_dynamic_formatter, level=hconfig(ConfigEnum.log_level),
-                   colorize=True, catch=True, enqueue=True, diagnose=False, backtrace=True)
-
-    def get_locale():
-        # Put your logic here. Application can store locale in
-        # user profile, cookie, session, etc.
-        if "admin" in request.base_url:
-            g.locale = hconfig(ConfigEnum.admin_lang) or 'en'
-        else:
-            g.locale = auth.current_account.lang or hconfig(ConfigEnum.lang) or 'en'
-        return g.locale
-    app.jinja_env.globals['get_locale'] = get_locale
-    babel = Babel(app, locale_selector=get_locale)
-    if not cli:
-        app.config['SESSION_TYPE'] = 'redis'
-        from hiddifypanel.cache import redis_client
-        app.config['SESSION_REDIS'] = redis_client
-        app.config['SESSION_PERMANENT'] = True
-        app.config['PERMANENT_SESSION_LIFETIME'] = datetime.timedelta(days=10)
-        app.security_schemes = {  # equals to use config SECURITY_SCHEMES
-            'Hiddify-API-Key': {
-                'type': 'apiKey',
-                'in': 'header',
-                'name': 'Hiddify-API-Key',
-            }
-        }
-        Session(app)
-        hiddifypanel.panel.common.init_app(app)
-        hiddifypanel.panel.common_bp.init_app(app)
-
-        from hiddifypanel.panel import user, commercial, admin
-        admin.init_app(app)
-        user.init_app(app)
-        commercial.init_app(app)
+    dyn=FlaskDynaconf(app,settings_files=[os.environ.get("HIDDIFY_CFG_PATH", 'app.cfg')])
+
+    if cli:
+        app.config['EXTENSIONS']=[
+            # "hiddifypanel.cache:init_app",
+            "hiddifypanel.database:init_app",
+            "hiddifypanel.panel.hlogger:init_cli",
+            "hiddifypanel.panel.cli:init_app",
+            "hiddifypanel.celery:init_app",
+        ]
+    else:
+        app.config['EXTENSIONS']=[
+            # "hiddifypanel.cache:init_app",
+            "hiddifypanel.database:init_app",
+            "hiddifypanel.panel.hlogger:init_app",
+            "hiddifypanel.base_setup:init_app",
+            "hiddifypanel.panel.common:init_app",
+            "hiddifypanel.panel.common_bp:init_app",
+            "hiddifypanel.panel.admin:init_app",
+            "hiddifypanel.panel.user:init_app",
+            "hiddifypanel.panel.commercial:init_app",
+            "hiddifypanel.panel.node:init_app",
+            "hiddifypanel.celery:init_app",
+        ]
+    
+
 
     app.config.update(config)  # Override with passed config
-    # app.config['WTF_CSRF_CHECK_DEFAULT'] = False
-    # app.config['WTF_CSRF_ENABLED'] = False
-    # app.config['BABEL_TRANSLATION_DIRECTORIES'] = '/workspace/Hiddify-Server/hiddify-panel/src/translations.i18n'
-
-    # from flask_wtf.csrf import CSRFProtect
-
-    # csrf = CSRFProtect(app)
-
-    # @app.before_request
-    # def check_csrf():
-    # # if "/admin/user/" in request.base_url:
-    # #     return
-    # # if "/admin/domain/" in request.base_url:
-    # #     return
-    # # if "/admin/actions/" in request.base_url:
-    # #     return
-    # # if "/api/" in request.base_url:
-    # #     return
-    #     csrf.protect()
-
-    hiddifypanel.panel.cli.init_app(app)
+    
+    app.config.load_extensions("EXTENSIONS")
     return app
 
 
@@ -153,16 +65,18 @@ def create_app_wsgi(*args, **kwargs):
     # that doesn't allow **config
     # to be passed to create_app
     # https://github.com/pallets/flask/issues/4170
-    cli = ("hiddifypanel" in sys.argv[0]) or (sys.argv[1] in ["update-usage", "all-configs", "admin_links", "admin_path"])
+    cli = ("hiddifypanel" in sys.argv[0] ) or (sys.argv[1] in ["update-usage", "all-configs", "admin_links", "admin_path"])
+
     app = create_app(cli=cli)
     return app
 
 
-# def create_cli_app(*args, **kwargs):
-#     #     # workaround for Flask issue
-#     #     # that doesn't allow **config
-#     #     # to be passed to create_app
-#     #     # https://github.com/pallets/flask/issues/4170
-#     # print(kwargs)
-#     app = create_app(*args, cli=True, **kwargs)
-#     return app
+
+def create_celery_app():
+    #     # workaround for Flask issue
+    #     # that doesn't allow **config
+    #     # to be passed to create_app
+    #     # https://github.com/pallets/flask/issues/4170
+    # print(kwargs)
+    app = create_app(cli=True)
+    return app.extensions["celery"]

hiddifypanel/base_setup.py

@@ -0,0 +1,82 @@
+from flask import request, g
+import redis
+# from hiddifypanel.cache import cache
+from hiddifypanel.models import *
+
+import flask_bootstrap
+from flask_babel import Babel
+from flask_session import Session
+
+import datetime
+
+from dotenv import dotenv_values
+import os
+import sys
+from werkzeug.middleware.proxy_fix import ProxyFix
+from loguru import logger
+from sonora.wsgi import grpcWSGI
+
+
+
+def init_app(app):
+        from hiddifypanel import auth
+        app.config["PREFERRED_URL_SCHEME"] = "https"
+        app.wsgi_app = ProxyFix(
+            app.wsgi_app, x_for=1, x_proto=1, x_host=1, x_prefix=1,
+        )
+        
+
+        app.secret_key="asdsad"
+        app.servers = {
+            'name': 'current',
+            'url': '',
+        }  # type: ignore
+        app.info = {
+            'description': 'Hiddify is a free and open source software. It is as it is.',
+            'termsOfService': 'https://hiddify.com',
+            'contact': {
+                'name': 'API Support',
+                'url': 'https://www.hiddify.com/support',
+                'email': 'panel@hiddify.com'
+            },
+            'license': {
+                'name': 'Creative Commons Zero v1.0 Universal',
+                'url': 'https://github.com/hiddify/Hiddify-Manager/blob/main/LICENSE'
+            }
+        }
+        # setup flask server-side session
+        # app.config['APPLICATION_ROOT'] = './'
+        # app.config['SESSION_COOKIE_DOMAIN'] = '/'
+        
+
+        app.jinja_env.line_statement_prefix = '%'
+        from hiddifypanel import hutils
+        app.jinja_env.filters['b64encode'] = hutils.encode.do_base_64
+        app.view_functions['admin.static'] = {}  # fix bug in apiflask
+        flask_bootstrap.Bootstrap4(app)
+
+        def get_locale():
+            # Put your logic here. Application can store locale in
+            # user profile, cookie, session, etc.
+            if "admin" in request.base_url:
+                g.locale = hconfig(ConfigEnum.admin_lang) or 'en'
+            else:
+                g.locale = auth.current_account.lang or hconfig(ConfigEnum.lang) or 'en'
+            return g.locale
+        app.jinja_env.globals['get_locale'] = get_locale
+        babel = Babel(app, locale_selector=get_locale)
+        
+        app.config['SESSION_TYPE'] = 'redis'
+        
+        app.config['SESSION_REDIS'] = redis.from_url(os.environ['REDIS_URI_MAIN'])
+        app.config['SESSION_PERMANENT'] = True
+        app.config['PERMANENT_SESSION_LIFETIME'] = datetime.timedelta(days=10)
+        app.security_schemes = {  # equals to use config SECURITY_SCHEMES
+            'Hiddify-API-Key': {
+                'type': 'apiKey',
+                'in': 'header',
+                'name': 'Hiddify-API-Key',
+            }
+        }
+        Session(app)
+        app.wsgi_app = grpcWSGI(app.wsgi_app)

hiddifypanel/cache.py

@@ -5,7 +5,7 @@ from pickle import dumps, loads
 from loguru import logger
 
 redis_client = redis.from_url(os.environ["REDIS_URI_MAIN"])
-
+# print(os.environ["REDIS_URI_MAIN"])
 
 class CustomRedisCache(RedisCache):
     def __init__(self, redis_client, prefix="rc", serializer=compact_dump, deserializer=loads, key_serializer=None, support_cluster=True, exception_handler=None):

hiddifypanel/celery.py

@@ -0,0 +1,45 @@
+from celery import Celery, Task
+from celery.schedules import crontab
+
+def init_app(app):
+    class FlaskTask(Task):
+        def __call__(self, *args: object, **kwargs: object) -> object:
+            with app.app_context():
+                return self.run(*args, **kwargs)
+
+    celery_app = Celery(app.name, task_cls=FlaskTask)
+    
+    celery_app.config_from_object(dict(
+        broker_url=app.config['REDIS_URI_MAIN'],
+        result_backend=app.config['REDIS_URI_MAIN'],
+        # task_ignore_result=True,
+    ))
+    app.extensions["celery"] = celery_app
+
+
+        # Calls test('hello') every 10 seconds.
+    from hiddifypanel.panel import usage
+    celery_app.add_periodic_task(60.0, usage.update_local_usage.s(), name='update usage')
+    # celery_app.conf.beat_schedule = {
+    # 'update_usage': {
+    #     'task': 'hiddifypanel.panel.usage.update_local_usage',
+    #     'schedule': 30.0, 
+
+    # },
+# }
+    from hiddifypanel.panel.cli import backup_task
+    celery_app.autodiscover_tasks()
+    # celery_app.add_periodic_task(30.0, backup_task.s(), name='backup task')
+    # celery_app.add_periodic_task(
+    #     crontab(hour="*/6", minute=30),
+    #     backup_task.delay(),
+    # )
+
+    celery_app.add_periodic_task(
+        crontab(hour="*/6", minute="0"),
+        backup_task.s(),
+        name="backup_task "
+    )
+    
+    celery_app.set_default()
+    return celery_app

hiddifypanel/database.py

@@ -6,6 +6,9 @@ import os
 from sqlalchemy import Row, text, Sequence
 
 
+
+
+
 db: SQLAlchemy = SQLAlchemy()
 db.UUID = UUIDType  # type: ignore
 
@@ -13,6 +16,10 @@ db.UUID = UUIDType  # type: ignore
 def init_app(app):
     app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
     db.init_app(app)
+    with app.app_context():
+        from hiddifypanel.panel.init_db import init_db
+        init_db()
+        
 
 
 def db_execute(query: str, return_val: bool = False, commit: bool = False, **params: dict):

hiddifypanel/panel/__init__.py

@@ -1,9 +1,9 @@
 
-from . import user
-# from . import admin
-from . import cli
-# from .. import database
-from . import common
-# from . import commercial
-# from .. import auth
-from . import common_bp
+# from . import user
+# # from . import admin
+# from . import cli
+# # from .. import database
+# from . import common
+# # from . import commercial
+# # from .. import auth
+# from . import common_bp

hiddifypanel/panel/cli.py

@@ -13,6 +13,7 @@ from hiddifypanel.panel import hiddify, usage
 from hiddifypanel.database import db
 from hiddifypanel.panel.init_db import init_db
 
+from loguru import logger
 
 def drop_db():
     """Cleans database"""
@@ -29,7 +30,12 @@ def downgrade():
         os.rename("/opt/hiddify-manager/hiddify-panel/hiddifypanel.db.old", "/opt/hiddify-manager/hiddify-panel/hiddifypanel.db")
 
 
+from celery import shared_task
 def backup():
+    backup_task()
+
+@shared_task(ignore_result=False)
+def backup_task():
     dbdict = hiddify.dump_db_to_dict()
     os.makedirs('backup', exist_ok=True)
     dst = f'backup/{datetime.datetime.now().strftime("%Y_%m_%d__%H_%M_%S")}.json'
@@ -42,9 +48,12 @@ def backup():
             register_bot(True)
 
         with open(dst, 'rb') as document:
-            for admin in AdminUser.query.filter(AdminUser.mode == AdminMode.super_admin, AdminUser.telegram_id is not None).all():
+            for admin in AdminUser.query.filter(AdminUser.mode == AdminMode.super_admin, AdminUser.telegram_id is not None,AdminUser.telegram_id!=0).all():
                 caption = ("Backup \n" + admin_links())
-                bot.send_document(admin.telegram_id, document, visible_file_name=dst.replace("backup/", ""), caption=caption[:min(len(caption), 1000)])
+                try:
+                    bot.send_document(admin.telegram_id, document, visible_file_name=dst.replace("backup/", ""), caption=caption[:1000])
+                except Exception as e:
+                    logger.exception(e)
 
 
 def all_configs():

hiddifypanel/panel/commercial/restapi/v2/admin/system_actions.py

@@ -1,3 +1,5 @@
+import asyncio
+import time
 from flask import current_app as app, request
 from flask import g
 from flask.views import MethodView
@@ -16,7 +18,9 @@ class UpdateUserUsageApi(MethodView):
 
     def get(self):
         """System: Update User Usage"""
-        return json.dumps(usage.update_local_usage(), indent=2)
+        # time.sleep(5)
+        
+        return json.dumps(usage.update_local_usage_not_lock(), indent=2)
 
 
 class AllConfigsApi(MethodView):

hiddifypanel/panel/commercial/restapi/v2/admin/user_api.py

@@ -6,7 +6,8 @@ from hiddifypanel.auth import login_required
 from hiddifypanel.models import *
 from hiddifypanel.panel import hiddify
 from hiddifypanel.drivers import user_driver
-from hiddifypanel.panel import hiddify
+
+
 
 from . import has_permission
 from .schema import UserSchema, PostUserSchema, PatchUserSchema, SuccessfulSchema

hiddifypanel/panel/hlogger.py

@@ -0,0 +1,32 @@
+import sys
+from loguru import logger
+
+def logger_dynamic_formatter(record) -> str:
+    fmt = '<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>'
+    if record['extra']:
+        fmt += ' | <level>{extra}</level>'
+    return fmt + '\n'
+
+def init_app(app):
+    init_logger(app,False)
+
+def init_cli(app):
+    init_logger(app,True)
+
+
+def init_logger(app, cli):
+    # configure logger
+    
+    logger.remove()
+    logger.add(sys.stderr if cli else sys.stdout, format=logger_dynamic_formatter, level=app.config['STDOUT_LOG_LEVEL'],
+               colorize=True, catch=True, enqueue=True, diagnose=False, backtrace=True)
+    logger.trace('Logger initiated :)')
+
+    with app.app_context():
+        from hiddifypanel.models.config import hconfig,ConfigEnum
+        set_level(app,hconfig(ConfigEnum.log_level))
+
+
+def set_level(app, level):
+    logger.add(app.config['HIDDIFY_CONFIG_PATH'] + "/log/system/panel.log", format=logger_dynamic_formatter, level=level,
+                   colorize=True, catch=True, enqueue=True, diagnose=False, backtrace=True)

hiddifypanel/panel/node/__init__.py

@@ -0,0 +1,9 @@
+from flask import Flask
+
+
+
+
+from . import test_pb2_grpc
+from .hello import HelloServicer
+def init_app(app:Flask):
+    test_pb2_grpc.add_HelloServicer_to_server(HelloServicer(),app.wsgi_app)

hiddifypanel/panel/node/a.py

@@ -0,0 +1,14 @@
+import asyncio
+from . import test_pb2_grpc 
+import sonora.aio
+from .test_pb2 import HelloRequest
+
+
+async def temp():
+    async with sonora.aio.insecure_web_channel(f"http://localhost:9000") as channel:
+        stub = test_pb2_grpc.HelloStub(channel)
+        print(await stub.SayHello(HelloRequest(req="F")))
+
+
+
+asyncio.run(temp())

hiddifypanel/panel/node/hello.py

@@ -0,0 +1,15 @@
+import grpc
+
+# from hiddifypanel.hasync.config import BoolConfig 
+from hiddifypanel.models.config import hconfig
+from hiddifypanel.models.config_enum import ConfigEnum
+from . import test_pb2
+from . import test_pb2_grpc
+from quart import current_app
+
+class HelloServicer(test_pb2_grpc.HelloServicer):
+    """Missing associated documentation comment in .proto file."""
+
+    def SayHello(self, request: test_pb2.HelloRequest, context) -> test_pb2.HelloResponse:
+            
+            return test_pb2.HelloResponse(res=hconfig(ConfigEnum.log_level))

hiddifypanel/panel/node/test.proto

@@ -0,0 +1,13 @@
+syntax = "proto3";
+
+message HelloRequest {
+    string req = 1;
+}
+
+message HelloResponse {
+    string res = 1;
+}
+
+service Hello {
+    rpc SayHello (HelloRequest) returns (HelloResponse);
+}

hiddifypanel/panel/node/test_grpc.py

@@ -0,0 +1,40 @@
+# Generated by the Protocol Buffers compiler. DO NOT EDIT!
+# source: hiddifypanel/async/node/test.proto
+# plugin: grpclib.plugin.main
+import abc
+import typing
+
+import grpclib.const
+import grpclib.client
+if typing.TYPE_CHECKING:
+    import grpclib.server
+
+import hiddifypanel.hasync.node.test_pb2
+
+
+class HelloBase(abc.ABC):
+
+    @abc.abstractmethod
+    async def SayHello(self, stream: 'grpclib.server.Stream[hiddifypanel.hasync.node.test_pb2.HelloRequest, hiddifypanel.hasync.node.test_pb2.HelloResponse]') -> None:
+        pass
+
+    def __mapping__(self) -> typing.Dict[str, grpclib.const.Handler]:
+        return {
+            '/Hello/SayHello': grpclib.const.Handler(
+                self.SayHello,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                hiddifypanel.hasync.node.test_pb2.HelloRequest,
+                hiddifypanel.hasync.node.test_pb2.HelloResponse,
+            ),
+        }
+
+
+class HelloStub:
+
+    def __init__(self, channel: grpclib.client.Channel) -> None:
+        self.SayHello = grpclib.client.UnaryUnaryMethod(
+            channel,
+            '/Hello/SayHello',
+            hiddifypanel.hasync.node.test_pb2.HelloRequest,
+            hiddifypanel.hasync.node.test_pb2.HelloResponse,
+        )

hiddifypanel/panel/node/test_pb2.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: hiddifypanel/panel/node/test.proto
+# Protobuf Python Version: 5.27.2
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    5,
+    27,
+    2,
+    '',
+    'hiddifypanel/panel/node/test.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\"hiddifypanel/panel/node/test.proto\"\x1b\n\x0cHelloRequest\x12\x0b\n\x03req\x18\x01 \x01(\t\"\x1c\n\rHelloResponse\x12\x0b\n\x03res\x18\x01 \x01(\t22\n\x05Hello\x12)\n\x08SayHello\x12\r.HelloRequest\x1a\x0e.HelloResponseb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'hiddifypanel.panel.node.test_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_HELLOREQUEST']._serialized_start=38
+  _globals['_HELLOREQUEST']._serialized_end=65
+  _globals['_HELLORESPONSE']._serialized_start=67
+  _globals['_HELLORESPONSE']._serialized_end=95
+  _globals['_HELLO']._serialized_start=97
+  _globals['_HELLO']._serialized_end=147
+# @@protoc_insertion_point(module_scope)