gluerpy 0.0.0__py3-none-any.whl

gluerpy/client.py

@@ -0,0 +1,305 @@
+import asyncio
+import traceback
+import time
+import json
+import uuid
+import sys
+import os
+import importlib
+import random
+import websockets
+# from websockets.sync.client import connect
+
+# from mako.lookup import TemplateLookup
+# from mako.template import Template
+
+project = "sm"
+websocket_url = "wss://ws.gluer.io/server"
+session_id = f'ws-{str(uuid.uuid4())}'
+heartbeat_interval = 5
+retry_delay = 5
+ws = None
+
+imported_files = {}
+methods_map = {}
+
+
+def set_project(p):
+    global project
+    project = p
+
+
+def set_websocket_url(url):
+    global websocket_url
+    websocket_url = url
+
+
+# async def start():
+    # print("Start")
+    # sub_server()
+    # await asyncio.get_event_loop().run_until_complete(start_ws())
+    # await asyncio.to_thread(queue())
+
+def build_header_from_message(job):
+    smh = job["smh"].split(":")
+    return {"d": smh[0], "session_id": smh[1].split('>'), "project": smh[2], "plugin": smh[3] or "", "action": smh[4] or ""}
+
+
+def build_message_from_header(header):
+    return f'{header["d"]}:{">".join(header["session_id"])}>{session_id}:{header["project"]}:{header["plugin"] or ""}:{header["action"] or ""}'
+
+
+async def on_message(wsapp, message):
+    global methods_map
+    print("MethodsMap",methods_map)
+
+    job = json.loads(message)
+    header = build_header_from_message(job)
+    job["smh"] = build_message_from_header(header)
+    print("header")
+    print(header)
+    try:
+        mtd = None
+        print(header["plugin"])
+        print(methods_map)
+        print(methods_map[header["plugin"]])
+        if header["plugin"] in methods_map and header["action"] in methods_map[header["plugin"]]:
+            mtd = methods_map[header["plugin"]][header["action"]]
+        elif header["plugin"] in imported_files:
+            if hasattr(imported_files[header["plugin"]], header["action"]):
+                mtd = getattr(
+                    imported_files[header["plugin"]], header["action"])
+        if mtd:
+            ret = None
+            if "data" in job:
+                ret = mtd(job["data"])
+            else:
+                ret = mtd(job)
+            # print("Pre Process")
+            process_dict(ret)
+            # print(ret)
+            # print("Post Process")
+            job["data"] = ret
+            # if "htmx" in job:
+            #     # print("HTMX found")
+            #     try:
+            #         act_template = lookup.get_template(
+            #             f'{header["plugin"]}/{header["action"]}.mako')
+            #         # print("act_template")
+            #         # print(act_template)
+            #         if act_template:
+            #             # print("Template Found")
+            #             # print(ret)
+            #             # print(job["data"])
+            #             job["data"] = act_template.render(data=ret)
+            #             # print(job["data"])
+            #     except Exception as error:
+            #         print(error)
+        else:
+            job["data"] = {
+                "error": f"no server actions found for {header['plugin']}:{header['action']}"
+            }
+    except Exception as error:
+        print("ERROR")
+        print(traceback.format_exc())
+        # print(error)
+        error_handler(job, error)
+    # if "ws" in job:
+
+    job["smh"] = "<" + job["smh"][1:]
+    # print("Sending job back")
+    # print(job["data"])
+    # job["d"] = "<"
+    await wsapp.send(json.dumps(job))
+
+
+def on_open(ws):
+    print("Opened")
+    job = f'{{"smh":"+:{session_id}:{project}","channel":"{session_id},{project}"}}'
+    ws.send(job)
+
+
+def on_error(ws, error):
+    print("Error")
+    print(ws)
+    print(error)
+    # job = f'{{"smh":"+:{session_id}:{project}","channel":"{session_id},{project}"}}'
+    # ws.send(job)
+
+
+async def connect():
+    global ws
+    while True:
+            try:
+                print(f"Connecting to {websocket_url}...")
+                async with websockets.connect(f'{websocket_url}/{project}/{session_id}') as websocket:
+                    print(f"Connected to {websocket_url}")
+
+                    # job = f'{{"smh":"+:{session_id}:{project}","channel":"{session_id},{project}"}}'
+                    # await websocket.send(job)
+                    # print(f"Sent custom message: {custom_message}")
+
+                    # Send a greeting message after successful connection
+                    # await websocket.send("Hello, WebSocket server!")
+
+                    while True:
+                        try:
+                            message = await websocket.recv()
+                            if message is None:
+                                print("Received None, connection may be closed. Reconnecting...")
+                                break # Break the inner loop to reconnect
+                            print(f"Received: {message}")
+                            await on_message(websocket, message)
+                            # You can add your message handling logic here.
+                            # For example, you might want to check for specific messages
+                            # and respond accordingly.  Or, process the data.
+                        except websockets.ConnectionClosedError:
+                            print("Connection closed unexpectedly. Reconnecting...")
+                            break # Break the inner loop to reconnect
+                        except websockets.ConnectionClosedOK:
+                            print("Connection closed normally. Reconnecting...")
+                            break
+                        except Exception as e:
+                            print(f"Error receiving message: {e}. Reconnecting...")
+                            break # Exit inner loop, try to reconnect
+            except ConnectionRefusedError:
+                print("Connection refused. Server may not be running or is busy.")
+                break # Don't reconnect, since the server refused.  Exit the outer loop
+            except OSError as e:
+                if e.errno in (54, 61, 64): # Connection reset, connection refused, host down
+                    print(f"Network error: {e}.  Attempting to reconnect...")
+                else:
+                    print(f"OS error: {e}.  Reconnecting...")
+            except Exception as e:
+                print(f"Error: {e}")
+                print("An unexpected error occurred.  Check network, server, and code.")
+                #  Consider different strategies here.  For example, you might
+                #  want to exit after a few unknown errors, or perhaps
+                #  log the error to a file.  For this example, we'll just
+                #  keep trying to reconnect.
+            # Use exponential backoff to avoid overwhelming the server with rapid reconnect attempts.
+            delay = random.uniform(1, 5)  # Introduce some random jitter
+            print(f"Reconnecting in {delay:.2f} seconds...")
+            await asyncio.sleep(delay)    
+    # with connect(websocket_url) as websocket:
+        # ws = websocket
+        # websocket.send("Hello world!")
+        # message = websocket.recv()
+        # print(f"Received: {message}")    
+    # with connect(websocket_url) as websocket:
+    # ws = websocket
+    # message = websocket.recv()
+    # print(f"Received: {message}")
+    # websocket.enableTrace(false)
+    # ws = websocket.WebSocketApp(
+    #     websocket_url, on_message=on_message, on_open=on_open, on_error=on_error)
+    # ws.run_forever(dispatcher=rel, ping_interval=60, ping_timeout=10, reconnect=5,
+    #                ping_payload="This is an optional ping payload")
+
+    # rel.dispatch()
+
+
+lookup = None
+
+
+def import_directories(path):
+    global lookup
+    files = os.listdir(path)
+    # print(files)
+    sys.path.append(path)
+    for file in files:
+        if file.endswith(".py"):
+            try:
+                file = file[:-3]
+                imported_files.setdefault(file, importlib.import_module(file))
+                print(f"Imported {file}")
+            except ImportError as err:
+                print('Error:', err)
+    # lookup = TemplateLookup(directories=[f'{path}/templates'])
+
+
+def add_method(plugin, action, fn):
+    global methods_map
+    print("Adding method", plugin, action)
+    methods_map.setdefault(plugin, {})
+    methods_map[plugin].setdefault(action, fn)
+
+def register_plugin(plugin_name: str, fn_name: str, fn: callable):
+    global methods_map    
+    """
+    Registers a function under a given plugin name.
+
+    Args:
+        plugin_name: The name of the plugin.
+        fn_name: The name of the function to register.
+        fn: The function object.
+    """
+    fn_map = {fn_name: fn}
+    if plugin_name not in methods_map:
+        methods_map[plugin_name] = {}
+    methods_map[plugin_name].update(fn_map)
+
+def register_object(plugin_name: str, obj: object):
+    """
+    Registers all methods of an object under a given plugin name.
+
+    Args:
+        plugin_name: The name of the plugin.
+        obj: The object whose methods will be registered.
+    """
+    methods = [
+        method_name for method_name in dir(obj)
+        if callable(getattr(obj, method_name)) and not method_name.startswith("__")
+    ]
+    print("methods",methods)
+    for method_name in methods:
+        method = getattr(obj, method_name)
+        register_plugin(plugin_name, method_name, method)
+    # print('Methods', methods)
+
+def error_handler(job, error):
+    job["data"] = {"error": {
+        "message": error.content[0]['message'], "code": error.content[0]['errorCode']}}
+
+
+def set_error_handler(fn):
+    global error_handler
+    error_handler = fn
+
+
+def process_dict(data):
+    for key, value in data.items():
+        # Check if the value has a 'model_dump' method
+        if hasattr(value, "model_dump") and callable(getattr(value, "model_dump")):
+            # Call model_dump() if it's available and callable
+            data[key] = value.model_dump()
+        elif isinstance(value, dict):
+            # If the value is a nested dictionary, recursively process it
+            process_dict(value)
+        elif isinstance(value, list):
+            # If the value is a list, process each item
+            for i, item in enumerate(value):
+                if hasattr(item, "model_dump") and callable(getattr(item, "model_dump")):
+                    value[i] = item.model_dump()
+                elif isinstance(item, dict):
+                    process_dict(item)
+
+def start():
+    asyncio.run(connect())
+    # """
+    # Main function to start the WebSocket client.  Allows user to specify the URI.
+    # """
+    # await start()
+
+# if __name__ == '__main__':
+    # asyncio.run(main())
+    # print('start')
+    # redis.set_user("Teste")
+#     try:
+#         # loop = asyncio.get_event_loop()
+#         # loop.run_until_complete(start())
+#         asyncio.run(start())
+#     except Exception as error:
+#         print(error)
+#         traceback.print_exc()
+#     # asyncio.run(start())

