infomankit 0.3.23__py3-none-any.whl

infoman/utils/http/info.py

@@ -0,0 +1,94 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+# Time       ：2024/4/11 18:51
+# Author     ：Maxwell
+# Description：
+"""
+import re
+
+
+class ClientInfoExtractor:
+
+    @staticmethod
+    def client_ip(request) -> str:
+        x_forwarded_for = request.headers.get("X-Forwarded-For")
+        if x_forwarded_for:
+            client_ip = x_forwarded_for.split(",")[0].strip()
+        else:
+            client_ip = request.headers.get("X-Real-IP", request.client.host)
+        return client_ip or "unknown"
+
+    @staticmethod
+    def user_agent(request) -> str:
+        return request.headers.get("User-Agent", "Unknown")
+
+    @staticmethod
+    def time_zone(request) -> str:
+        return request.headers.get("TimeZone", "")
+
+    @staticmethod
+    def info(request) -> dict:
+        return {
+            "ip": ClientInfoExtractor.ip_address(request),
+            "timezone": ClientInfoExtractor.time_zone(request),
+            "useragent": ClientInfoExtractor.user_agent(request),
+        }
+
+    @staticmethod
+    def ip_address(request) -> str:
+        cf_connecting_ip = request.headers.get("CF-Connecting-IP")
+        if cf_connecting_ip and cf_connecting_ip.strip():
+            return cf_connecting_ip.strip()
+
+        # 2. 部分CDN使用的 True-Client-IP
+        true_client_ip = request.headers.get("True-Client-IP")
+        if true_client_ip and true_client_ip.strip():
+            return true_client_ip.strip()
+
+        # 3. X-Forwarded-For（可能包含多个IP，格式: client, proxy1, proxy2）
+        xff = request.headers.get("X-Forwarded-For")
+        if xff:
+            ip_list = [ip.strip() for ip in xff.split(",") if ip.strip()]
+            for ip in ip_list:
+                if not ClientInfoExtractor.is_private_ip(ip):
+                    return ip
+
+            # 如果都是内网IP，返回第一个
+            if ip_list:
+                return ip_list[0]
+
+        # 4. X-Real-IP（Nginx/Caddy传递的单值IP）
+        x_real_ip = request.headers.get("X-Real-IP")
+        if x_real_ip and x_real_ip.strip():
+            return x_real_ip.strip()
+
+        # 5. 兜底：直连场景使用 client.host
+        fallback_ip = request.client.host if request.client else "unknown"
+        return fallback_ip
+
+
+    @staticmethod
+    def is_private_ip(ip: str) -> bool:
+        """
+        判断是否为内网IP
+
+        内网IP段：
+        - 127.0.0.0/8 (localhost)
+        - 10.0.0.0/8 (私有网络A类)
+        - 172.16.0.0/12 (私有网络B类)
+        - 192.168.0.0/16 (私有网络C类)
+        - ::1 (IPv6 localhost)
+        - fc00::/7 (IPv6 私有网络)
+        """
+        # IPv4 内网IP正则
+        ipv4_private_pattern = r"^(127\.|10\.|192\.168\.|172\.(1[6-9]|2[0-9]|3[0-1])\.)"
+        if re.match(ipv4_private_pattern, ip):
+            return True
+
+        # IPv6 内网IP判断
+        if ip.startswith("::1") or ip.startswith("fc") or ip.startswith("fd"):
+            return True
+
+        return False

infoman/utils/http/result.py

@@ -0,0 +1,19 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+# Time       ：2024/7/29 14:42
+# Author     ：Maxwell
+# Description：
+"""
+
+
+class HttpResult(object):
+
+    def __init__(
+        self, succeed: bool, content: bytes, text: str = "", message: str = ""
+    ):
+        self.succeed = succeed
+        self.content = content
+        self.text = text
+        self.message = message

infoman/utils/notification/__init__.py

