import pandas as pd
import glob

# 读取数据
csv_files = glob.glob("2024中国气象站逐日数据/*.csv")

# 读取所有CSV文件并合并
combined_data = pd.DataFrame()
for file in csv_files:
    data = pd.read_csv(file, encoding='utf-8')
    combined_data = pd.concat([combined_data, data], ignore_index=True)
# 保存文件
combined_data.to_csv("2024中国气象站逐日数据-合并后.csv", index=False, encoding='utf-8')

import pandas as pd
from enum import Enum

class MssingValue(Enum):
    """
    缺失值
    """
    MAX = 9999.9
    MIN = 9999.9
    PRCP = 99.99
# 计算每个站点的月均值,并将数据转换为中国标准
def calculate_monthly_means(df):
    """
    计算每个站点的月均值
    :param df: 分组后的数据
    :return: 月均值数据
    """
    # 根据缺失值进行数据清洗
    df = df[df['MAX'] != MssingValue.MAX.value]
    df = df[df['MIN'] != MssingValue.MIN.value]
    df = df[df['PRCP'] != MssingValue.PRCP.value]

    # 将日期列转换为日期类型
    df['DATE'] = pd.to_datetime(df['DATE'], format='%Y-%m-%d')

    # 提取月份
    df['MONTH'] = df['DATE'].dt.month

    monthly_means = df.groupby(['STATION', 'MONTH']).agg({
        'MAX': 'mean',
        'MIN': 'mean',
        'PRCP': 'sum',  # 降水量求和
    }).reset_index()
    # 将月份转换为字符串格式
    monthly_means['MONTH'] = monthly_means['MONTH'].astype(str).str.zfill(2)
    # 每个站点的经纬度
    station_info = df[['STATION', 'LATITUDE', 'LONGITUDE', 'ELEVATION', 'NAME']].drop_duplicates(subset='STATION')
    monthly_means = monthly_means.merge(station_info, on='STATION', how='left')

    monthly_means['MAX'] = (monthly_means['MAX'] - 32) / 1.8  # 华氏度转摄氏度
    monthly_means['MIN'] = (monthly_means['MIN'] - 32) / 1.8  # 华氏度转摄氏度
    monthly_means['PRCP'] = monthly_means['PRCP'] * 25.4  # 英寸转毫米

    return monthly_means

# 处理数据
def process_data(file_path):
    """
    处理数据
    :param file_path: 文件路径
    :return: 处理后的数据
    """
    # 读取数据
    df = pd.read_csv(file_path)

    # 计算每个站点的月均值
    monthly_means = calculate_monthly_means(df)

    return monthly_means
# 主函数
if __name__ == "__main__":
    # 文件路径
    file_path = "2024中国气象站逐日数据-合并后.csv"
    # 处理数据
    processed_data = process_data(file_path)
    processed_data.to_csv("2024中国气象站逐日数据-月均值.csv", index=False)

import pandas as pd

# 读取数据
df = pd.read_csv('2024中国气象站逐日数据-月均值.csv')

# 按月分割数据
def split_monthly_data(df):
    # 将 'MONTH' 列转换为整数类型
    df['MONTH'] = df['MONTH'].astype(int)
    # 遍历每个月份
    for month in range(1, 13):
        # 过滤出当前月份的数据
        monthly_data = df[df['MONTH'] == month]
        # 将数据保存到 CSV 文件中，文件名为 'month_XX.csv'
        monthly_data.to_csv(f'2024中国气象站逐月数据/month_{month:02}.csv', index=False)
        print(f"Month {month:02} data saved to month_{month:02}.csv")

if __name__ == "__main__":
    split_monthly_data(df)

import pdfplumber
import re
from typing import List, Dict, Optional

