pixelarraylib 1.0.0__py3-none-any.whl

arraylib/gitlab/code_analyzer.py

@@ -0,0 +1,344 @@
+import aiohttp
+import asyncio
+from datetime import datetime, timedelta
+import pandas as pd
+from typing import List, Dict, Optional, Tuple
+
+
+class GitLabCodeAnalyzer:
+    def __init__(self, gitlab_url, private_token):
+        self.gitlab_url = gitlab_url.rstrip("/")
+        self.headers = {"PRIVATE-TOKEN": private_token}
+        self.session = None
+
+    async def __aenter__(self):
+        """异步上下文管理器入口"""
+        self.session = aiohttp.ClientSession(headers=self.headers)
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """异步上下文管理器出口"""
+        if self.session:
+            await self.session.close()
+
+    async def _get_session(self):
+        """获取或创建aiohttp会话"""
+        if self.session is None:
+            self.session = aiohttp.ClientSession(headers=self.headers)
+        return self.session
+
+    async def _close_session(self):
+        """关闭aiohttp会话"""
+        if self.session:
+            await self.session.close()
+            self.session = None
+
+    async def get_project_id_name_list(self, group_id=None, owned_only=True):
+        """获取项目的 ID 和名称列表
+
+        Args:
+            group_id: 组ID，如果指定则只获取该组的项目
+            owned_only: 是否只获取用户拥有的项目，默认为True以提高速度
+        """
+        projects = await self.get_all_projects(
+            group_id, owned_only=owned_only, membership_only=True
+        )
+        return [(p["id"], p["name"]) for p in projects]
+
+    async def get_all_projects(
+        self, group_id=None, owned_only=True, membership_only=True
+    ):
+        """获取项目列表
+
+        Args:
+            group_id: 组ID，如果指定则只获取该组的项目
+            owned_only: 是否只获取用户拥有的项目
+            membership_only: 是否只获取用户有权限的项目
+        """
+        if group_id:
+            url = f"{self.gitlab_url}/api/v4/groups/{group_id}/projects"
+        else:
+            url = f"{self.gitlab_url}/api/v4/projects"
+
+        # 构建查询参数
+        params = {
+            "page": 1,
+            "per_page": 100,
+            "simple": "true",  # 只返回基本信息，提高速度
+            "order_by": "name",
+            "sort": "asc",
+        }
+
+        if owned_only:
+            params["owned"] = "true"
+        if membership_only:
+            params["membership"] = "true"
+
+        projects = []
+        page = 1
+        session = await self._get_session()
+
+        while True:
+            params["page"] = page
+            async with session.get(url, params=params) as response:
+                # 检查响应状态
+                if response.status != 200:
+                    print(f"请求失败，状态码: {response.status}")
+                    text = await response.text()
+                    print(f"响应内容: {text}")
+                    break
+
+                # 获取响应数据
+                data = await response.json()
+                print(f"第{page}页数据: {len(data)}个项目")
+
+                # 如果返回的数据为空，说明已经到达最后一页
+                if not data:
+                    break
+
+                projects.extend(data)
+                page += 1
+
+                # 如果返回的数据少于per_page，说明这是最后一页
+                if len(data) < params["per_page"]:
+                    break
+
+        print(f"总共获取到 {len(projects)} 个项目")
+        return projects
+
+    async def get_project_code_stats(self, project_id, since=None, until=None):
+        """获取项目的代码统计，包括每个贡献者的提交数和代码行数变化
+
+        Args:
+            project_id: 项目ID
+            since: 开始日期，格式为YYYY-MM-DD
+            until: 结束日期，格式为YYYY-MM-DD
+        """
+        session = await self._get_session()
+
+        # 获取贡献者基本信息
+        contributors_url = (
+            f"{self.gitlab_url}/api/v4/projects/{project_id}/repository/contributors"
+        )
+        async with session.get(contributors_url) as response:
+            if response.status != 200:
+                print(f"获取贡献者信息失败，状态码: {response.status}")
+                return []
+            contributors = await response.json()
+
+        # 获取所有提交的统计信息（避免重复计算）
+        all_commits_stats = await self._get_all_commits_stats(
+            session, project_id, since, until
+        )
+
+        # 为每个贡献者分配统计信息
+        for contributor in contributors:
+            author_email = contributor.get("email", "")
+            author_name = contributor.get("name", "")
+
+            # 从所有提交中筛选该贡献者的提交
+            contributor_commits = [
+                commit
+                for commit in all_commits_stats
+                if commit.get("author_email", "").lower() == author_email.lower()
+            ]
+
+            # 计算该贡献者的统计信息
+            # 注意：这里统计的是代码变化量，不是最终代码量
+            total_additions = sum(
+                commit.get("additions", 0) for commit in contributor_commits
+            )
+            total_deletions = sum(
+                commit.get("deletions", 0) for commit in contributor_commits
+            )
+
+            # 更新贡献者统计信息
+            contributor["additions"] = total_additions
+            contributor["deletions"] = total_deletions
+            contributor["total_changes"] = total_additions + total_deletions
+            contributor["commit_details"] = contributor_commits
+
+            # 添加净变化行数（新增 - 删除）
+            contributor["net_changes"] = total_additions - total_deletions
+
+        return contributors
+
+    async def _get_all_commits_stats(self, session, project_id, since=None, until=None):
+        """获取项目中所有提交的统计信息"""
+        commits_url = (
+            f"{self.gitlab_url}/api/v4/projects/{project_id}/repository/commits"
+        )
+        commit_params = {
+            "per_page": 100,
+            "ref_name": "master",  # 只统计master分支的提交
+        }
+
+        if since:
+            commit_params["since"] = since
+        if until:
+            commit_params["until"] = until
+
+        all_commits = []
+        page = 1
+
+        while True:
+            commit_params["page"] = page
+            async with session.get(commits_url, params=commit_params) as response:
+                if response.status != 200:
+                    print(f"获取提交列表失败，状态码: {response.status}")
+                    break
+
+                commits = await response.json()
+                if not commits:
+                    break
+
+                all_commits.extend(commits)
+                page += 1
+
+                if len(commits) < commit_params["per_page"]:
+                    break
+
+        # 过滤掉合并提交，只保留真正的功能提交
+        filtered_commits = []
+        for commit in all_commits:
+            title = commit.get("title", "").lower()
+            message = commit.get("message", "").lower()
+
+            # 过滤掉合并提交
+            if (
+                title.startswith("merge branch")
+                or title.startswith("merge pull request")
+                or "merge" in title
+                and "into" in title
+            ):
+                continue
+
+            filtered_commits.append(commit)
+
+        print(f"总提交数: {len(all_commits)}, 过滤后提交数: {len(filtered_commits)}")
+
+        # 并发获取每个提交的详细统计
+        commit_tasks = []
+        for commit in filtered_commits:
+            task = self._get_commit_details(session, project_id, commit)
+            commit_tasks.append(task)
+
+        # 等待所有提交详情获取完成
+        commit_details_list = await asyncio.gather(*commit_tasks)
+
+        # 过滤掉None值
+        return [commit for commit in commit_details_list if commit is not None]
+
+    async def _get_commit_details(self, session, project_id, commit):
+        """获取单个提交的详细信息"""
+        commit_id = commit["id"]
+        commit_stats_url = f"{self.gitlab_url}/api/v4/projects/{project_id}/repository/commits/{commit_id}"
+
+        async with session.get(commit_stats_url) as commit_response:
+            if commit_response.status == 200:
+                commit_data = await commit_response.json()
+                stats = commit_data.get("stats", {})
+
+                # 返回详细的提交信息
+                return {
+                    "id": commit_id,
+                    "short_id": commit.get("short_id", ""),
+                    "title": commit.get("title", ""),
+                    "message": commit.get("message", ""),
+                    "author_name": commit.get("author_name", ""),
+                    "author_email": commit.get("author_email", ""),
+                    "committed_date": commit.get("committed_date", ""),
+                    "created_at": commit.get("created_at", ""),
+                    "additions": stats.get("additions", 0),
+                    "deletions": stats.get("deletions", 0),
+                    "total": stats.get("total", 0),
+                }
+            else:
+                return None
+
+    async def generate_code_report(self, group_id=None, since=None, until=None):
+        """生成代码统计报告
+
+        Args:
+            group_id: 组ID，如果指定则只获取该组的项目
+            since: 开始日期，格式为YYYY-MM-DD
+            until: 结束日期，格式为YYYY-MM-DD
+        """
+        projects = await self.get_all_projects(group_id)
+        report_data = []
+
+        # 并发处理所有项目
+        project_tasks = []
+        for project in projects:
+            task = self._process_project_for_report(project, since, until)
+            project_tasks.append(task)
+
+        # 等待所有项目处理完成
+        project_results = await asyncio.gather(*project_tasks)
+
+        # 汇总所有项目的数据
+        for project_data in project_results:
+            report_data.extend(project_data)
+
+        if not report_data:
+            print("没有找到任何贡献者数据")
+            return pd.DataFrame()
+
+        return report_data
+
+    async def _process_project_for_report(self, project, since=None, until=None):
+        """处理单个项目的报告数据"""
+        project_id = project["id"]
+        project_name = project["name"]
+        project_data = []
+
+        print(f"分析项目: {project_name}")
+
+        # 获取贡献者统计，包含代码行数信息
+        contributors = await self.get_project_code_stats(
+            project_id, since=since, until=until
+        )
+
+        for contributor in contributors:
+            project_data.append(
+                {
+                    "project": project_name,
+                    "author": contributor["name"],
+                    "email": contributor["email"],
+                    "commits": contributor["commits"],
+                    "additions": contributor.get("additions", 0),
+                    "deletions": contributor.get("deletions", 0),
+                    "total_changes": contributor.get("total_changes", 0),
+                    "net_changes": contributor.get("net_changes", 0),
+                }
+            )
+
+        return project_data
+
+    async def get_commit_details_report(self, project_id, since=None, until=None):
+        """获取详细的提交信息报告
+
+        Args:
+            project_id: 项目ID
+            since: 开始日期，格式为YYYY-MM-DD
+            until: 结束日期，格式为YYYY-MM-DD
+
+        Returns:
+            List[Dict]: 包含所有提交详细信息的列表
+        """
+        contributors = await self.get_project_code_stats(
+            project_id, since=since, until=until
+        )
+
+        all_commits = []
+        for contributor in contributors:
+            commit_details = contributor.get("commit_details", [])
+            for commit in commit_details:
+                commit["contributor_name"] = contributor.get("name", "")
+                commit["contributor_email"] = contributor.get("email", "")
+                all_commits.append(commit)
+
+        # 按提交日期排序
+        all_commits.sort(key=lambda x: x.get("committed_date", ""), reverse=True)
+
+        return all_commits

