pyxllib 0.3.96__py3-none-any.whl → 0.3.197__py3-none-any.whl

pyxllib/data/sqlite.py

@@ -4,16 +4,189 @@
 # @Email  : 877362867@qq.com
 # @Date   : 2022/04/12 08:59
 
+import copy
 import json
 import re
 import sqlite3
+import warnings
+from collections import defaultdict
 
 import pandas as pd
 
+# 旧版的pandas警告
+warnings.filterwarnings('ignore', message="pandas only support SQLAlchemy connectable")
+# 新版的pandas警告多了个's‘
+warnings.filterwarnings('ignore', message="pandas only supports SQLAlchemy connectable")
+
+
+class SqlBuilder:
+    def __init__(self, table=''):
+        self.table = table
+        self._select = []
+        self._set = []
+        self._where = []
+        self._order_by = []
+        self._group_by = []
+        self._limit = None  # 限制最多读多少条数据
+        self._offset = None  # 从第几条数据开始读
+
+    def copy(self):
+        # 拷贝一个当前状态的副本sql
+        return copy.deepcopy(self)
+
+    def __1_组件(self):
+        pass
+
+    def from_table(self, table):
+        self.table = table
+        return self
+
+    def select(self, *columns):
+        self._select.extend(columns)
+        return self
+
+    def set(self, *columns):
+        self._set.extend(columns)
+        return self
+
+    def where(self, condition):
+        if isinstance(condition, (list, tuple)):
+            self._where.extend(condition)
+        elif isinstance(condition, str):
+            self._where.append(condition)
+        else:
+            raise ValueError(f'不支持的where条件类型{type(condition)}')
+
+        return self
+
+    def where_dict_match(self, items):
+        """ 输入一个字典，要求每个key的字段对应上具体的某个取值value """
+        for k, v in items.items():
+            if isinstance(v, str):
+                self._where.append(f"{k} = '{v}'")
+            elif isinstance(v, (int, float)):
+                self._where.append(f"{k} = {v}")
+            else:
+                raise TypeError
+
+    def where_in(self, column, values):
+        if values is None:
+            return self
+
+        if isinstance(values, str):
+            values = [values]
+        values_str = ', '.join(f"'{str(value)}'" for value in values)
+        if len(values) == 1:
+            self._where.append(f"{column} = {values_str[0]}")
+        else:
+            self._where.append(f"{column} IN ({values_str})")
+        return self
+
+    def where_or(self, *conditions):
+        """ 输入的这一批条件，作为OR组合后成为一个整体条件
+        """
+        self._where.append(f"({' OR '.join(conditions)})")
+        return self
+
+    def where_mod(self, column, divisor, remainder):
+        """ 输入的column列的值对divisor取余，筛选出余数为remainder的记录
+        """
+        condition = f"({column} % {divisor} = {remainder})"
+        self._where.append(condition)
+        return self
+
+    def where_mod2(self, desc):
+        """ 使用一种特殊的格式化标记来设置规则
+
+        :param desc: 例如 'id%2=1'
+
+        todo 我好像傻了，画蛇添足，这个功能好像直接用 .where 就能完成~
+        """
+        if not desc:
+            return
+        column, divisor_remainder = desc.split('%')
+        divisor, remainder = map(int, divisor_remainder.split('='))
+        return self.where_mod(column, divisor, remainder)
+
+    def group_by(self, *columns):
+        self._group_by.extend(columns)
+        return self
+
+    def order_by(self, *columns):
+        self._order_by.extend(columns)
+        return self
+
+    def limit(self, limit, offset=None):
+        self._limit = limit
+        self._offset = offset
+        return self
+
+    def __2_build_初级命令(self):
+        pass
+
+    def build_select(self, *columns):
+        if columns:
+            columns = self._select + list(columns)
+        else:
+            columns = self._select
+
+        sql = [f"SELECT {', '.join(columns) or '*'}", f"FROM {self.table}"]
+        if self._where:
+            sql.append(f"WHERE {' AND '.join(self._where)}")
+        if self._group_by:
+            sql.append(f"GROUP BY {', '.join(self._group_by)}")
+        if self._order_by:
+            sql.append(f"ORDER BY {', '.join(self._order_by)}")
+        if self._limit is not None:
+            limit_clause = f"LIMIT {self._limit}"
+            if self._offset is not None:
+                limit_clause += f" OFFSET {self._offset}"
+            sql.append(limit_clause)
+        return '\n'.join(sql)
+
+    def build_count(self):
+        sql = [f"SELECT COUNT(*)", f"FROM {self.table}"]
+        if self._where:
+            sql.append(f"WHERE {' AND '.join(self._where)}")
+        if self._group_by:
+            sql.append(f"GROUP BY {', '.join(self._group_by)}")
+        return '\n'.join(sql)
+
+    def build_update(self):
+        sql = [f"UPDATE {self.table}"]
+        if self._set:
+            sql.append(f"SET {', '.join(self._set)}")
+        if self._where:
+            sql.append(f"WHERE {' AND '.join(self._where)}")
+        return '\n'.join(sql)
+
+    def __3_build_中级命令(self):
+        pass
+
+    def build_check_data_type(self, column):
+        """ 检查column的数据类型 """
+        sql = SqlBuilder('information_schema.columns')
+        sql.select(f"data_type")
+        sql.where(f"table_name='{self.table}' AND column_name='{column}'")
+        return sql.build_select()
+
+    def build_group_count(self, columns, count_column_name='cnt'):
+        sql = SqlBuilder(self.table)
+        if isinstance(columns, (list, tuple)):
+            columns = ', '.join(columns)
+        sql.select(columns, f"COUNT(*) {count_column_name}")
+        sql.group_by(columns)
+        sql.order_by(f'{count_column_name} DESC')
+        sql._where = self._where.copy()
+        return sql.build_select()
+
 
 class SqlBase:
     """ Sql语法通用的功能 """
 
