552 lines
22 KiB
Python
552 lines
22 KiB
Python
import os
|
|
import shutil
|
|
import zipfile
|
|
import pandas as pd
|
|
from datetime import datetime
|
|
from pathlib import Path
|
|
from utils.logger import log
|
|
|
|
class FileHandler:
|
|
"""
|
|
通用文件操作工具类（所有输入输出均为DataFrame格式）
|
|
功能包括：文件读写、目录操作、文件压缩、路径处理等
|
|
"""
|
|
|
|
def __init__(self, base_path=None):
|
|
"""
|
|
初始化文件处理器
|
|
:param base_path: 基础路径，所有操作将基于此路径
|
|
"""
|
|
self.base_path = Path(base_path) if base_path else None
|
|
self.log = log.bind(module=self.__class__.__name__)
|
|
|
|
def _resolve_path(self, path):
|
|
"""解析路径，处理相对路径和绝对路径"""
|
|
path = Path(path)
|
|
if not path.is_absolute() and self.base_path:
|
|
return self.base_path / path
|
|
return path
|
|
|
|
def _to_dataframe(self, data, columns=None):
|
|
"""将数据转换为DataFrame格式"""
|
|
if isinstance(data, pd.DataFrame):
|
|
return data
|
|
if isinstance(data, dict):
|
|
return pd.DataFrame([data])
|
|
if isinstance(data, list):
|
|
return pd.DataFrame(data, columns=columns) if columns else pd.DataFrame(data)
|
|
return pd.DataFrame([{'value': data}])
|
|
|
|
def read_file(self, file_path, encoding='utf-8', **kwargs):
|
|
"""
|
|
读取文件内容为DataFrame
|
|
:param file_path: 文件路径
|
|
:param encoding: 文件编码
|
|
:param kwargs: pandas.read_* 方法的其他参数
|
|
:return: DataFrame
|
|
"""
|
|
file_path = self._resolve_path(file_path)
|
|
try:
|
|
ext = self.get_file_extension(file_path).lower()
|
|
|
|
if ext in ['csv', 'txt']:
|
|
df = pd.read_csv(file_path, encoding=encoding, **kwargs)
|
|
elif ext in ['xls', 'xlsx']:
|
|
df = pd.read_excel(file_path, **kwargs)
|
|
elif ext == 'json':
|
|
df = pd.read_json(file_path, encoding=encoding, **kwargs)
|
|
elif ext == 'parquet':
|
|
df = pd.read_parquet(file_path, **kwargs)
|
|
else:
|
|
# 默认按文本文件处理
|
|
with open(file_path, 'r', encoding=encoding) as f:
|
|
content = f.read()
|
|
df = self._to_dataframe({'content': content})
|
|
|
|
self.log.debug("文件读取成功 | path={} shape={}", file_path, df.shape)
|
|
return df
|
|
except Exception as e:
|
|
self.log.error("文件读取失败 | path={} error={}", file_path, str(e))
|
|
raise
|
|
|
|
def write_file(self, file_path, data, encoding='utf-8', **kwargs):
|
|
"""
|
|
将DataFrame写入文件
|
|
:param file_path: 文件路径
|
|
:param data: 要写入的DataFrame数据
|
|
:param encoding: 文件编码
|
|
:param kwargs: pandas.to_* 方法的其他参数
|
|
:return: DataFrame({'success': bool, 'file_path': str, 'file_size': int})
|
|
"""
|
|
file_path = self._resolve_path(file_path)
|
|
df = self._to_dataframe(data)
|
|
|
|
try:
|
|
self.create_dir(os.path.dirname(file_path))
|
|
ext = self.get_file_extension(file_path) # 现在返回的是字符串
|
|
|
|
if ext in ['csv', 'txt']:
|
|
df.to_csv(file_path, encoding=encoding, index=False, **kwargs)
|
|
elif ext in ['xls', 'xlsx']:
|
|
df.to_excel(file_path, index=False, **kwargs)
|
|
elif ext == 'json':
|
|
df.to_json(file_path, force_ascii=False, **kwargs)
|
|
elif ext == 'parquet':
|
|
df.to_parquet(file_path, **kwargs)
|
|
else:
|
|
# 默认按文本文件处理
|
|
content = df.to_string(index=False)
|
|
with open(file_path, 'w', encoding=encoding) as f:
|
|
f.write(content)
|
|
|
|
file_size = os.path.getsize(file_path)
|
|
result = {
|
|
'success': True,
|
|
'file_path': str(file_path),
|
|
'file_size': file_size
|
|
}
|
|
self.log.debug("文件写入成功 | path={} size={} bytes", file_path, file_size)
|
|
return self._to_dataframe(result)
|
|
except Exception as e:
|
|
self.log.error("文件写入失败 | path={} error={}", file_path, str(e))
|
|
raise
|
|
|
|
def read_lines(self, file_path, encoding='utf-8', columns=['line_content']):
|
|
"""
|
|
按行读取文件内容为DataFrame
|
|
:param file_path: 文件路径
|
|
:param encoding: 文件编码
|
|
:param columns: 列名列表
|
|
:return: DataFrame
|
|
"""
|
|
file_path = self._resolve_path(file_path)
|
|
try:
|
|
with open(file_path, 'r', encoding=encoding) as f:
|
|
lines = f.readlines()
|
|
|
|
df = self._to_dataframe(lines, columns=columns)
|
|
self.log.debug("文件按行读取成功 | path={} lines={}", file_path, len(df))
|
|
return df
|
|
except Exception as e:
|
|
self.log.error("文件按行读取失败 | path={} error={}", file_path, str(e))
|
|
raise
|
|
|
|
def write_lines(self, file_path, data, encoding='utf-8', line_column=None):
|
|
"""
|
|
将DataFrame按行写入文件
|
|
:param file_path: 文件路径
|
|
:param data: 要写入的DataFrame数据
|
|
:param encoding: 文件编码
|
|
:param line_column: 指定作为行内容的列名
|
|
"""
|
|
file_path = self._resolve_path(file_path)
|
|
df = self._to_dataframe(data)
|
|
|
|
try:
|
|
self.create_dir(os.path.dirname(file_path))
|
|
|
|
if line_column and line_column in df.columns:
|
|
lines = df[line_column].tolist()
|
|
else:
|
|
lines = df.to_string(index=False, header=False).split('\n')
|
|
|
|
with open(file_path, 'w', encoding=encoding) as f:
|
|
f.writelines([line + '\n' for line in lines])
|
|
|
|
self.log.debug("文件按行写入成功 | path={} lines={}", file_path, len(lines))
|
|
except Exception as e:
|
|
self.log.error("文件按行写入失败 | path={} error={}", file_path, str(e))
|
|
raise
|
|
|
|
def file_exists(self, file_path):
|
|
"""
|
|
检查文件是否存在
|
|
:param file_path: 文件路径
|
|
:return: DataFrame({'exists': bool})
|
|
"""
|
|
file_path = self._resolve_path(file_path)
|
|
exists = os.path.isfile(file_path)
|
|
self.log.trace("文件存在检查 | path={} exists={}", file_path, exists)
|
|
return self._to_dataframe({'exists': [exists]})
|
|
|
|
def dir_exists(self, dir_path):
|
|
"""
|
|
检查目录是否存在
|
|
:param dir_path: 目录路径
|
|
:return: DataFrame({'exists': bool})
|
|
"""
|
|
dir_path = self._resolve_path(dir_path)
|
|
exists = os.path.isdir(dir_path)
|
|
self.log.trace("目录存在检查 | path={} exists={}", dir_path, exists)
|
|
return self._to_dataframe({'exists': [exists]})
|
|
|
|
def create_dir(self, dir_path):
|
|
"""
|
|
创建目录（包括父目录）
|
|
:param dir_path: 目录路径
|
|
:return: DataFrame({'created': bool, 'path': str})
|
|
"""
|
|
dir_path = self._resolve_path(dir_path)
|
|
try:
|
|
os.makedirs(dir_path, exist_ok=True)
|
|
self.log.debug("目录创建成功 | path={}", dir_path)
|
|
return self._to_dataframe({'created': [True], 'path': [str(dir_path)]})
|
|
except Exception as e:
|
|
self.log.error("目录创建失败 | path={} error={}", dir_path, str(e))
|
|
raise
|
|
|
|
def delete_file(self, file_path):
|
|
"""
|
|
删除文件
|
|
:param file_path: 文件路径
|
|
:return: DataFrame({'deleted': bool, 'path': str})
|
|
"""
|
|
file_path = self._resolve_path(file_path)
|
|
try:
|
|
exists = self.file_exists(file_path).iloc[0]['exists']
|
|
if exists:
|
|
os.remove(file_path)
|
|
self.log.debug("文件删除成功 | path={}", file_path)
|
|
return self._to_dataframe({'deleted': [True], 'path': [str(file_path)]})
|
|
return self._to_dataframe({'deleted': [False], 'path': [str(file_path)]})
|
|
except Exception as e:
|
|
self.log.error("文件删除失败 | path={} error={}", file_path, str(e))
|
|
raise
|
|
|
|
def delete_dir(self, dir_path):
|
|
"""
|
|
删除目录及其内容
|
|
:param dir_path: 目录路径
|
|
:return: DataFrame({'deleted': bool, 'path': str})
|
|
"""
|
|
dir_path = self._resolve_path(dir_path)
|
|
try:
|
|
exists = self.dir_exists(dir_path).iloc[0]['exists']
|
|
if exists:
|
|
shutil.rmtree(dir_path)
|
|
self.log.debug("目录删除成功 | path={}", dir_path)
|
|
return self._to_dataframe({'deleted': [True], 'path': [str(dir_path)]})
|
|
return self._to_dataframe({'deleted': [False], 'path': [str(dir_path)]})
|
|
except Exception as e:
|
|
self.log.error("目录删除失败 | path={} error={}", dir_path, str(e))
|
|
raise
|
|
|
|
def copy_file(self, src_path, dst_path):
|
|
"""
|
|
复制文件
|
|
:param src_path: 源文件路径
|
|
:param dst_path: 目标文件路径
|
|
:return: DataFrame({'copied': bool, 'source': str, 'destination': str})
|
|
"""
|
|
src_path = self._resolve_path(src_path)
|
|
dst_path = self._resolve_path(dst_path)
|
|
try:
|
|
self.create_dir(os.path.dirname(dst_path))
|
|
shutil.copy2(src_path, dst_path)
|
|
self.log.debug("文件复制成功 | src={} dst={}", src_path, dst_path)
|
|
return self._to_dataframe({
|
|
'copied': [True],
|
|
'source': [str(src_path)],
|
|
'destination': [str(dst_path)]
|
|
})
|
|
except Exception as e:
|
|
self.log.error("文件复制失败 | src={} dst={} error={}",
|
|
src_path, dst_path, str(e))
|
|
raise
|
|
|
|
def move_file(self, src_path, dst_path):
|
|
"""
|
|
移动/重命名文件
|
|
:param src_path: 源文件路径
|
|
:param dst_path: 目标文件路径
|
|
:return: DataFrame({'moved': bool, 'source': str, 'destination': str})
|
|
"""
|
|
src_path = self._resolve_path(src_path)
|
|
dst_path = self._resolve_path(dst_path)
|
|
try:
|
|
self.create_dir(os.path.dirname(dst_path))
|
|
shutil.move(src_path, dst_path)
|
|
self.log.debug("文件移动成功 | src={} dst={}", src_path, dst_path)
|
|
return self._to_dataframe({
|
|
'moved': [True],
|
|
'source': [str(src_path)],
|
|
'destination': [str(dst_path)]
|
|
})
|
|
except Exception as e:
|
|
self.log.error("文件移动失败 | src={} dst={} error={}",
|
|
src_path, dst_path, str(e))
|
|
raise
|
|
|
|
def list_files(self, dir_path, recursive=False, pattern='*'):
|
|
"""
|
|
列出目录中的文件
|
|
:param dir_path: 目录路径
|
|
:param recursive: 是否递归查找
|
|
:param pattern: 文件匹配模式
|
|
:return: DataFrame({'file_path': str, 'file_name': str, 'extension': str})
|
|
"""
|
|
dir_path = self._resolve_path(dir_path)
|
|
try:
|
|
if recursive:
|
|
files = [str(f) for f in Path(dir_path).rglob(pattern) if f.is_file()]
|
|
else:
|
|
files = [str(f) for f in Path(dir_path).glob(pattern) if f.is_file()]
|
|
|
|
result = []
|
|
for f in files:
|
|
p = Path(f)
|
|
result.append({
|
|
'file_path': str(p),
|
|
'file_name': p.name,
|
|
'extension': p.suffix.lower().lstrip('.')
|
|
})
|
|
|
|
df = self._to_dataframe(result)
|
|
self.log.trace("列出目录文件 | path={} recursive={} count={}",
|
|
dir_path, recursive, len(df))
|
|
return df
|
|
except Exception as e:
|
|
self.log.error("列出文件失败 | path={} error={}", dir_path, str(e))
|
|
raise
|
|
|
|
def list_dirs(self, dir_path, recursive=False):
|
|
"""
|
|
列出目录中的子目录
|
|
:param dir_path: 目录路径
|
|
:param recursive: 是否递归查找
|
|
:return: DataFrame({'dir_path': str, 'dir_name': str})
|
|
"""
|
|
dir_path = self._resolve_path(dir_path)
|
|
try:
|
|
if recursive:
|
|
dirs = [str(d) for d in Path(dir_path).rglob('*') if d.is_dir()]
|
|
else:
|
|
dirs = [str(d) for d in Path(dir_path).glob('*') if d.is_dir()]
|
|
|
|
result = [{'dir_path': d, 'dir_name': Path(d).name} for d in dirs]
|
|
df = self._to_dataframe(result)
|
|
self.log.trace("列出子目录 | path={} recursive={} count={}",
|
|
dir_path, recursive, len(df))
|
|
return df
|
|
except Exception as e:
|
|
self.log.error("列出目录失败 | path={} error={}", dir_path, str(e))
|
|
raise
|
|
|
|
def get_file_size(self, file_path):
|
|
"""
|
|
获取文件大小（字节）
|
|
:param file_path: 文件路径
|
|
:return: DataFrame({'file_path': str, 'size_bytes': int, 'size_mb': float})
|
|
"""
|
|
file_path = self._resolve_path(file_path)
|
|
try:
|
|
size_bytes = os.path.getsize(file_path)
|
|
result = {
|
|
'file_path': str(file_path),
|
|
'size_bytes': size_bytes,
|
|
'size_mb': round(size_bytes / 1024 / 1024, 4)
|
|
}
|
|
df = self._to_dataframe(result)
|
|
self.log.trace("获取文件大小 | path={} size={} bytes", file_path, size_bytes)
|
|
return df
|
|
except Exception as e:
|
|
self.log.error("获取文件大小失败 | path={} error={}", file_path, str(e))
|
|
raise
|
|
|
|
def get_file_modified_time(self, file_path):
|
|
"""
|
|
获取文件修改时间
|
|
:param file_path: 文件路径
|
|
:return: DataFrame({'file_path': str, 'modified_time': datetime, 'timestamp': float})
|
|
"""
|
|
file_path = self._resolve_path(file_path)
|
|
try:
|
|
mtime = datetime.fromtimestamp(os.path.getmtime(file_path))
|
|
result = {
|
|
'file_path': str(file_path),
|
|
'modified_time': mtime,
|
|
'timestamp': mtime.timestamp()
|
|
}
|
|
df = self._to_dataframe(result)
|
|
self.log.trace("获取文件修改时间 | path={} mtime={}",
|
|
file_path, mtime.isoformat())
|
|
return df
|
|
except Exception as e:
|
|
self.log.error("获取文件修改时间失败 | path={} error={}",
|
|
file_path, str(e))
|
|
raise
|
|
|
|
def zip_files(self, file_paths, zip_path):
|
|
"""
|
|
压缩多个文件到zip
|
|
:param file_paths: 要压缩的文件路径列表或DataFrame
|
|
:param zip_path: 压缩文件路径
|
|
:return: DataFrame({'zipped': bool, 'zip_path': str, 'file_count': int})
|
|
"""
|
|
zip_path = self._resolve_path(zip_path)
|
|
|
|
# 处理输入可以是DataFrame或列表
|
|
if isinstance(file_paths, pd.DataFrame):
|
|
if 'file_path' in file_paths.columns:
|
|
file_list = file_paths['file_path'].tolist()
|
|
else:
|
|
file_list = file_paths.iloc[:, 0].tolist()
|
|
else:
|
|
file_list = file_paths
|
|
|
|
try:
|
|
self.create_dir(os.path.dirname(zip_path))
|
|
file_count = 0
|
|
with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
|
|
for file_path in file_list:
|
|
file_path = self._resolve_path(file_path)
|
|
if self.file_exists(file_path).iloc[0]['exists']:
|
|
zipf.write(file_path, os.path.basename(file_path))
|
|
file_count += 1
|
|
|
|
result = {
|
|
'zipped': True,
|
|
'zip_path': str(zip_path),
|
|
'file_count': file_count
|
|
}
|
|
self.log.info("文件压缩成功 | zip={} files={}", zip_path, file_count)
|
|
return self._to_dataframe(result)
|
|
except Exception as e:
|
|
self.log.error("文件压缩失败 | zip={} error={}", zip_path, str(e))
|
|
raise
|
|
|
|
def zip_dir(self, dir_path, zip_path):
|
|
"""
|
|
压缩整个目录到zip
|
|
:param dir_path: 要压缩的目录路径
|
|
:param zip_path: 压缩文件路径
|
|
:return: DataFrame({'zipped': bool, 'zip_path': str, 'dir_path': str, 'file_count': int})
|
|
"""
|
|
dir_path = self._resolve_path(dir_path)
|
|
zip_path = self._resolve_path(zip_path)
|
|
try:
|
|
self.create_dir(os.path.dirname(zip_path))
|
|
file_count = 0
|
|
with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
|
|
for root, dirs, files in os.walk(dir_path):
|
|
for file in files:
|
|
file_path = os.path.join(root, file)
|
|
arcname = os.path.relpath(file_path, dir_path)
|
|
zipf.write(file_path, arcname)
|
|
file_count += 1
|
|
|
|
result = {
|
|
'zipped': True,
|
|
'zip_path': str(zip_path),
|
|
'dir_path': str(dir_path),
|
|
'file_count': file_count
|
|
}
|
|
self.log.info("目录压缩成功 | zip={} dir={} files={}",
|
|
zip_path, dir_path, file_count)
|
|
return self._to_dataframe(result)
|
|
except Exception as e:
|
|
self.log.error("目录压缩失败 | zip={} error={}", zip_path, str(e))
|
|
raise
|
|
|
|
def unzip(self, zip_path, extract_to=None):
|
|
"""
|
|
解压zip文件
|
|
:param zip_path: zip文件路径
|
|
:param extract_to: 解压目标目录，默认为zip文件所在目录
|
|
:return: DataFrame({'unzipped': bool, 'zip_path': str, 'extract_to': str, 'file_count': int})
|
|
"""
|
|
zip_path = self._resolve_path(zip_path)
|
|
if extract_to is None:
|
|
extract_to = os.path.dirname(zip_path)
|
|
else:
|
|
extract_to = self._resolve_path(extract_to)
|
|
|
|
try:
|
|
self.create_dir(extract_to)
|
|
with zipfile.ZipFile(zip_path, 'r') as zipf:
|
|
file_list = zipf.namelist()
|
|
zipf.extractall(extract_to)
|
|
|
|
result = {
|
|
'unzipped': True,
|
|
'zip_path': str(zip_path),
|
|
'extract_to': str(extract_to),
|
|
'file_count': len(file_list)
|
|
}
|
|
self.log.info("文件解压成功 | zip={} extract_to={} files={}",
|
|
zip_path, extract_to, len(file_list))
|
|
return self._to_dataframe(result)
|
|
except Exception as e:
|
|
self.log.error("文件解压失败 | zip={} error={}", zip_path, str(e))
|
|
raise
|
|
|
|
def compress_large_log(self, log_path, max_size_mb=20):
|
|
"""
|
|
压缩过大的日志文件
|
|
:param log_path: 日志文件路径
|
|
:param max_size_mb: 最大大小(MB)，超过则压缩
|
|
:return: DataFrame({'compressed': bool, 'original_path': str, 'zip_path': str, 'original_size_mb': float})
|
|
"""
|
|
log_path = self._resolve_path(log_path)
|
|
if not self.file_exists(log_path).iloc[0]['exists']:
|
|
return self._to_dataframe({'compressed': [False]})
|
|
|
|
max_size_bytes = max_size_mb * 1024 * 1024
|
|
size_info = self.get_file_size(log_path)
|
|
current_size = size_info.iloc[0]['size_bytes']
|
|
|
|
if current_size > max_size_bytes:
|
|
try:
|
|
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
|
|
zip_path = f"{log_path}_{timestamp}.zip"
|
|
self.zip_files([log_path], zip_path)
|
|
self.delete_file(log_path)
|
|
|
|
result = {
|
|
'compressed': True,
|
|
'original_path': str(log_path),
|
|
'zip_path': zip_path,
|
|
'original_size_mb': round(current_size/1024/1024, 2)
|
|
}
|
|
self.log.info("日志文件压缩 | original={} compressed={} original_size={} MB",
|
|
log_path, zip_path, result['original_size_mb'])
|
|
return self._to_dataframe(result)
|
|
except Exception as e:
|
|
self.log.error("日志压缩失败 | path={} error={}", log_path, str(e))
|
|
raise
|
|
|
|
return self._to_dataframe({'compressed': [False]})
|
|
|
|
def get_file_extension(self, file_path):
|
|
"""
|
|
获取文件扩展名
|
|
:param file_path: 文件路径
|
|
:return: 文件扩展名字符串（小写，不带点）
|
|
"""
|
|
file_path = self._resolve_path(file_path)
|
|
ext = Path(file_path).suffix.lower().lstrip('.')
|
|
self.log.trace("获取文件扩展名 | path={} ext={}", file_path, ext)
|
|
return ext # 直接返回字符串而不是DataFrame
|
|
|
|
def change_file_extension(self, file_path, new_extension):
|
|
"""
|
|
修改文件扩展名
|
|
:param file_path: 文件路径
|
|
:param new_extension: 新扩展名（不带点）
|
|
:return: DataFrame({'original_path': str, 'new_path': str})
|
|
"""
|
|
file_path = self._resolve_path(file_path)
|
|
new_path = str(Path(file_path).with_suffix(f'.{new_extension}'))
|
|
result = {'original_path': str(file_path), 'new_path': new_path}
|
|
self.log.debug("修改文件扩展名 | original={} new={}", file_path, new_path)
|
|
return self._to_dataframe(result)
|
|
|
|
def join_path(self, *paths):
|
|
"""
|
|
拼接路径
|
|
:param paths: 多个路径部分
|
|
:return: DataFrame({'joined_path': str})
|
|
"""
|
|
joined_path = str(Path(*paths))
|
|
self.log.trace("路径拼接 | parts={} result={}", paths, joined_path)
|
|
return self._to_dataframe({'joined_path': [joined_path]}) |