gluerpy/client_redis.py

@@ -0,0 +1,269 @@
+import datetime
+import asyncio
+import threading
+import traceback
+import time
+import json
+import uuid
+import sys
+import os
+import importlib
+import redis
+
+import gluer.lib.redis_lib as redis_lib
+import gluer.lib.acl as acl
+
+project = "sm"
+session_id = str(uuid.uuid4())
+heartbeat_interval = 5
+retry_delay = 5
+
+imported_files = {}
+methods_map = {}
+
+# ssh -R 80:localhost:9001 serveo.net
+# autossh -M 0 -R gluer.serveo.net:80:localhost:9001 serveo.net
+# autossh -M 0 -R gluer:80:localhost:9001 serveo.net
+# ssh -R gluer.serveo.net:443:localhost:9001 serveo.net
+# ssh -R 443:localhost:9001 serveo.net
+
+# def import_directories():
+#     files = os.listdir('./plugins')
+#     # print(files)
+#     sys.path.append('./plugins')
+#     for file in files:
+#         if file.endswith(".py"):
+#             try:
+#                 file = file[:-3]
+#                 imported_files.setdefault(file, importlib.import_module(file))
+#             except ImportError as err:
+#                 print('Error:', err)
+#     # print(imported_files)
+
+
+def set_project(p):
+    global project
+    project = p
+
+
+def set_user(u):
+    redis_lib.set_redis_user(u)
+
+
+def set_password(p):
+    redis_lib.set_redis_password(p)
+
+
+def set_redis_url(url):
+    redis_lib.set_redis_url(url)
+
+
+def set_redis_api_key(key):
+    acl.set_api_key(key)
+
+
+def set_redis_api_secret(secret):
+    acl.set_api_secret(secret)
+
+
+async def start():
+    # print("Start")
+    sub_server()
+    await asyncio.to_thread(queue())
+
+
+def import_directories(path):
+    files = os.listdir(path)
+    # print(files)
+    sys.path.append(path)
+    for file in files:
+        if file.endswith(".py"):
+            try:
+                file = file[:-3]
+                imported_files.setdefault(file, importlib.import_module(file))
+                print(f"Imported {file}")
+            except ImportError as err:
+                print('Error:', err)
+
+
+def sub_server():
+    print("Sub Server")
+    # r = await redis.from_url("redis://admin:V!6xU8Kf*sQqJS@redis-10264.c277.us-east-1-3.ec2.redns.redis-cloud.com:10264")
+
+    # acl.create_acl("test2", "test123")
+    ev = {
+        "channel": f'{project}:bl',
+        "action": "server_up",
+        "created": time.time_ns()
+    }
+    # get_redis_connection().hset(
+    #     f'pp1:servers:{session_id}', mapping=session_data)
+    # get_redis_connection().expire(
+    #     f'pp1:servers:{session_id}', heartbeat_interval)
+    # ev = {
+    #     "channel": f'{project}:bl',
+    #     "action": "server_up",
+    #     "created": time.time_ns()
+    # }
+    redis_lib.get_redis_connection().publish(f'{project}:bl', json.dumps(ev))
+    pubsub = redis_lib.get_redis_connection().pubsub()
+    subscribe_channel(pubsub, f'{project}:br')
+
+    # update_redis_hash()
+    # Run the update_redis_hash function in a separate thread
+    interval_thread = threading.Thread(target=update_redis_hash)
+    interval_thread.daemon = True  # Daemon thread will exit when the main program exits
+    interval_thread.start()
+
+# while True:
+#     try:
+#         # Listen for messages
+#         for message in pubsub.listen():
+#             if message['type'] == 'message':
+#                 print(f"Message received: {message['data']}")
+
+#     except Exception as e:
+#         time.sleep(5)
+#         pubsub = get_redis_connection().pubsub()
+#         subscribe_channel(pubsub, f'{project}:br')
+
+
+def update_redis_hash():
+    while True:
+        session_data = {
+            "type": "plugin",
+            "sessionId": session_id,
+            "project": project
+        }
+        try:
+            redis_lib.get_redis_connection().hset(
+                f'pp1:servers:{session_id}', mapping=session_data)
+            redis_lib.get_redis_connection().expire(
+                f'pp1:servers:{session_id}', heartbeat_interval)
+            # print("Ping Redis", session_id)
+            time.sleep(heartbeat_interval-1)
+        except (redis.exceptions.ConnectionError, redis.exceptions.TimeoutError) as e:
+            print(e)
+        except Exception as e:
+            print(e)
+
+
+def message_handler(message):
+    print("message_handler")
+    print(message.get("data"))
+    job = json.loads(message.get("data"))
+    job["connected"] = True
+    if "action" in job and job["action"] == "ping":
+        print("PING")
+        if "ws" in job:
+            redis_lib.get_redis_connection().rpush(
+                job["ws"], json.dumps(job))
+            redis_lib.get_redis_connection().expire(
+                job["ws"], 60)
+        # redis_lib.get_redis_connection().publish(f'{project}:bl', json.dumps(job))
+
+    elif "plugin" in job and job["plugin"] in imported_files:
+        if hasattr(imported_files[job["plugin"]], job["action"]):
+            mtd = getattr(
+                imported_files[job["plugin"]], job["action"])
+            ret = mtd(job["data"])
+            job["data"] = ret
+            print('job with data')
+            print(job)
+            if "ws" in job:
+                redis_lib.get_redis_connection().rpush(
+                    job["ws"], json.dumps(job))
+                redis_lib.get_redis_connection().expire(
+                    job["ws"], 60)
+
+
+def subscribe_channel(pubsub, channel):
+    print("Subscribe", channel)
+    # pubsub.subscribe(channel)
+    pubsub.subscribe(**{channel: message_handler})
+    pubsub.run_in_thread(sleep_time=0.001)
+
+
+def add_method(plugin, action, fn):
+    print("Adding method", plugin, action)
+    methods_map.setdefault(plugin, {})
+    methods_map[plugin].setdefault(action, fn)
+
+
+def error_handler(job, error):
+    job["data"] = {"error": {
+        "message": error.content[0]['message'], "code": error.content[0]['errorCode']}}
+
+
+def set_error_handler(fn):
+    global error_handler
+    error_handler = fn
+
+
+def queue():
+    # print('Queue')
+    # r = await redis.from_url("redis://admin:V!6xU8Kf*sQqJS@redis-10264.c277.us-east-1-3.ec2.redns.redis-cloud.com:10264")
+    while True:
+        # print(f'{project}:r')
+        try:
+            val = redis_lib.get_redis_connection().blpop(f'{project}:r', 5)
+            if val:
+                job = json.loads(val[1])
+                try:
+                    mtd = None
+                    if job["plugin"] in methods_map and job["action"] in methods_map[job["plugin"]]:
+                        mtd = methods_map[job["plugin"]][job["action"]]
+                    elif job["plugin"] in imported_files:
+                        if hasattr(imported_files[job["plugin"]], job["action"]):
+                            mtd = getattr(
+                                imported_files[job["plugin"]], job["action"])
+                    if mtd:
+                        ret = None
+                        if "data" in job:
+                            ret = mtd(job["data"])
+                        else:
+                            ret = mtd(job)
+                        job["data"] = ret
+                    else:
+                        job["data"] = {
+                            "error": f"no server actions found for {job['plugin']}:{job['action']}"
+                        }
+                except Exception as error:
+                    print("ERROR")
+                    print(traceback.format_exc())
+                    # print(error)
+                    error_handler(job, error)
+                if "ws" in job:
+                    redis_lib.get_redis_connection().rpush(
+                        job["ws"], json.dumps(job))
+                    redis_lib.get_redis_connection().expire(
+                        job["ws"], 60)
+        except (redis.exceptions.ConnectionError, redis.exceptions.TimeoutError) as e:
+            print("Redis connection lost. Reconnecting...")
+            print(e)
+            time.sleep(retry_delay)
+
+        except redis.exceptions.RedisError as e:
+            # Catch other general Redis-related exceptions
+            print("General Redis error")
+            print(e)
+            # traceback.print_exc()
+
+        except Exception as error:
+            print("Unexpected error on brpop queue")
+            print(error)
+
+def queue_ws():
+    print("Queue WS")
+
+if __name__ == '__main__':
+    print('start')
+    # redis.set_user("Teste")
+#     try:
+#         # loop = asyncio.get_event_loop()
+#         # loop.run_until_complete(start())
+#         asyncio.run(start())
+#     except Exception as error:
+#         print(error)
+#         traceback.print_exc()
+#     # asyncio.run(start())