+    def __init__(self, *args, **kwargs):
+        self._commit_cache = defaultdict(list)
+
     def __1_库(self):
         pass
 
@@ -81,6 +254,12 @@ class SqlBase:
             cols = ','.join(map(str, cols))
         self.execute(f'CREATE INDEX {index_name} ON {table_name}({cols})')
 
+    def create_index2(self, table_name, cols):
+        """ 创建一个简单的索引，索引名字自动生成 """
+        if not isinstance(cols, str):
+            cols = ','.join(map(str, cols))
+        self.execute(f'CREATE INDEX idx_{table_name}_{cols.replace(",", "_")} ON {table_name}({cols})')
+
     def keep_top_n_rows(self, table_name, num, col_name='id'):
         """ 只保留一小部分数据，常用来做lite、demo数据示例文件
 
@@ -109,7 +288,10 @@ class SqlBase:
 
     def exec2one(self, *args, **kwargs):
         """ 获得第1行的值 """
-        return self.execute(*args, **kwargs).fetchone()[0]
+        try:
+            return self.execute(*args, **kwargs).fetchone()[0]
+        except TypeError:
+            return None
 
     def exec2row(self, *args, **kwargs):
         """ 获得第1行的值 """
@@ -149,6 +331,34 @@ class SqlBase:
     def __5_增删改查(self):
         pass
 
+    def commit_base(self, commit_type, query, params=None):
+        """
+        :param commit_type:
+            -1，先真正缓存在本地
+            False，传统的事务机制，虽然不会更新数据，但每一条依然会连接数据库，其实速度回挺慢的
+            True，传统的事务机制，但每条都作为独立事务，直接更新了
+        """
+        if commit_type == -1:
+            self._commit_cache[query].append(params)
+        elif commit_type is False:
+            self.execute(query, params)
+        elif commit_type is True:
+            self.execute(query, params)
+            self.commit()
+
+    def commit_all(self):
+        if not self._commit_cache:
+            self.commit()
+            return
+
+        for query, params in self._commit_cache.items():
+            cur = self.cursor()
+            cur.executemany(query, params)
+            cur.close()
+            self.commit()
+
+        self._commit_cache = defaultdict(list)
+
     def update_row(self, table_name, cols, where, *, commit=False):
         """ 【改】更新数据
 
@@ -164,9 +374,22 @@ class SqlBase:
         kvs = ','.join([f'{k}=%s' for k in cols.keys()])
         ops = ' AND '.join([f'{k}=%s' for k in where.keys()])
         vals = list(cols.values()) + list(where.values())
