DrissionRecord 1.0.0__tar.gz

drissionrecord-1.0.0/DrissionRecord/__init__.py

@@ -0,0 +1,7 @@
+from .byte_recorder import ByteRecorder
+from .db_recorder import DBRecorder
+from .recorder import Recorder
+from .cell_style import CellStyle
+from .tools import Col
+
+__version__ = '1.0.0'

drissionrecord-1.0.0/DrissionRecord/base.py

@@ -0,0 +1,193 @@
+# -*- coding:utf-8 -*-
+from abc import abstractmethod
+from pathlib import Path
+from threading import Lock
+from time import sleep
+
+from .setter import OriginalSetter, BaseSetter
+from .tools import get_usable_path, make_valid_name, get_tables, make_final_data_simplify
+
+
+class OriginalRecorder(object):
+    def __init__(self, path=None, cache_size=1000):
+        self._data = []
+        self._path = None
+        self._type = None
+        self._lock = Lock()
+        self._pause_add = False  # 文件写入时暂停接收输入
+        self._pause_write = False  # 标记文件正在被一个线程写入
+        self._setter = None
+        self._data_count = 0  # 已缓存数据的条数
+        self._file_exists = False
+        self._backup_path = 'backup'
+        self._backup_times = 0
+        self._backup_interval = 0  # 多少次就自动保存
+        self._backup_overwrite = False
+        self.show_msg = True
+        if path:
+            self.set.path(path)
+        self._cache = cache_size or 0
+
+    def __del__(self):
+        self.record()
+
+    @property
+    def set(self):
+        if self._setter is None:
+            self._setter = OriginalSetter(self)
+        return self._setter
+
+    @property
+    def cache_size(self):
+        return self._cache
+
+    @property
+    def path(self):
+        return self._path
+
+    @property
+    def type(self):
+        return self._type
+
+    @property
+    def data(self):
+        return self._data
+
+    def record(self):
+        if not self._data_count:
+            return self._path
+        if not self._path:
+            raise ValueError('保存路径为空。')
+
+        with self._lock:
+            if self._backup_interval and self._backup_times >= self._backup_interval:
+                self.backup(folder=self._backup_path, overwrite=self._backup_overwrite)
+
+            self._pause_add = True  # 写入文件前暂缓接收数据
+            if self.show_msg:
+                print(f'{self.path} 开始写入文件，切勿关闭进程。')
+
+            Path(self.path).parent.mkdir(parents=True, exist_ok=True)
+            while True:
+                try:
+                    while self._pause_write:  # 等待其它线程写入结束
+                        sleep(.02)
+
+                    self._pause_write = True
+                    self._record()
+                    break
+
+                except PermissionError:
+                    if self.show_msg:
+                        print('\r文件被打开，保存失败，请关闭，程序会自动重试。', end='')
+
+                except Exception as e:
+                    try:
+                        with open('failed_data.txt', 'a+', encoding='utf-8') as f:
+                            f.write(str(self.data) + '\n')
+                        print('保存失败的数据已保存到failed_data.txt。')
+                    except:
+                        raise e
+                    raise
+
+                finally:
+                    self._pause_write = False
+
+                sleep(.3)
+
+            if self.show_msg:
+                print(f'{self.path} 写入文件结束。')
+            self.clear()
+            self._pause_add = False
+
+        if self._backup_interval:
+            self._backup_times += 1
+        self._file_exists = True
+        return self._path
+
+    def clear(self):
+        self._data.clear()
+        self._data_count = 0
+
+    def backup(self, folder=None, name=None, overwrite=None):
+        src_path = Path(self._path)
+        if not self._file_exists:
+            if not src_path.exists():
+                return ''
+            self._file_exists = True
+
+        if overwrite is None:
+            overwrite = self._backup_overwrite
+        folder = Path(folder if folder else self._backup_path)
+        folder.mkdir(parents=True, exist_ok=True)
+        if not name:
+            name = src_path.name
+        elif not name.endswith(src_path.suffix):
+            name = f'{name}{src_path.suffix}'
+        path = folder / make_valid_name(name)
+        if not overwrite and path.exists():
+            from datetime import datetime
+            name = f'{path.stem}_{datetime.now().strftime("%Y%m%d%H%M%S")}{path.suffix}'
+            path = get_usable_path(folder / name)
+
+        from shutil import copy
+        copy(self._path, path)
+        self._backup_times = 0
+        return str(path.absolute())
+
+    @abstractmethod
+    def add_data(self, data):
+        pass
+
+    @abstractmethod
+    def _record(self):
+        pass
+
+
+class BaseRecorder(OriginalRecorder):
+    def __init__(self, path=None, cache_size=None):
+        super().__init__(path, cache_size)
+        self._before = []
+        self._after = []
+        self._encoding = 'utf-8'
+        self._table = None
+        self._make_final_data = make_final_data_simplify
+        self._auto_new_header = False
+
+    @property
+    def set(self):
+        if self._setter is None:
+            self._setter = BaseSetter(self)
+        return self._setter
+
+    @property
+    def before(self):
+        return self._before
+
+    @property
+    def after(self):
+        return self._after
+
+    @property
+    def table(self):
+        return self._table
+
+    @property
+    def tables(self):
+        if self._type != 'xlsx':
+            raise TypeError('只有xlsx格式能使用tables属性。')
+        if not self._path:
+            raise RuntimeError('未指定文件路径。')
+        return get_tables(self._path)
+
+    @property
+    def encoding(self):
+        return self._encoding
+
+    @abstractmethod
+    def add_data(self, data, table=None):
+        pass
+
+    @abstractmethod
+    def _record(self):
+        pass