@@ -0,0 +1,8 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+# Time       ：2024/9/29 08:01
+# Author     ：Maxwell
+# Description：
+"""

infoman/utils/notification/feishu.py

@@ -0,0 +1,35 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+# Time       ：2024/9/29 08:01
+# Author     ：Maxwell
+# Description：
+"""
+import json
+import aiohttp
+from infoman.logger import logger
+
+
+class RobotManager(object):
+
+    @classmethod
+    async def publish_message(cls, url, message):
+        try:
+            headers = {"Content-Type": "application/json"}
+            json_data = {"msg_type": "text", "content": {"text": message}}
+
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    url, headers=headers, data=json.dumps(json_data)
+                ) as response:
+                    if response.status == 200:
+                        logger.info("RobotManager publish_message sent successfully")
+                    else:
+                        logger.info(
+                            f"RobotManager publish_message. Status code: {response.status}"
+                        )
+                        response_text = await response.text()
+                        logger.info(f"RobotManager publish_message: {response_text}")
+        except Exception as e:
+            logger.info(f"RobotManager error: {e}")

infoman/utils/text/__init__.py

@@ -0,0 +1,8 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+# Time       ：2024/1/5 16:25
+# Author     ：Maxwell
+# Description：
+"""

infoman/utils/text/extractor.py

@@ -0,0 +1,111 @@
+# !/usr/bin/env python
+# -*-coding:utf-8 -*-
+
+"""
+# Time       ：2024/1/5 16:25
+# Author     ：Maxwell
+# Description：
+"""
+
+import re
+import json
+from typing import Optional, Dict, List, Union
+
+
+def extract_json_from_string(s: str) -> Optional[Union[Dict, List]]:
+    if not s:
+        return None
+
+    json_pattern = re.compile(r"(\{[^{}]*}|$[^\[$]*])", re.DOTALL)
+    candidates = []
+
+    for match in json_pattern.finditer(s):
+        candidate = match.group(0)
+        try:
+            if candidate.startswith("{") or candidate.startswith("["):
+                candidates.append((match.start(), match.end(), candidate))
+        except (IndexError, AttributeError):
+            continue
+
+    for start, end, candidate in candidates:
+        if (
+            candidate.startswith("{") and candidate.count("{") == candidate.count("}")
+        ) or (
+            candidate.startswith("[") and candidate.count("[") == candidate.count("]")
+        ):
+            try:
+                parsed = json.loads(candidate)
+                return parsed
+            except json.JSONDecodeError:
+                expanded = _expand_json_boundary(s, start, end)
+                if expanded:
+                    try:
+                        return json.loads(expanded)
+                    except json.JSONDecodeError:
+                        continue
+                continue
+
+    return _robust_json_parse(s)
+
+
+def _expand_json_boundary(s: str, start: int, end: int) -> Optional[str]:
+    stack = []
+    in_string = False
+    escape = False
+
+    for i in range(start, len(s)):
+        c = s[i]
+
+        if c == '"' and not escape:
+            in_string = not in_string
+        elif not in_string:
+            if c == "{" or c == "[":
+                stack.append(c)
+            elif c == "}" and stack and stack[-1] == "{":
+                stack.pop()
+            elif c == "]" and stack and stack[-1] == "[":
+                stack.pop()
+
+        escape = c == "\\" and not escape
+
+        if not stack and not in_string:
+            return s[start : i + 1]
+
+    return None
+
+
+def _robust_json_parse(s: str) -> Optional[Union[Dict, List]]:
+    stack = []
+    in_string = False
+    escape = False
+    start_index = None
+    structures = []
+
+    for i, c in enumerate(s):
+        if c == '"' and not escape:
+            in_string = not in_string
+        elif not in_string:
+            if c == "{" or c == "[":
+                if not stack:
+                    start_index = i
+                stack.append(c)
+            elif c == "}" and stack and stack[-1] == "{":
+                stack.pop()
+                if not stack:
+                    structures.append((start_index, i + 1))
+            elif c == "]" and stack and stack[-1] == "[":
+                stack.pop()
+                if not stack:
+                    structures.append((start_index, i + 1))
+
+        escape = c == "\\" and not escape
+
+    structures.sort(key=lambda x: x[1] - x[0], reverse=True)
+
+    for start, end in structures:
+        try:
+            return json.loads(s[start:end])
+        except json.JSONDecodeError:
+            continue
+
+    return None