-        self.execute(f'UPDATE {table_name} SET {kvs} WHERE {ops}', self.cvt_types(vals))
-        if commit:
-            self.commit()
+        self.commit_base(commit,
+                         f'UPDATE {table_name} SET {kvs} WHERE {ops}',
+                         self.cvt_types(vals))
+
+    def delete_row(self, table_name, where, *, commit=False):
+        """ 【删】删除数据
+
+        :param dict where: 怎么匹配到对应记录
+        :param commit: 建议减小commit频率，会极大降低性能
+        :return:
+        """
+        ops = ' AND '.join([f'{k}=%s' for k in where.keys()])
+        vals = list(where.values())
+        self.commit_base(commit,
+                         f'DELETE FROM {table_name} WHERE {ops}',
+                         self.cvt_types(vals))
 
     def select_col(self, table_name, col):
         """ 获得一列数据，常使用的功能，所以做了一个封装
@@ -238,6 +461,10 @@ class SqlBase:
             print("No 'FROM' keyword found in the data query.")
             return 0
 
+    def get_column_data_type(self, table_name, col_name):
+        """ 获取表格中某一列的数据类型 """
+        return self.exec2one(SqlBuilder(table_name).build_check_data_type(col_name))
+
 
 class Connection(sqlite3.Connection, SqlBase):
     """

pyxllib/ext/JLineViewer.py

@@ -390,9 +390,22 @@ class JLineViewer(QMainWindow):
         if parent is None:
             parent = QStandardItemModel()
             parent.setHorizontalHeaderLabels(['Key', 'Value'])
+
+        # if isinstance(data, dict):
+        #     for key, value in data.items():
+        #         self.dataToModel(key, value, parent)
+
+        # 判断数据类型，并相应处理
         if isinstance(data, dict):
             for key, value in data.items():
                 self.dataToModel(key, value, parent)
+        elif isinstance(data, list):
+            # 处理列表：创建一个无key的父项，将列表元素作为子项添加
+            self.dataToModel("List", data, parent)
+        else:
+            # 处理基本数据类型：创建一个单独的条目
+            self.dataToModel("Value", data, parent)
+
         return parent
 
     def dataToModel(self, key, value, parent):
@@ -476,7 +489,7 @@ def start_jlineviewer(fname=None):
     if isinstance(fname, list):  # 可以输入一个list字典数据，会转存到临时目录里查看
         tempfile = XlPath.tempfile(suffix='.jsonl')
         tempfile.write_jsonl(fname)
-        fname = tempfile
+        fname = tempfile.as_posix()
     if fname:
         ex.showDialog(fname=fname)
     sys.exit(app.exec_())

pyxllib/ext/drissionlib.py