arraylib/gitlab/pypi_package_manager.py

@@ -0,0 +1,61 @@
+import requests
+from typing import List, Optional
+
+
+class GitLabPyPIPackageManager:
+    def __init__(self, project_id: str, token: str, api_version: str = "v4"):
+        self.gitlab_url = "https://gitlab.com"
+        self.project_id = project_id
+        self.token = token
+        self.api_version = api_version
+        self.base_url = f"{self.gitlab_url}/api/{api_version}/projects/{project_id}"
+        self.headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json",
+        }
+
+    def _find_package_id(self, package_name: str, package_version: str) -> str:
+        url = f"{self.base_url}/packages"
+        params = {
+            "package_type": "pypi",
+            "package_name": package_name,
+            "package_version": package_version,
+        }
+        response = requests.get(url, headers=self.headers, params=params)
+        if response.status_code == 200:
+            for package in response.json():
+                if (
+                    package["name"] == package_name
+                    and package["version"] == package_version
+                ):
+                    return package["id"]
+        return None
+
+    def list_packages(self) -> List[str]:
+        url = f"{self.base_url}/packages"
+        params = {"package_type": "pypi"}
+        response = requests.get(url, headers=self.headers, params=params)
+        if response.status_code == 200:
+            return response.json()
+        else:
+            return []
+
+    def list_package_versions(self, package_name: str) -> List[str]:
+        url = f"{self.base_url}/packages"
+        params = {"package_type": "pypi", "package_name": package_name}
+        response = requests.get(url, headers=self.headers, params=params)
+        if response.status_code == 200:
+            return [version["version"] for version in response.json()]
+        else:
+            return []
+
+    def delete_package(self, package_name: str, package_version: str):
+        package_id = self._find_package_id(package_name, package_version)
+        if package_id is None:
+            raise ValueError(f"Package {package_name} {package_version} not found")
+        url = f"{self.base_url}/packages/{package_id}"
+        response = requests.delete(url, headers=self.headers)
+        if response.status_code == 200:
+            return True
+        else:
+            return False