class InvoiceExtractor:
    def _invoice_pdf2txt(self, pdf_path: str) -> Optional[str]:
        """
        使用 pdfplumber 从 PDF 文件中提取文本。
        :param pdf_path: PDF 文件的路径。
        :return: 提取的文本作为字符串返回，如果提取失败则返回 None。
        """
        try:
            with pdfplumber.open(pdf_path) as pdf:
                text = '\n'.join(page.extract_text() for page in pdf.pages if page.extract_text())
            return text
        except Exception as e:
            #print(f"从 {pdf_path} 提取文本时出错: {e}")
            return None

    def _extract_invoice_product_content(self, content: str) -> str:
        """
        从发票文本中提取商品相关内容。
        :param content: 发票的完整文本。
        :return: 提取的商品相关内容作为字符串返回。
        """
        lines = content.splitlines()
        start_pattern = re.compile(r"^(货物或应税劳务|项目名称)")
        end_pattern = re.compile(r"^价税合计")

        start_index = next((i for i, line in enumerate(lines) if start_pattern.match(line)), None)
        end_index = next((i for i, line in enumerate(lines) if end_pattern.match(line)), None)

        if start_index is not None and end_index is not None:
            extracted_lines = lines[start_index:end_index + 1]
            return '\n'.join(extracted_lines).strip()
        return "未找到匹配的内容"

    def construct_invoice_product_data(self, raw_text: str) -> List[Dict[str, str]]:
        """
        处理提取的文本，构建发票商品数据列表。
        :param raw_text: 提取的原始文本。
        :return: 商品数据列表，每个商品为一个字典。
        """
        blocks = re.split(r'(?=货物或应税劳务|项目名称)', raw_text.strip())
        records = []

        for block in blocks:
            lines = [line.strip() for line in block.splitlines() if line.strip()]
            if not lines:
                continue

            current_record = ""
            for line in lines[1:]:
                if line.startswith("合") or line.startswith("价税合计"):
                    continue

                if line.startswith("*"):
                    if current_record:
                        self._process_record(current_record, records)
                    current_record = line
                else:
                    if " " in current_record:
                        first_space_index = current_record.index(" ")
                        current_record = current_record[:first_space_index] + line + current_record[first_space_index:]

            if current_record:
                self._process_record(current_record, records)

        return records

    def _process_record(self, record: str, records: List[Dict[str, str]]):
        """
        处理单条记录并添加到记录列表中。
        :param record: 单条记录的字符串。
        :param records: 记录列表。
        """
        parts = record.rsplit(maxsplit=7)
        if len(parts) == 8:
            try:
                records.append({
                    "product_name": parts[0].strip(),
                    "specification": parts[1].strip(),
                    "unit": parts[2].strip(),
                    "quantity": parts[3].strip(),
                    "unit_price": float(parts[4].strip()),
                    "amount": float(parts[5].strip()),
                    "tax_rate": parts[6].strip(),
                    "tax_amount": float(parts[7].strip())
                })
            except ValueError as e:
                print(f"记录解析失败: {record}, 错误: {e}")
                pass

import openai
import json
import logging
from concurrent.futures import ThreadPoolExecutor, as_completed

# 设置日志记录
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

class MarkdownTranslator:
    def __init__(self, config_file):
        self.config = self.load_config(config_file)
        openai.api_key = self.config.get('OPENAI_API_KEY')
        openai.base_url = self.config.get('OPENAI_API_BASE')
        openai.default_headers = {"x-foo": "true"}

    # 从配置文件获取OpenAI API密钥和自定义服务器地址
    def load_config(self, config_file):
        try:
            with open(config_file, 'r', encoding='utf-8') as file:
                config = json.load(file)
                return config
        except Exception as e:
            logging.error(f"Error reading config file {config_file}: {e}")
            raise

    # 读取Markdown文件
    def read_markdown(self, file_path):
        try:
            with open(file_path, 'r', encoding='utf-8') as file:
                return file.read()
        except Exception as e:
            logging.error(f"Error reading file {file_path}: {e}")
            raise

    # 将翻译后的内容写入新的Markdown文件
    def write_markdown(self, file_path, content):
        try:
            with open(file_path, 'w', encoding='utf-8') as file:
                file.write(content)
        except Exception as e:
            logging.error(f"Error writing file {file_path}: {e}")
            raise

    # 翻译函数
    def translate_text(self, text, source_lang='en', target_lang='zh'):
        try:
            response = openai.chat.completions.create(
                model="gpt-4o-mini",
                messages=[
                    {
                        "role": "user",
                        "content": f"请将以下{source_lang}文本翻译成{target_lang}：\n{text}"
                    }
                ]
            )
            return response.choices[0].message.content.strip()
        except Exception as e:
            logging.error(f"Error translating text: {e}")
            return text  # 返回原文以防止翻译失败

    # 处理Markdown内容
    def process_markdown_content(self, content, source_lang, target_lang):
        lines = content.split('\n')
        translated_lines = []

        def translate_line(index, line):
            if line.strip():  # 忽略空行
                translated_line = self.translate_text(line, source_lang, target_lang)
                translated_lines.append((index, translated_line))
            else:
                translated_lines.append((index, ''))  # 保持空行

        with ThreadPoolExecutor(max_workers=10) as executor:
            futures = [executor.submit(translate_line, i, line) for i, line in enumerate(lines)]
            for future in as_completed(futures):
                future.result()  # 等待所有线程完成

        # 按原始顺序排序
        translated_lines.sort(key=lambda x: x[0])
        return '\n'.join(line for _, line in translated_lines)

    # 翻译文件
    def translate_file(self, input_file, output_file, source_lang='en', target_lang='zh'):
        # 打印参数
        logging.info(f"Translating file from {source_lang} to {target_lang}...")
        logging.info(f"OpenAi_key: {openai.api_key}")
        logging.info(f"OpenAi_base: {openai.base_url}")

        # 读取原始Markdown文件
        markdown_content = self.read_markdown(input_file)

        # 处理并翻译内容
        translated_content = self.process_markdown_content(markdown_content, source_lang, target_lang)

        # 写入新Markdown文件
        self.write_markdown(output_file, translated_content)