@@ -0,0 +1,277 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# @Author : 陈坤泽
+# @Email  : 877362867@qq.com
+# @Date   : 2024/04/12
+
+import re
+from urllib.parse import unquote
+import tempfile
+import time
+from urllib.parse import urlparse
+
+from deprecated import deprecated
+from loguru import logger
+import DrissionPage
+from DrissionPage import ChromiumPage, Chromium
+from DrissionPage._pages.chromium_base import ChromiumBase
+from DrissionPage._pages.chromium_tab import ChromiumTab
+import DrissionPage.errors
+
+from pyxllib.prog.pupil import inject_members
+from pyxllib.text.pupil import strfind
+from pyxllib.file.specialist import GetEtag
+
+
+@deprecated(reason='get_dp_page逻辑不太对，请换用get_dp_tab')
+def get_dp_page(dp_page=None) -> 'XlPage':
+    """
+
+    :param dp_page:
+        默认None, 返回默认的page，一般就是当前页面
+        True, 新建一个page
+        str, 新建一个对应url的page
+        func(tab), 通过规则筛选tab，返回符合条件的第1个tab，否则新建一个tab
+    """
+
+    if isinstance(dp_page, Chromium):
+        return dp_page
+    elif isinstance(dp_page, ChromiumTab):
+        return dp_page.page
+    elif callable(dp_page):
+        page0 = Chromium()
+        for tab in page0.get_tabs():
+            if dp_page(tab):
+                return tab.page
+        return page0.new_tab().page
+    elif dp_page is True:
+        return Chromium().new_tab().page
+    elif isinstance(dp_page, str):
+        return Chromium().new_tab(dp_page).page
+    else:
+        return Chromium()
+
+
+def get_dp_tab(dp_tab=None) -> 'XlTab':
+    """ 智能获取一个标签页tab
+
+    :param dp_tab:
+        默认None, 返回默认的tab，一般就是当前页面
+        True, 新建一个tab
+        str, 新建一个对应url的tab，如果发现已存在的tab中已经有该url，则直接复用
+        func(tab), 通过规则筛选tab，返回符合条件的第1个tab，否则新建一个tab
+    """
+
+    if isinstance(dp_tab, Chromium):
+        return dp_tab.latest_tab
+    elif isinstance(dp_tab, ChromiumTab):
+        return dp_tab
+    elif callable(dp_tab):
+        page0 = Chromium()
+        for tab in page0.get_tabs():
+            if dp_tab(tab):
+                return tab
+        return page0.new_tab()
+    elif dp_tab is True:
+        return Chromium().new_tab()
+    elif isinstance(dp_tab, str):
+        def dp_page2(tab):  # 默认开启页面复用
+            if tab.url == dp_tab:
+                return tab
+
+        tab = get_dp_tab(dp_page2)
+        if tab.url == 'about:blank':
+            tab.get(dp_tab)
+        return tab
+    else:
+        return Chromium().latest_tab
+
+
+def get_latest_not_dev_tab(browser=None):
+    """ 开发工具本身也会算一个tab，这个函数返回最新的一个不是开发工具的tab """
+    if browser is None:
+        browser = Chromium()
+    tabs = browser.get_tabs()
+    for tab in tabs:
+        if strfind(tab.url, ['devtools://', 'chrome-extension://']) != -1:
+            continue
+        return tab
+
+
+class XlChromiumBase(ChromiumBase):
+    def get2(self, url, show_errmsg=False, retry=None, interval=None):
+        """
+        240418周四21:57，DrissionPage-4.0.4.21 官方自带page.get，有时候会有bug，不会实际刷新url，这里加个代码进行fix
+        """
+        old_url = self.url
+        if old_url == url:
+            # page.refresh()
+            return
+
+        ele = self.active_ele
+        self.get(url, show_errmsg=show_errmsg, retry=retry, interval=interval)
+        try:  # 如果新页面获取成功，理论上旧的ele会失效
+            ele
+            self.refresh()  # 如果不报错，这里网站要强制更新
+            return self
+        except DrissionPage.errors.ElementLostError:
+            return self
+
+    def get_download_files(self: Chromium):
+        """ 获取下载列表
+
+         (241205周四21:02，这个功能原本是用来做页面文件下载的，
+        但后来知道dp有更简洁的解决方案后，其实原本功能意义已不大，
+        只是作为一个结构化解析下载页面的功能，可以保留参考)
+
+        :param search_name: 搜索文件名，输入该参数时，只会从上往下找到第一个匹配的文件
+            否则返回一个list结构，存储下载清单里的文件
+        :return:
+
+        todo 默认应该显示是不全的，有时间可以考虑往下滑动继续检索的功能
+        """
+        files = []
+        page2 = Chromium().new_tab('chrome://downloads/')
+        items = page2('tag:downloads-manager', timeout=1).sr('#mainContainer')('#downloadsList').eles(
+            'tag:downloads-item')
+        for item in items:
+            loc = unquote(item.sr('tag:img').attr('src').replace('+', ' '))
+            file = re.search(r'path=(.+?)(&scale=(\d+(\.\d+)?)x)?$', loc).group(1)
+
+            files.append({
+                'file': file,
+                'url': unquote(item.sr('#url').attr('href'))
+            })
+
+        page2.close()
+
+        return files
+
+    def wait_page_not_change(self, interval=3):
+        """ 等待直到页面内容不再变化
+
+        :param interval: 时间间隔，需要判断当前内容和interval秒后的内容，看内容是否欧发生改变
+        """
+        last_html, last_etag = None, None
+        while True:
+            html = self.html
+            etag = GetEtag.from_text(html)
+            if etag == last_etag:
+                break
+
+            last_html, last_etag = html, etag
+            time.sleep(interval)
+        return last_html
+
+    def action_type(self, ele, text, clear=True):
+        """ 基于action实现的重写入，常用于日期相关操作
+        因为很多日期类组件，直接使用ele.input是不生效的，哪怕看似显示了文本，但其实并没有触发js改动，需要用动作链来实现
+        """
+        from DrissionPage.common import Keys
+        if clear:
+            self.actions.click(ele).key_down(Keys.CTRL).type('a').key_up(Keys.CTRL).type(text)
+        else:
+            self.actions.click(ele).type(text)
+
+
+inject_members(XlChromiumBase, ChromiumBase)
+
+
+class XlPage(XlChromiumBase, ChromiumTab, Chromium):
+    """ 只作为一个类型标记，无实质功能。在猴子补丁背景下，让ide能正确跳转函数定义。 """
+    pass
+
+
+class XlTab(XlChromiumBase, ChromiumTab, Chromium):
+    pass
+
+
+def wait_page_not_change(page, interval=3):
+    page.wait_page_not_change(interval)
+
+
+class DpWebBase:
+    """ 基于dp开发的爬虫工具的一个基础类 """
+
+    def __init__(self, url=None, *, base_url=None):
+        self.browser = Chromium()
+        self.browser.set.download_path(tempfile.gettempdir())
+
+        parsed_url = urlparse(url)
+        root_url = f"{parsed_url.scheme}://{parsed_url.netloc}"  # 构建基础 URL
+        self.tab: XlTab = self.browser.new_tab(url)
+        self.base_url = base_url or root_url  # 使用基础 URL 作为 base_url，后续同域名网站去重用
+
+    def close_if_exceeds_min_tabs(self, min_tabs_to_keep=1):
+        """ 检查同网站的tab数量，如果超过最小保留数量则关闭当前页面 """
+        try:  # 靠Py结束触发的可能报错：ImportError: sys.meta_path is None, Python is likely shutting down
+            if self.tab and self.base_url and len(self.browser.get_tabs(url=self.base_url)) > min_tabs_to_keep:
+                self.tab.close()
+        except Exception as e:
+            pass
+
+    # 实测效果不稳定，感觉还不如手动触发吧~
+    # def __del__(self):
+    #     """ 我习惯每次新任务建立新的tab处理，并在结束后自动检查同网页打开的标签是否不唯一则删掉 """
+    #     self.close_if_exceeds_min_tabs()
+
+
+def close_duplicate_tabs(browser=None):
+    """ 关闭浏览器重复标签页
+
+    遍历所有标签页（从前往后，dp的get_tabs拿到的tab就是从新到旧的），对每个域名仅保留第一个出现的标签页，其余同域名标签页关闭；
+    如果最后还剩多个标签页，则把'chrome://newtab/'也关掉。
+    """
+    # 1 初始化
+    if browser is None:
+        browser = Chromium()
+
+    # 250115周三21:12 这步不稳定，会报错，不知道为啥。导致dp最后经常没有清理tabs
+    # 250204周二09:21，好像是浏览器重启更新到最新版本就行了~ 这里也要加个try
+    try:
+        all_tabs = browser.get_tabs()
+    except TimeoutError:
+        logger.warning(
+            'browser.get_tabs()运行报错，请清查浏览器是否已更新但没有重启。本次将browser.quit()退出整个浏览器。')
+        # 你不让我关tabs是吧，那我就把整个浏览器关了
+        browser.quit()
+        return
+
+    seen_domains = set()
+
+    # 2 第一次遍历：保留首个出现的域名，其余重复则关闭
+    for t in all_tabs:
+        parsed_url = urlparse(t.url)
+        domain = parsed_url.netloc  # netloc 通常可拿到域名部分
+        # logger.info(f'{t.url}, {domain}')
+
+        if domain in seen_domains:
+            t.close()
+        else:
+            seen_domains.add(domain)
+
+    # 3 第二次遍历：如果剩余标签页 > 1，则关掉chrome://newtab/
+    remaining_tabs = browser.get_tabs()
+    if len(remaining_tabs) > 1:
+        for t in remaining_tabs:
+            if t.url.startswith('chrome://newtab'):
+                t.close()
+
+
+def dp_check_quit():
+    """ 检查当前页面是否只剩空标签页，则浏览器可以自动退出 """
+    browser = Chromium()
+    try:
+        tabs = browser.get_tabs()
+    except TimeoutError:
+        logger.warning('browser.get_tabs()运行报错，浏览器可能已更新但没有重启。将退出浏览器。')
+        browser.quit()
+        return
+
+    # 检查是否只剩下空标签页
+    if len(tabs) == 1 and tabs[0].url.startswith('chrome://newtab'):
+        # 如果只剩下一个空标签页，则退出浏览器
+        browser.quit()
+    elif len(tabs) == 0:
+        # 如果没有标签页，也退出浏览器
+        browser.quit()