gluerpy/lib/acl.py

@@ -0,0 +1,148 @@
+import requests
+import time
+import os
+
+API_KEY = os.getenv('REDIS_API_KEY',None)
+API_SECRET_KEY = os.getenv('REDIS_API_SECRET',None)
+
+headers = {
+    "x-api-key": "Ay9adtha5prx8za3413t4v9y5vptrvst1aulowgz6r30uz2oa7",
+    "x-api-secret-key": "S3ctl9u1zjg5cbcyma38bgnbrq6q2ia6pud7lwvaonramcpanq9",
+    "Content-Type": "application/json"
+}
+
+
+def set_api_key(key):
+    API_KEY = key
+
+
+def set_api_secret(secret):
+    API_SECRET_KEY = secret
+
+
+def check_task_status(task_url):
+    while True:
+        response = requests.get(task_url, headers=headers)
+        if response.status_code == 200:
+            task_status = response.json()
+            status = task_status.get('status')
+
+            if status == 'processing-completed':
+                return task_status
+            elif status in ['received', 'processing', 'processing-in-progress']:
+                print(f"Task is still processing: {status}")
+                time.sleep(5)  # Non-blocking sleep
+            elif status == 'processing-error':
+                raise Exception(
+                    f"Task failed with status: {status}. Error details: {task_status.get('response', {}).get('error', {}).get('description', 'No details provided')}")
+            else:
+                raise Exception(f"Unexpected task status: {status}")
+        else:
+            response.raise_for_status()
+
+
+def create_acl(name, password):
+    rule = create_rule(name)
+    role = create_role(name)
+    user = create_user(name, password)
+    print("ACL Created")
+    print(rule)
+    print(role)
+    print(user)
+    return {"rule": rule, "role": role, "user": user}
+
+
+def delete_acl(name):
+    delete_user(name)
+    # create_rule(name)
+    # create_role(name)
+
+
+def create_rule(name):
+    print('Create Rule')
+    print(name)
+    data = {
+        "name": name,
+        "redisRule": f'+hset +unlink +pubsub +subscribe +brpop +blpop +rpush +lpush ~{name}* +pubsub ~pp1:* ~ws:*'
+    }
+    print(data)
+    response = requests.post(
+        'https://api.redislabs.com/v1/acl/redisRules', json=data, headers=headers)
+    response.raise_for_status()
+    data = response.json()
+    print(data)
+    if "links" in data and len(data["links"]) > 0:
+        status = check_task_status(data["links"][0]["href"])
+        print(status)
+        return status.get('response').get('resourceId')
+
+
+def create_role(name):
+    data = {
+        "name": name,
+        "redisRules": [
+            {
+                "ruleName": name,
+                "databases": [
+                    {
+                        "subscriptionId": 2350147,
+                        "databaseId": 12364997
+                    }
+                ]
+            }
+        ]
+    }
+    response = requests.post(
+        'https://api.redislabs.com/v1/acl/roles', json=data, headers=headers)
+    response.raise_for_status()
+    data = response.json()
+    print(data)
+    if "links" in data and len(data["links"]) > 0:
+        status = check_task_status(data["links"][0]["href"])
+        print(status)
+        return status.get('response').get('resourceId')
+
+
+def create_user(name, password):
+    if not password:
+        passowrd = generate_random_password()
+    data = {
+        "name": name,
+        "role": name,
+        "password": password
+    }
+    response = requests.post(
+        'https://api.redislabs.com/v1/acl/users', json=data, headers=headers)
+    response.raise_for_status()
+    data = response.json()
+    print(data)
+    if "links" in data and len(data["links"]) > 0:
+        status = check_task_status(data["links"][0]["href"])
+        print(status)
+        return status.get('response').get('resourceId')
+    # return data
+
+
+def delete_user(name):
+    data = {
+        "name": name,
+        "role": name,
+        "password": password
+    }
+    response = requests.post(
+        'https://api.redislabs.com/v1/acl/users', json=data, headers=headers)
+    response.raise_for_status()
+    data = response.json()
+    print(data)
+    if "links" in data and len(data["links"]) > 0:
+        status = check_task_status(data["links"][0]["href"])
+        print(status)
+    return data
+
+
+def generate_random_password(length=12):
+    # Define the character sets to use
+    characters = string.ascii_letters + string.digits + '!@$'
+    # Generate a random password
+    password = ''.join(random.choice(characters) for _ in range(length))
+    return password