if __name__ == "__main__":
    # 输入和输出文件路径
    input_file_path = 'input.md'   # 输入的Markdown文件
    output_file_path = 'output.md'  # 输出的Markdown文件

    # 可选的源语言和目标语言
    source_language = 'en'  # 源语言（默认为英文）
    target_language = 'zh'  # 目标语言（默认为中文）

    translator = MarkdownTranslator('config.json')
    translator.translate_file(input_file_path, output_file_path, source_language, target_language)

import requests
import random
import os
from concurrent.futures import ThreadPoolExecutor, as_completed
import scipdf
import string
from datetime import datetime

# 自定义异常，用于处理 GROBID 服务的异常情况
class GROBID_OFFLINE_EXCEPTION(Exception):
    pass

class PDFToMarkdown:
    def __init__(self, input_path, grobid_urls=None):
        """
        初始化 PDFToMarkdown 实例。

        Args:
            input_path (str): 要处理的文件或文件夹路径。
            grobid_urls (list): 可选，GROBID 服务器 URLs 列表。默认为预设的 URLs 列表。
        """
        self.input_path = input_path
        # 使用自定义 GROBID 服务器，如果没有则使用默认服务器
        self.grobid_urls = grobid_urls if grobid_urls is not None else [
            "https://qingxu98-grobid.hf.space",
            "https://qingxu98-grobid2.hf.space",
            # ... (其他服务器 URL)
            "https://qingxu98-grobid8.hf.space",
        ]

    def get_avail_grobid_url(self):
        """获取可用的 GROBID 服务器 URL"""
        if not self.grobid_urls:
            return None

        while self.grobid_urls:
            _grobid_url = random.choice(self.grobid_urls)  # 随机选择一个 GROBID URL
            if _grobid_url.endswith('/'):
                _grobid_url = _grobid_url.rstrip('/')
            try:
                # 检查服务器是否在线
                res = requests.get(f"{_grobid_url}/api/isalive", timeout=5)
                if res.text == 'true':
                    return _grobid_url  # 返回可用的 URL
            except (requests.ConnectionError, requests.Timeout):
                # 如果连接错误或超时，从列表中移除此 URL
                self.grobid_urls.remove(_grobid_url)
        return None  # 如果没有可用的服务器，返回 None

    @staticmethod
    def dict_to_markdown(article_json):
        """将文章字典转换为 Markdown 格式字符串"""
        markdown_lines = []
        markdown_lines.append(f"# {article_json.get('title', '无标题')} \n")  # 标题
        markdown_lines.append(f"> doi:{article_json.get('doi', '')} \n")  # DOI
        markdown_lines.append(f"+ authors\n{article_json.get('authors', ['无作者'])}  \n")  # 作者
        markdown_lines.append(f"+ abstract\n{article_json.get('abstract', '无摘要')}  \n")  # 摘要

        # 处理各章节内容
        if 'sections' in article_json:
            for section in article_json['sections']:
                markdown_lines.append(f"+ {section['heading']}\n{section['text']}\n")  # 章节标题与内容

        return "\n".join(markdown_lines)  # 返回合并后的 Markdown 字符串

    @staticmethod
    def save_markdown_file(filename, content):
        """将内容写入到 Markdown 文件"""
        with open(filename, 'w', encoding='utf-8') as f:
            f.write(content)  # 写入内容到文件

    def parse_pdf(self, pdf_path, grobid_url):
        """解析单个 PDF 文件，返回文章字典"""
        if not os.path.isfile(pdf_path):
            raise FileNotFoundError(f"指定路径下没有找到 PDF 文件: {pdf_path}")  # 检查文件是否存在

        if grobid_url.endswith('/'):
            grobid_url = grobid_url.rstrip('/')

        try:
            # 使用 GROBID 解析 PDF
            return scipdf.parse_pdf_to_dict(pdf_path, grobid_url=grobid_url)
        except GROBID_OFFLINE_EXCEPTION:
            raise GROBID_OFFLINE_EXCEPTION("GROBID 服务不可用，检查配置中的 GROBID_URL。")
        except RuntimeError:
            raise RuntimeError("解析 PDF 失败，请检查 PDF 是否损坏。")

    def process_pdf_file(self, pdf_path, grobid_url):
        """处理单个 PDF 文件，返回 Markdown 内容"""
        print(f"正在解析: {pdf_path}")
        try:
            pdf_article_dict = self.parse_pdf(pdf_path, grobid_url)  # 解析 PDF 文件
            return self.dict_to_markdown(pdf_article_dict)  # 转换为 Markdown
        except Exception as e:
            print(f"处理文件 {pdf_path} 时发生错误: {e}")
            return None  # 出现错误时返回 None

    def process(self):
        """处理输入文件或文件夹，并返回生成的 Markdown 文件路径"""
        markdown_contents = []  # 存储所有 Markdown 内容
        grobid_url = self.get_avail_grobid_url()

        if grobid_url is None:
            raise RuntimeError("没有可用的 GROBID 服务，请检查您的服务器配置。")

        # 根据输入路径判断是文件还是文件夹
        if os.path.isfile(self.input_path):
            pdf_files = [self.input_path]  # 单个文件
        elif os.path.isdir(self.input_path):
            # 收集文件夹中的所有 PDF 文件
            pdf_files = [os.path.join(dirpath, filename)
                         for dirpath, _, filenames in os.walk(self.input_path)
                         for filename in filenames if filename.endswith('.pdf')]
        else:
            raise ValueError("输入路径既不是文件也不是文件夹。")

        # 使用线程池并行处理 PDF 文件
        with ThreadPoolExecutor(max_workers=5) as executor:
            future_to_file = {executor.submit(self.process_pdf_file, pdf, grobid_url): pdf for pdf in pdf_files}

            # 收集生成的 Markdown 内容
            for future in as_completed(future_to_file):
                result = future.result()
                if result:
                    markdown_contents.append(result)

        # 如果有有效的 Markdown 内容，将其保存到文件
        if markdown_contents:
            # 生成时间戳
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            # 生成两位随机字母
            random_suffix = ''.join(random.choices(string.ascii_lowercase, k=2))
            output_filename = f"{timestamp}_{random_suffix}.md"
            self.save_markdown_file(output_filename, "\n\n".join(markdown_contents))  # 合并并保存为 Markdown 文件
            print(f"所有 Markdown 文件已合并并保存为 {output_filename}")
            return output_filename  # 返回生成文件路径
        else:
            print("没有有效的 Markdown 内容生成。")
            return None