arraylib/monitor/feishu.py

@@ -0,0 +1,132 @@
+import requests
+import json
+import asyncio
+
+
+class Feishu:
+    channel_map = {
+        "矩阵像素订阅群": "https://open.feishu.cn/open-apis/bot/v2/hook/6e368741-ab2e-46f4-a945-5c1182303f91",
+        "devtoolkit服务报警": "https://open.feishu.cn/open-apis/bot/v2/hook/b9e7cfa1-c63f-4a9f-9699-286f7316784b",
+        "baymax服务报警": "https://open.feishu.cn/open-apis/bot/v2/hook/5d8d4fa6-67c4-4202-9122-389d1ec2b668",
+        "videodriver服务报警": "https://open.feishu.cn/open-apis/bot/v2/hook/5359b92d-02ab-47ca-a617-58b8152eaa2d",
+        "arraycut服务报警": "https://open.feishu.cn/open-apis/bot/v2/hook/e610b1e8-f867-4670-8d4d-0553f64884f0",
+        "knowledgebase微服务报警": "https://open.feishu.cn/open-apis/bot/v2/hook/5f007914-235a-4287-8349-6c1dd7c70024",
+        "llm微服务报警": "https://open.feishu.cn/open-apis/bot/v2/hook/54942aa6-24f1-4851-8fe9-d7c87572d00a",
+        "thirdparty微服务报警": "https://open.feishu.cn/open-apis/bot/v2/hook/b1e6237a-1323-4ad9-96f4-d74de5cdc00f",
+    }
+
+    def __init__(self, channel_name):
+        self.webhook_url = self.channel_map[channel_name]
+
+    def send(self, text):
+        print(text)
+        headers = {"Content-Type": "application/json"}
+        data = {"msg_type": "text", "content": {"text": text}}
+        response = requests.post(
+            self.webhook_url, headers=headers, data=json.dumps(data)
+        )
+        return bool(
+            response
+            and response.json().get("StatusCode") == 0
+            and response.json().get("StatusMessage") == "success"
+        )
+
+    async def send_async(self, text: str):
+        return await asyncio.to_thread(self.send, text)
+
+    def send_markdown(
+        self,
+        markdown_content: str,
+        title: str,
+        template: str = "turquoise",
+    ):
+        headers = {"Content-Type": "application/json; charset=utf-8"}
+        card = {
+            "config": {"wide_screen_mode": True, "enable_forward": True},
+            "header": {
+                "title": {"tag": "plain_text", "content": title},
+                "template": template,
+            },
+            "elements": [
+                {"tag": "div", "text": {"tag": "lark_md", "content": markdown_content}}
+            ],
+        }
+        payload = {"msg_type": "interactive", "card": card}
+        resp = requests.post(
+            self.webhook_url, headers=headers, data=json.dumps(payload)
+        )
+        return bool(resp.ok and resp.json().get("StatusCode") == 0)
+
+    async def send_markdown_async(
+        self,
+        markdown_content: str,
+        title: str,
+        template: str = "turquoise",
+    ):
+        return await asyncio.to_thread(
+            self.send_markdown, markdown_content, title, template
+        )
+
+    def send_table(
+        self,
+        headers: list,
+        rows: list,
+        title: str,
+        template: str = "turquoise",
+    ):
+        headers_req = {"Content-Type": "application/json; charset=utf-8"}
+        n_cols = len(headers)
+        columns = []
+        for ci in range(n_cols):
+            elements_in_col = []
+            # 表头
+            elements_in_col.append(
+                {
+                    "tag": "div",
+                    "text": {"tag": "lark_md", "content": f"**{headers[ci]}**"},
+                }
+            )
+            # 每一行的该列内容
+            for row in rows:
+                cell = row[ci] if ci < len(row) else ""
+                elements_in_col.append(
+                    {"tag": "div", "text": {"tag": "lark_md", "content": cell}}
+                )
+            columns.append(
+                {
+                    "tag": "column",
+                    "width": "weighted",
+                    "weight": 1,
+                    "elements": elements_in_col,
+                }
+            )
+
+        elements = [{"tag": "column_set", "columns": columns}]
+
+        card = {
+            "config": {"wide_screen_mode": True, "enable_forward": True},
+            "header": {
+                "title": {"tag": "plain_text", "content": title},
+                "template": template,
+            },
+            "elements": elements,
+        }
+        payload = {"msg_type": "interactive", "card": card}
+
+        resp = requests.post(
+            self.webhook_url, headers=headers_req, data=json.dumps(payload)
+        )
+        try:
+            print("feishu send_table resp:", resp.status_code, resp.json())
+        except Exception:
+            print("feishu send_table resp:", resp.status_code, resp.text)
+        return bool(resp.ok and resp.json().get("StatusCode") == 0)
+
+    async def send_table_async(
+        self,
+        headers: list[str],
+        rows: list[list[str]],
+        title: str,
+        template: str = "turquoise",
+    ):
+        return await asyncio.to_thread(self.send_table, headers, rows, title, template)