gluerpy/lib/redis_lib.py

@@ -0,0 +1,69 @@
+# redis_connection.py
+import redis
+import os
+
+redis_client = None
+redis_pubsub = None
+
+redis_url = os.getenv('REDIS_URL', None)
+redis_user = os.getenv('REDIS_USER', None)
+redis_password = os.getenv('REDIS_PASSWORD', None)
+redis_host = os.getenv(
+    'REDIS_HOST', "redis-10264.c277.us-east-1-3.ec2.redns.redis-cloud.com")
+redis_port = os.getenv('REDIS_PORT', "10264")
+
+
+def set_redis_url(u):
+    global redis_url
+    redis_url = u
+
+
+def set_redis_user(u):
+    global redis_user
+    redis_user = u
+
+
+def set_redis_password(p):
+    global redis_password
+    redis_password = p
+
+
+events = {}
+
+# pool = None
+# r = redis.Redis(connection_pool=pool)
+
+
+def get_url():
+    global redis_url, redis_user, redis_password
+    if redis_url:
+        return redis_url
+    elif redis_user and redis_password:
+        return f"redis://{redis_user}:{redis_password}@{redis_host}:{redis_port}"
+
+
+def get_redis_connection():
+    global redis_client, redis_url
+    if redis_client is None:
+        redis_client = redis.from_url(redis_url,
+                                      decode_responses=True)
+    return redis_client
+    # if pool is None:
+        # pool = redis.ConnectionPool.from_url(get_url())
+    # return redis.Redis(connection_pool=pool, decode_responses=True)
+
+    # if redis_client is None:
+    #     if redis_user and redis_password:
+    #         redis_url = f"redis://{redis_user}:{redis_password}@redis-10264.c277.us-east-1-3.ec2.redns.redis-cloud.com:10264"
+    #     redis_client = redis.from_url(redis_url,
+    #                                   decode_responses=True)
+    #     # redis_client = redis.Redis(
+    #     #     host='localhost', port=6379, decode_responses=True)
+
+
+def get_redis_pubsub():
+    global redis_pubsub
+    if redis_pubsub is None:
+        redis_pubsub = get_redis_connection().pubsub()
+        redis_pubsub.run_in_thread(sleep_time=0.001)
+    return redis_pubsub

