authlyx-api 0.1.0__py3-none-any.whl

authlyx_api/__init__.py

@@ -0,0 +1,5 @@
+from .sdk import Auth, AuthlyX
+
+__all__ = ["Auth", "AuthlyX"]
+__version__ = "0.1.0"
+

authlyx_api/sdk.py

@@ -0,0 +1,573 @@
+import requests
+import json
+import uuid
+import hashlib
+import os
+import sys
+import re
+import time
+import subprocess
+from datetime import datetime, timezone
+
+
+class AuthlyXLogger:
+    Enabled = True
+    AppName = "AuthlyX"
+
+    @staticmethod
+    def _mask_sensitive(text):
+        if not text:
+            return text
+        patterns = [
+            r'("session_id"\s*:\s*")([^"]+)(")',
+            r'("owner_id"\s*:\s*")([^"]+)(")',
+            r'("secret"\s*:\s*")([^"]+)(")',
+            r'("password"\s*:\s*")([^"]+)(")',
+            r'("key"\s*:\s*")([^"]+)(")',
+            r'("license_key"\s*:\s*")([^"]+)(")',
+            r'("hash"\s*:\s*")([^"]+)(")',
+            r'("request_id"\s*:\s*")([^"]+)(")',
+            r'("nonce"\s*:\s*")([^"]+)(")',
+            r'("hwid"\s*:\s*")([^"]+)(")',
+            r'("sid"\s*:\s*")([^"]+)(")',
+            r'(\bx-auth-signature\s*:\s*)([A-Za-z0-9+/=]+)',
+            r'(\bx-v2-signature\s*:\s*)([A-Za-z0-9+/=]+)',
+        ]
+        out = str(text)
+        for p in patterns:
+            out = re.sub(
+                p,
+                lambda m: (m.group(1) + "***" + (m.group(3) if m.lastindex and m.lastindex >= 3 else "")),
+                out,
+                flags=re.IGNORECASE,
+            )
+        return out
+
+    @staticmethod
+    def Log(content):
+        if not AuthlyXLogger.Enabled:
+            return
+        if content is None:
+            return
+        s = str(content)
+        if not s.strip():
+            return
+        try:
+            app = (AuthlyXLogger.AppName or "default").strip() or "default"
+            program_data = os.environ.get("PROGRAMDATA") or ""
+            root = os.path.join(program_data, "AuthlyX", app)
+            os.makedirs(root, exist_ok=True)
+            log_path = os.path.join(root, f"{datetime.now(timezone.utc):%Y_%m_%d}.log")
+            line = f"[{datetime.now(timezone.utc):%H:%M:%S}] {AuthlyXLogger._mask_sensitive(s)}\n"
+            with open(log_path, "a", encoding="utf-8") as f:
+                f.write(line)
+        except Exception:
+            return
+
+
+class Auth:
+    DefaultBaseUrl = "https://authly.cc/api/v2"
+    IpLookupUrl = "https://api.ipify.org"
+
+    def __init__(self, ownerId, appName, version, secret, debug=True, api=None):
+        self.ownerId = ownerId or ""
+        self.appName = appName or ""
+        self.version = version or ""
+        self.secret = secret or ""
+        self.baseUrl = self._normalize_base_url(api or Auth.DefaultBaseUrl)
+        self.loggingEnabled = True if debug is None else bool(debug)
+
+        AuthlyXLogger.AppName = self.appName or "AuthlyX"
+        AuthlyXLogger.Enabled = self.loggingEnabled
+
+        self.sessionId = ""
+        self.applicationHash = ""
+        self.initialized = False
+        self.cachedPublicIp = ""
+        self.cachedPublicIpExpiresAt = 0.0
+
+        self.response = {
+            "success": False,
+            "message": "",
+            "raw": "",
+            "code": "",
+            "status_code": 0,
+            "request_id": "",
+            "nonce": "",
+            "signature_kid": "",
+        }
+
+        self.userData = {
+            "Username": "",
+            "Email": "",
+            "LicenseKey": "",
+            "Subscription": "",
+            "SubscriptionLevel": "",
+            "ExpiryDate": "",
+            "DaysLeft": 0,
+            "LastLogin": "",
+            "Hwid": "",
+            "IpAddress": "",
+            "RegisteredAt": "",
+        }
+
+        self.variableData = {"VarKey": "", "VarValue": "", "UpdatedAt": ""}
+
+        self.updateData = {
+            "Available": False,
+            "LatestVersion": "",
+            "DownloadUrl": "",
+            "ForceUpdate": False,
+            "Changelog": "",
+            "ShowReminder": False,
+            "ReminderMessage": "",
+            "AllowedUntil": "",
+        }
+
+        self.chatMessages = {
+            "ChannelName": "",
+            "Messages": [],
+            "Count": 0,
+            "NextCursor": "",
+            "HasMore": False,
+        }
+
+        self._calculate_application_hash()
+        AuthlyXLogger.Log(f"[SDK] AuthlyX initialized for app '{self.appName}' using '{self.baseUrl}'.")
+
+    def _normalize_base_url(self, api):
+        base = (api or "").strip()
+        if not base:
+            return Auth.DefaultBaseUrl
+        return base.rstrip("/")
+
+    def _reset_response(self):
+        self.response["success"] = False
+        self.response["message"] = ""
+        self.response["raw"] = ""
+        self.response["code"] = ""
+        self.response["status_code"] = 0
+        self.response["request_id"] = ""
+        self.response["nonce"] = ""
+        self.response["signature_kid"] = ""
+
+    def _set_failure(self, code, message, raw="", status_code=0):
+        self.response["success"] = False
+        self.response["code"] = code or ""
+        self.response["message"] = message or ""
+        self.response["raw"] = raw or ""
+        self.response["status_code"] = int(status_code or 0)
+        return False
+
+    def _has_required_credentials(self):
+        return bool(self.ownerId and self.appName and self.version and self.secret)
+
+    def _canonical_json(self, obj):
+        return json.dumps(obj, separators=(",", ":"), sort_keys=True, ensure_ascii=False)
+
+    def _create_security_context(self):
+        request_id = str(uuid.uuid4())
+        nonce = os.urandom(16).hex()
+        ts = int(time.time() * 1000)
+        return request_id, nonce, ts
+
+    def _calculate_application_hash(self):
+        try:
+            path = sys.executable
+            if not path or not os.path.exists(path):
+                path = os.path.abspath(sys.argv[0]) if sys.argv and sys.argv[0] else ""
+            if not path or not os.path.exists(path):
+                self.applicationHash = "UNKNOWN_HASH"
+                return
+            h = hashlib.sha256()
+            with open(path, "rb") as f:
+                while True:
+                    b = f.read(1024 * 1024)
+                    if not b:
+                        break
+                    h.update(b)
+            self.applicationHash = h.hexdigest()
+        except Exception:
+            self.applicationHash = "UNKNOWN_HASH"
+
+    def _get_windows_sid(self):
+        try:
+            out = subprocess.check_output(
+                ["whoami", "/user", "/fo", "csv", "/nh"],
+                stderr=subprocess.DEVNULL,
+                text=True,
+            ).strip()
+            if not out:
+                return ""
+            cols = [c.strip().strip('"') for c in out.split(",")]
+            for c in cols:
+                if c.startswith("S-1-"):
+                    return c
+            if len(cols) >= 2 and cols[1].startswith("S-1-"):
+                return cols[1]
+            return ""
+        except Exception:
+            return ""
+
+    def _get_system_identifier(self):
+        if sys.platform == "win32":
+            sid = self._get_windows_sid()
+            if sid:
+                return sid
+        try:
+            seed = (os.environ.get("USERNAME") or "") + "|" + (os.environ.get("COMPUTERNAME") or "") + "|" + (sys.platform or "")
+            return hashlib.sha256(seed.encode("utf-8", errors="ignore")).hexdigest()
+        except Exception:
+            return "UNKNOWN_SID"
+
+    def _get_public_ip(self):
+        now = time.time()
+        if self.cachedPublicIp and now < self.cachedPublicIpExpiresAt:
+            return self.cachedPublicIp
+        try:
+            r = requests.get(Auth.IpLookupUrl, timeout=10)
+            ip = (r.text or "").strip()
+            if ip:
+                self.cachedPublicIp = ip
+                self.cachedPublicIpExpiresAt = now + 600.0
+                return ip
+        except Exception:
+            return self.cachedPublicIp or ""
+        return ""
+
+    def _build_url(self, endpoint):
+        ep = (endpoint or "").lstrip("/")
+        return f"{self.baseUrl}/{ep}"
+
+    def _validate_response_metadata(self, headers, request_id, nonce):
+        resp_request_id = headers.get("x-v2-request-id") or ""
+        resp_nonce = headers.get("x-v2-nonce") or ""
+        sig_kid = headers.get("x-v2-signature-kid") or ""
+        if resp_request_id and resp_request_id != request_id:
+            return False, "AUTH_REQUEST_MISMATCH", "Response request_id does not match the original request.", sig_kid
+        if resp_nonce and resp_nonce != nonce:
+            return False, "AUTH_REQUEST_MISMATCH", "Response nonce does not match the original request.", sig_kid
+        return True, "", "", sig_kid
+
+    def _compute_days_left(self, expiry):
+        try:
+            if not expiry:
+                return 0
+            s = str(expiry).strip()
+            if not s:
+                return 0
+            if s.endswith("Z"):
+                dt = datetime.fromisoformat(s.replace("Z", "+00:00"))
+            else:
+                dt = datetime.fromisoformat(s)
+            diff = dt.timestamp() - time.time()
+            days = int(diff // (24 * 60 * 60))
+            return days if days > 0 else 0
+        except Exception:
+            return 0
+
+    def _load_update_data(self, obj):
+        try:
+            u = obj.get("update") if isinstance(obj, dict) else None
+            if not isinstance(u, dict):
+                return
+            self.updateData["Available"] = bool(u.get("available"))
+            self.updateData["LatestVersion"] = str(u.get("latest_version") or "")
+            self.updateData["DownloadUrl"] = u.get("download_url")
+            self.updateData["ForceUpdate"] = bool(u.get("force_update"))
+            self.updateData["Changelog"] = str(u.get("changelog") or "")
+            self.updateData["ShowReminder"] = bool(u.get("show_reminder"))
+            self.updateData["ReminderMessage"] = str(u.get("reminder_message") or "")
+            self.updateData["AllowedUntil"] = u.get("allowed_until")
+        except Exception:
+            return
+
+    def _load_user_data(self, obj):
+        if not isinstance(obj, dict):
+            return
+
+        user = obj.get("user") if isinstance(obj.get("user"), dict) else None
+        lic = obj.get("license") if isinstance(obj.get("license"), dict) else None
+        dev = obj.get("device") if isinstance(obj.get("device"), dict) else None
+
+        if user:
+            self.userData["Username"] = str(user.get("username") or "")
+            self.userData["Email"] = str(user.get("email") or self.userData.get("Email") or "")
+            self.userData["Subscription"] = str(user.get("subscription") or self.userData.get("Subscription") or "")
+            if user.get("subscription_level") is not None:
+                self.userData["SubscriptionLevel"] = str(user.get("subscription_level"))
+            self.userData["ExpiryDate"] = str(user.get("expiry_date") or self.userData.get("ExpiryDate") or "")
+            self.userData["LastLogin"] = str(user.get("last_login") or self.userData.get("LastLogin") or "")
+            self.userData["RegisteredAt"] = str(user.get("created_at") or user.get("registered_at") or self.userData.get("RegisteredAt") or "")
+            if user.get("ip_address"):
+                self.userData["IpAddress"] = str(user.get("ip_address") or "")
+            if user.get("sid") or user.get("hwid"):
+                self.userData["Hwid"] = str(user.get("sid") or user.get("hwid") or "")
+
+        if lic:
+            if lic.get("license_key"):
+                self.userData["LicenseKey"] = str(lic.get("license_key") or "")
+            if not self.userData.get("Subscription"):
+                self.userData["Subscription"] = str(lic.get("subscription") or "")
+            if not self.userData.get("SubscriptionLevel") and lic.get("subscription_level") is not None:
+                self.userData["SubscriptionLevel"] = str(lic.get("subscription_level"))
+            if not self.userData.get("ExpiryDate") and lic.get("expiry_date"):
+                self.userData["ExpiryDate"] = str(lic.get("expiry_date") or "")
+
+        if dev:
+            if not self.userData.get("Subscription") and dev.get("subscription"):
+                self.userData["Subscription"] = str(dev.get("subscription") or "")
+            if not self.userData.get("SubscriptionLevel") and dev.get("subscription_level") is not None:
+                self.userData["SubscriptionLevel"] = str(dev.get("subscription_level"))
+            if not self.userData.get("ExpiryDate") and dev.get("expiry_date"):
+                self.userData["ExpiryDate"] = str(dev.get("expiry_date") or "")
+            if not self.userData.get("LastLogin") and dev.get("last_login"):
+                self.userData["LastLogin"] = str(dev.get("last_login") or "")
+            if not self.userData.get("RegisteredAt") and (dev.get("registered_at") or dev.get("created_at")):
+                self.userData["RegisteredAt"] = str(dev.get("registered_at") or dev.get("created_at") or "")
+            if not self.userData.get("IpAddress") and dev.get("ip_address"):
+                self.userData["IpAddress"] = str(dev.get("ip_address") or "")
+            if not self.userData.get("Hwid") and (dev.get("hwid") or dev.get("sid")):
+                self.userData["Hwid"] = str(dev.get("sid") or dev.get("hwid") or "")
+
+        if not self.userData.get("Hwid"):
+            self.userData["Hwid"] = self._get_system_identifier()
+        if not self.userData.get("IpAddress"):
+            self.userData["IpAddress"] = self._get_public_ip()
+        self.userData["DaysLeft"] = self._compute_days_left(self.userData.get("ExpiryDate") or "")
+
+    def _load_variable_data(self, obj):
+        if not isinstance(obj, dict):
+            return
+        v = obj.get("variable") if isinstance(obj.get("variable"), dict) else None
+        if not v:
+            return
+        self.variableData["VarKey"] = str(v.get("var_key") or "")
+        self.variableData["VarValue"] = str(v.get("var_value") or "")
+        self.variableData["UpdatedAt"] = str(v.get("updated_at") or "")
+
+    def _load_chat_messages(self, obj):
+        if not isinstance(obj, dict):
+            return
+        chats = obj.get("chats") if isinstance(obj.get("chats"), dict) else None
+        if not chats:
+            return
+        self.chatMessages["ChannelName"] = str(chats.get("channel_name") or "")
+        self.chatMessages["Messages"] = chats.get("messages") if isinstance(chats.get("messages"), list) else []
+        self.chatMessages["Count"] = int(chats.get("count") or 0)
+        self.chatMessages["NextCursor"] = str(chats.get("next_cursor") or "")
+        self.chatMessages["HasMore"] = bool(chats.get("has_more"))
+
+    def _post_json(self, endpoint, payload):
+        self._reset_response()
+        if not self._has_required_credentials():
+            return self._set_failure("AUTH_CONFIG", "Missing AuthlyX credentials.")
+
+        url = self._build_url(endpoint)
+        request_id, nonce, ts = self._create_security_context()
+
+        body = dict(payload or {})
+        body["owner_id"] = self.ownerId
+        body["app_name"] = self.appName
+        body["version"] = self.version
+        body["secret"] = self.secret
+        body["request_id"] = request_id
+        body["nonce"] = nonce
+        body["timestamp"] = ts
+        body["hash"] = self.applicationHash
+
+        try:
+            AuthlyXLogger.Log(f"[SDK][REQUEST] POST {url} {self._canonical_json(body)}")
+            r = requests.post(
+                url,
+                json=body,
+                headers={
+                    "x-request-id": request_id,
+                    "x-auth-nonce": nonce,
+                    "x-auth-timestamp": str(ts),
+                },
+                timeout=20,
+            )
+            text = r.text or ""
+            AuthlyXLogger.Log(f"[SDK][RESPONSE] {r.status_code} {text}")
+
+            self.response["status_code"] = int(r.status_code)
+            self.response["raw"] = text
+            self.response["request_id"] = request_id
+            self.response["nonce"] = nonce
+
+            ok, code, msg, kid = self._validate_response_metadata(r.headers or {}, request_id, nonce)
+            self.response["signature_kid"] = kid or ""
+            if not ok:
+                return self._set_failure(code, msg, text, r.status_code)
+
+            obj = None
+            try:
+                obj = r.json()
+            except Exception:
+                return self._set_failure("BAD_RESPONSE", "Invalid JSON response.", text, r.status_code)
+
+            self.response["success"] = bool(obj.get("success"))
+            self.response["message"] = str(obj.get("message") or "")
+            self.response["code"] = str(obj.get("code") or "")
+
+            if obj.get("session_id"):
+                self.sessionId = str(obj.get("session_id") or "")
+
+            if endpoint == "init":
+                self._load_update_data(obj)
+
+            if obj.get("success"):
+                self._load_user_data(obj)
+                self._load_variable_data(obj)
+                self._load_chat_messages(obj)
+
+            return bool(obj.get("success"))
+        except Exception as e:
+            return self._set_failure("NETWORK_ERROR", "Network error.", str(e), 0)
+
+    def _ensure_initialized(self):
+        if self.initialized and self.sessionId:
+            return True
+        return self._set_failure("NOT_INITIALIZED", "AuthlyX is not initialized. Call Init() first.")
+
+    def Init(self):
+        payload = {}
+        ok = self._post_json("init", payload)
+        self.initialized = bool(ok and self.sessionId)
+        return bool(ok)
+
+    def Login(self, identifier, password=None, deviceType=None):
+        if deviceType:
+            return self.DeviceLogin(deviceType, identifier)
+        if password is None:
+            return self.LicenseLogin(identifier)
+        return self.UsernameLogin(identifier, password)
+
+    def UsernameLogin(self, username, password):
+        if not self._ensure_initialized():
+            return False
+        payload = {
+            "session_id": self.sessionId,
+            "username": username or "",
+            "password": password or "",
+            "sid": self._get_system_identifier(),
+            "ip_address": self._get_public_ip(),
+        }
+        return self._post_json("login", payload)
+
+    def LicenseLogin(self, licenseKey):
+        if not self._ensure_initialized():
+            return False
+        payload = {
+            "session_id": self.sessionId,
+            "license_key": licenseKey or "",
+            "sid": self._get_system_identifier(),
+            "ip_address": self._get_public_ip(),
+        }
+        return self._post_json("licenses", payload)
+
+    def DeviceLogin(self, deviceType, deviceId):
+        if not self._ensure_initialized():
+            return False
+        payload = {
+            "session_id": self.sessionId,
+            "device_type": deviceType or "",
+            "device_id": deviceId or "",
+            "sid": self._get_system_identifier(),
+            "ip_address": self._get_public_ip(),
+        }
+        return self._post_json("device-auth", payload)
+
+    def Register(self, username, password, licenseKey, email=""):
+        if not self._ensure_initialized():
+            return False
+        payload = {
+            "session_id": self.sessionId,
+            "username": username or "",
+            "password": password or "",
+            "license_key": licenseKey or "",
+            "email": email or "",
+            "sid": self._get_system_identifier(),
+            "ip_address": self._get_public_ip(),
+        }
+        return self._post_json("register", payload)
+
+    def ChangePassword(self, oldPassword, newPassword):
+        if not self._ensure_initialized():
+            return False
+        payload = {"session_id": self.sessionId, "old_password": oldPassword or "", "new_password": newPassword or ""}
+        return self._post_json("change-password", payload)
+
+    def ExtendTime(self, username, licenseKey):
+        if not self._ensure_initialized():
+            return False
+        payload = {"session_id": self.sessionId, "username": username or "", "license_key": licenseKey or ""}
+        return self._post_json("extend", payload)
+
+    def GetVariable(self, varKey):
+        if not self._ensure_initialized():
+            return ""
+        payload = {"session_id": self.sessionId, "var_key": varKey or ""}
+        ok = self._post_json("variables", payload)
+        if ok:
+            return self.variableData.get("VarValue") or ""
+        return ""
+
+    def SetVariable(self, varKey, varValue):
+        if not self._ensure_initialized():
+            return False
+        payload = {"session_id": self.sessionId, "var_key": varKey or "", "var_value": varValue or ""}
+        return self._post_json("variables/set", payload)
+
+    def Log(self, message):
+        if not self._ensure_initialized():
+            return False
+        payload = {"session_id": self.sessionId, "message": message or ""}
+        return self._post_json("logs", payload)
+
+    def GetChats(self, channelName, limit=100, cursor=None):
+        if not self._ensure_initialized():
+            return False
+        payload = {"session_id": self.sessionId, "channel_name": channelName or "", "limit": int(limit or 100)}
+        if cursor:
+            payload["cursor"] = cursor
+        return self._post_json("chats/get", payload)
+
+    def SendChat(self, message, channelName=None):
+        if not self._ensure_initialized():
+            return False
+        payload = {"session_id": self.sessionId, "message": message or ""}
+        if channelName:
+            payload["channel_name"] = channelName
+        return self._post_json("chats/send", payload)
+
+    def ValidateSession(self):
+        if not self.initialized or not self.sessionId:
+            return self._set_failure("INVALID_SESSION", "No active session. Please login first.")
+        payload = {"session_id": self.sessionId}
+        return self._post_json("validate-session", payload)
+
+    def IsInitialized(self):
+        return bool(self.initialized)
+
+    def GetSessionId(self):
+        return self.sessionId or ""
+
+    def GetCurrentApplicationHash(self):
+        return self.applicationHash or ""
+
+    init = Init
+    login = Login
+    register = Register
+    extend_time = ExtendTime
+    get_variable = GetVariable
+    set_variable = SetVariable
+    get_chats = GetChats
+    send_chat = SendChat
+    validate_session = ValidateSession
+    change_password = ChangePassword
+
+
+AuthlyX = Auth
+

authlyx_api-0.1.0.dist-info/METADATA

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: authlyx-api
+Version: 0.1.0
+Summary: AuthlyX Python SDK (v2) for AuthlyX API integration.
+Author: AuthlyX
+License-Expression: MIT
+Project-URL: Homepage, https://authly.cc
+Keywords: authlyx,authentication,license,sdk
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31.0
+Dynamic: license-file
+
+# AuthlyX Python SDK (PyPI)
+
+This folder is a publish-ready PyPI package version of the AuthlyX Python SDK.
+
+Install:
+
+```bash
+pip install authlyx-api
+```
+
+Quick start:
+
+```py
+from authlyx_api import AuthlyX
+
+AuthlyXApp = AuthlyX(
+    ownerId="12345678",
+    appName="HI",
+    version="1.3",
+    secret="your-secret"
+)
+
+AuthlyXApp.Init()
+if not AuthlyXApp.response["success"]:
+    raise Exception(AuthlyXApp.response["message"])
+
+AuthlyXApp.Login("12", "1")
+print(AuthlyXApp.userData["SubscriptionLevel"])
+```
+
+Optional parameters:
+
+```py
+from authlyx_api import AuthlyX
+
+AuthlyXApp = AuthlyX(
+    ownerId="12345678",
+    appName="HI",
+    version="1.3",
+    secret="your-secret",
+    debug=False,
+    api="https://example.com/api/v2"
+)
+```
+
+Unified login:
+
+```py
+# Username + password
+AuthlyXApp.Login("12", "1")
+
+# License key
+AuthlyXApp.Login("XXXXX-XXXXX-XXXXX-XXXXX-XXXXX")
+
+# Device login
+AuthlyXApp.Login("YOUR_DEVICE_ID", deviceType="motherboard")
+```
+
+Build locally:
+
+```bash
+python -m pip install --upgrade build twine
+python -m build
+```
+
+Publish:
+
+```bash
+twine upload dist/*
+```
+

authlyx_api-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+authlyx_api/__init__.py,sha256=2EmCQaNw1Z0tEUAlEs8wKOxsy_UHvFwV9vHVQcMJ7hM,85
+authlyx_api/sdk.py,sha256=76FagpkvJ7LP2lNGLnsDLYxo0T-ZS8K_3OsYHvX3tGY,22284
+authlyx_api-0.1.0.dist-info/licenses/LICENSE,sha256=bILiEXG_2jCS3qMhXhjEWe1AqAqopRCSUOnB8NTfgzI,1065
+authlyx_api-0.1.0.dist-info/METADATA,sha256=hUG3k13_ta3CRB7tChrbxGtYBqxYVbl6VqNU1opKIcU,1627
+authlyx_api-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+authlyx_api-0.1.0.dist-info/top_level.txt,sha256=KY88Cbq_PvJZdlf7m1qBdbxUHwZcEPeU6DmohryDjSk,12
+authlyx_api-0.1.0.dist-info/RECORD,,

authlyx_api-0.1.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
+

authlyx_api-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 AuthlyX
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

authlyx_api-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+authlyx_api