# 如果直接运行此脚本，提供使用示例
if __name__ == "__main__":
    input_path = 'your_file_or_directory_path'  # 替换为你的文件或目录路径
    custom_grobid_urls = [
        "https://your-custom-grobid-server.com",
        "https://another-custom-grobid-server.com",
    ]
    pdf_to_markdown = PDFToMarkdown(input_path, grobid_urls=custom_grobid_urls)
    output_file = pdf_to_markdown.process()  # 处理 PDF 文件并生成 Markdown 文件
    print("生成的文件路径:", output_file)  # 输出生成的文件路径

import gdal
import os

input_file = "G:/4.其他/wc2.1_30s_bioc_ACCESS-CM2_ssp126_2041-2060.tif"#下载的tif文件
output_folder = "G:/4.其他/feature_bio/"#输出文件夹

if not os.path.exists(output_folder):
   os.makedirs(output_folder)

dataset = gdal.Open(input_file)
num_bands = dataset.RasterCount

for i in range(num_bands):
   band = dataset.GetRasterBand(i + 1)
   output_file = os.path.join(output_folder, f"bio_{i + 1}.tif")
   driver = gdal.GetDriverByName("GTiff")
   new_dataset = driver.Create(output_file, dataset.RasterXSize, dataset.RasterYSize, 1, gdal.GDT_Float32)
   new_dataset.SetProjection(dataset.GetProjection())
   new_dataset.SetGeoTransform(dataset.GetGeoTransform())
   new_dataset.GetRasterBand(1).WriteArray(band.ReadAsArray())
   print(f"Creating {output_file}...")
   new_dataset.FlushCache()
   new_dataset = None

dataset = None

# import osgeo.gdal as a convenience
from osgeo.gdal import deprecation_warn
deprecation_warn('gdal')
from osgeo.gdal import *