gluerpy-0.0.0.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: gluerpy
+Version: 0.0.0
+Summary: Python library to connect to gluer services
+Home-page: https://www.gluer.io
+Author: Thiago Magro
+Author-email: thiago.magro@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: redis
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+Gluer Library for Python

gluerpy-0.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+gluerpy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gluerpy/client.py,sha256=YYmMnbVs_yPUD8-ekR4A3_BOF5JxPAcfYHNkwjlfS-w,10874
+gluerpy/client_redis.py,sha256=P1x24i9it9p7H0mNAp-8ZfiuohDvCItneSJiQeoLwSU,8355
+gluerpy/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gluerpy/lib/acl.py,sha256=7laiX-NqpzqTb3LXlZkk6LBGQPBPir_6vxnmupyx_D4,4342
+gluerpy/lib/redis_lib.py,sha256=hjPGkacuiJLHYrEj-5rg3rMcAm83lp63BPetvrlY964,1891
+gluerpy-0.0.0.dist-info/METADATA,sha256=qa0nCzymQVu-HVpWrJV6oI4x4siHtGV-XizQrvIONrs,647
+gluerpy-0.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+gluerpy-0.0.0.dist-info/top_level.txt,sha256=CDQjbVgZAl4XVoo2vzvPCKwq1t6aRSD3GEyJ4G_iroE,8
+gluerpy-0.0.0.dist-info/RECORD,,

gluerpy-0.0.0.dist-info/WHEEL

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

gluerpy-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+gluerpy