drissionrecord-1.0.0/DrissionRecord/base.pyi

@@ -0,0 +1,143 @@
+# -*- coding:utf-8 -*-
+from abc import abstractmethod
+from pathlib import Path
+from threading import Lock
+from typing import Union, Optional, Callable
+
+from .setter import OriginalSetter, BaseSetter
+
+
+class OriginalRecorder(object):
+    """记录器的基类"""
+    _cache: int = ...
+    _path: Optional[str] = ...
+    _type: Optional[str] = ...
+    _data: list = ...
+    _lock: Lock = ...
+    _pause_add: bool = ...
+    _pause_write: bool = ...
+    _setter: Optional[OriginalSetter] = ...
+    _data_count: int = ...
+    _file_exists: bool = ...
+    _backup_path: str = ...
+    _backup_times: int = ...
+    _backup_interval: int = ...
+    _backup_overwrite: bool = ...
+    show_msg: bool = ...
+
+    def __init__(self,
+                 path: Union[str, Path, None] = None,
+                 cache_size: int = None) -> None:
+        """
+        :param path: 保存的文件路径
+        :param cache_size: 每接收多少条记录写入文件，0为不自动写入
+        """
+        ...
+
+    def __del__(self) -> None:
+        """对象关闭时把剩下的数据写入文件"""
+        ...
+
+    @property
+    def set(self) -> OriginalSetter:
+        """返回用于设置属性的对象"""
+        ...
+
+    @property
+    def cache_size(self) -> int:
+        """返回缓存大小"""
+        ...
+
+    @property
+    def path(self) -> str:
+        """返回文件路径"""
+        ...
+
+    @property
+    def type(self) -> str:
+        """返回文件类型"""
+        ...
+
+    @property
+    def data(self) -> Union[dict, list]:
+        """返回当前保存在缓存的数据"""
+        ...
+
+    def record(self) -> str:
+        """记录数据，返回文件路径"""
+        ...
+
+    def clear(self) -> None:
+        """清空缓存中的数据"""
+        ...
+
+    def backup(self,
+               folder: Union[str, Path, None] = None,
+               name: str = None,
+               overwrite: bool = None) -> str:
+        """把当前文件备份到指定路径
+        :param folder: 文件夹路径，为None使用内置路径（初始 'backup'）
+        :param name: 保存的文件名，可不含后缀，为None使用内置路径文件名
+        :param overwrite: 是否覆盖同名文件，为False时每次备份文件名添加当前时间，为None使用内置设置
+        """
+        ...
+
+    @abstractmethod
+    def add_data(self, data):
+        ...
+
+    @abstractmethod
+    def _record(self):
+        ...
+
+
+class BaseRecorder(OriginalRecorder):
+    """Recorder和DBRecorder的父类"""
+    _encoding: str = ...
+    _before: Optional[list] = ...
+    _after: Optional[list] = ...
+    _table: Optional[str] = ...
+    _setter: BaseSetter = ...
+    _make_final_data: Callable = ...
+    _auto_new_header: bool = ...
+
+    def __init__(self, path: Union[None, str, Path] = None, cache_size: int = None) -> None:
+        """
+        :param path: 保存的文件路径
+        :param cache_size: 每接收多少条记录写入文件，0为不自动写入
+        """
+        ...
+
+    @property
+    def set(self) -> BaseSetter:
+        """返回用于设置属性的对象"""
+        ...
+
+    @property
+    def before(self) -> Union[dict, list]:
+        """返回当前before内容"""
+        ...
+
+    @property
+    def after(self) -> Union[dict, list]:
+        """返回当前after内容"""
+        ...
+
+    @property
+    def table(self) -> Optional[str]:
+        """返回当前使用的表名"""
+        ...
+
+    @property
+    def tables(self) -> list:
+        """返回所有表名"""
+        ...
+
+    @property
+    def encoding(self) -> str:
+        """返回csv文件使用的编码格式"""
+        ...
+
+    @abstractmethod
+    def _record(self):
+        ...