arraylib/net/request.py

@@ -0,0 +1,143 @@
+import requests
+from typing import Generator
+
+
+class Request:
+    def __init__(self, trust_env: bool = False):
+        self.session = requests.Session()
+        self.session.trust_env = trust_env
+
+    def _post(
+        self,
+        url: str,
+        data: dict = {},
+        headers: dict = {"Content-Type": "application/json"},
+        timeout: int = 0,
+    ):
+        kwargs = {
+            "url": url,
+            "json": data,
+            "headers": headers,
+        }
+        if timeout:
+            kwargs["timeout"] = timeout
+        response = self.session.post(**kwargs)
+        return response
+
+    def _get(self, url: str, params: dict = {}, headers: dict = {}, timeout: int = 0):
+        kwargs = {
+            "url": url,
+            "params": params,
+            "headers": headers,
+        }
+        if timeout:
+            kwargs["timeout"] = timeout
+        response = self.session.get(**kwargs)
+        return response
+
+    def post(
+        self,
+        url: str,
+        data: dict = {},
+        headers: dict = {"Content-Type": "application/json"},
+        timeout: int = 0,
+    ) -> tuple[dict, bool]:
+        """
+        description:
+            发送 POST 请求
+        parameters:
+            url(str): 请求 URL
+            data(dict): 请求数据
+            headers(dict): 请求头
+            timeout(int): 请求超时时间
+        return:
+            response(dict): 响应数据
+            flag(bool): 请求是否成功
+        """
+        response = self._post(url, data, headers, timeout)
+
+        if response.status_code == 200:
+            return response.json(), True
+        else:
+            print(response.status_code, response.text)
+            return {
+                "status_code": response.status_code,
+                "message": response.text,
+            }, False
+
+    def get(
+        self,
+        url: str,
+        params: dict = {},
+        headers: dict = {},
+        timeout: int = 0,
+    ) -> tuple[dict, bool]:
+        """
+        description:
+            发送 GET 请求
+        parameters:
+            url(str): 请求 URL
+            params(dict): 请求参数
+            headers(dict): 请求头
+            timeout(int): 请求超时时间
+        return:
+            response(dict): 响应数据
+            flag(bool): 请求是否成功
+        """
+        response = self._get(url, params, headers, timeout)
+
+        if response.status_code == 200:
+            return response.json(), True
+        else:
+            print(response.status_code, response.text)
+            return {
+                "status_code": response.status_code,
+                "message": response.text,
+            }, False
+
+    def post_stream(
+        self,
+        url: str,
+        data: dict = {},
+        headers: dict = {"Content-Type": "application/json"},
+        timeout: int = 0,
+    ) -> Generator[str, None, None]:
+        """
+        description:
+            发送 POST 流式请求
+        parameters:
+            url(str): 请求 URL
+            data(dict): 请求数据
+            headers(dict): 请求头
+            timeout(int): 请求超时时间
+        return:
+            response(generator): 响应数据生成器
+        """
+        response = self._post(url, data, headers, timeout)
+        if response.status_code == 200:
+            return response.iter_lines()
+
+    def get_stream(
+        self,
+        url: str,
+        params: dict = {},
+        headers: dict = {},
+        timeout: int = 0,
+    ) -> Generator[str, None, None]:
+        """
+        description:
+            发送 GET 流式请求
+        parameters:
+            url(str): 请求 URL
+            params(dict): 请求参数
+            headers(dict): 请求头
+            timeout(int): 请求超时时间
+        return:
+            response(generator): 响应数据生成器
+        """
+        response = self._get(url, params, headers, timeout)
+        if response.status_code == 200:
+            return response.iter_lines()
+
+    def __del__(self):
+        self.session.close()