drissionrecord-1.0.0/DrissionRecord/byte_recorder.py

@@ -0,0 +1,42 @@
+# -*- coding:utf-8 -*-
+from pathlib import Path
+from time import sleep
+
+from .base import OriginalRecorder
+
+
+class ByteRecorder(OriginalRecorder):
+    __END = (0, 2)
+
+    def __init__(self, path=None, cache_size=1000):
+        super().__init__(path, cache_size)
+        self._type = 'byte'
+
+    def add_data(self, data, seek=None):
+        while self._pause_add:  # 等待其它线程写入结束
+            sleep(.02)
+
+        if not isinstance(data, bytes):
+            raise TypeError('只能接受bytes类型数据。')
+        if seek is not None and not (isinstance(seek, int) and seek >= 0):
+            raise ValueError('seek参数只能接受None或大于等于0的整数。')
+
+        self._data.append((data, seek))
+        self._data_count += 1
+
+        if 0 < self.cache_size <= self._data_count:
+            self.record()
+
+    def _record(self):
+        if not self._file_exists and not Path(self.path).exists():
+            with open(self.path, 'wb'):
+                pass
+
+        with open(self.path, 'rb+') as f:
+            previous = None
+            for i in self._data:
+                loc = ByteRecorder.__END if i[1] is None else (i[1], 0)
+                if not (previous == loc == ByteRecorder.__END):
+                    f.seek(loc[0], loc[1])
+                    previous = loc
+                f.write(i[0])

drissionrecord-1.0.0/DrissionRecord/byte_recorder.pyi

@@ -0,0 +1,33 @@
+# -*- coding:utf-8 -*-
+from pathlib import Path
+from typing import Union, Optional
+
+from .base import OriginalRecorder
+
+
+class ByteRecorder(OriginalRecorder):
+    __END: tuple = ...
+    data: list = ...
+
+    def __init__(self,
+                 path: Union[None, str, Path] = None,
+                 cache_size: int = 1000):
+        """用于记录字节数据的工具
+        :param path: 保存的文件路径
+        :param cache_size: 每接收多少条记录写入文件，0为不自动写入
+        """
+        ...
+
+    def add_data(self,
+                 data: bytes,
+                 seek: int = None) -> None:
+        """添加一段二进制数据
+        :param data: bytes类型数据
+        :param seek: 在文件中的位置，None表示最后
+        :return: None
+        """
+        ...
+
+    def _record(self) -> None:
+        """记录数据到文件"""
+        ...