QQ邮箱自动清理邮件，注意备份重要信息~



### `cargo.toml`
```toml
[package]
name = "email_helper"
version = "0.1.0"
edition = "2024"

[dependencies]
imap = "2.4"
native-tls = "0.2"
mailparse = "0.14"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
anyhow = "1"
chrono = { version = "0.4", features = ["serde"] }
encoding_rs = "0.8"
```

### `main.rs`
```rust
use std::net::TcpStream;

use anyhow::Result;
use imap::{
    Session,
    types::{Fetch, Flag, ZeroCopy},
};
use mailparse::{MailHeaderMap, parse_mail};
use native_tls::{TlsConnector, TlsStream};

fn main() -> Result<()> {
    let imap_server = "smtp.qq.com";
    let imap_port = 993;
    let username = "xxx";
    let password = "xxx"; // 授权码

    // 创建 TLS 连接
    let tls = TlsConnector::builder().build()?;
    let client = native_tls::TlsConnector::connect(
        &tls,
        imap_server,
        std::net::TcpStream::connect((imap_server, imap_port))?,
    )?;

    // 使用 imap 2.4 登录
    let mut imap_session = imap::Client::new(client)
        .login(username, password)
        .map_err(|e| e.0)?;

    // 选择 INBOX
    let mailbox = imap_session.select("INBOX")?;
    println!("Total messages in INBOX: {}", mailbox.exists);

    let batch_size = 100;
    let mut start = 1;
    let total = mailbox.exists;
    while start <= total {
        let end = std::cmp::min(start + batch_size - 1, total);
        let sequence_set = format!("{}:{}", start, end);
        println!("Fetching emails {}-{}", start, end);

        let messages = imap_session.fetch(&sequence_set, "(UID FLAGS BODY.PEEK[])")?;
        println!("Fetched {} messages", messages.len());
        let result = handle_messages(&messages, &mut imap_session);
        if result.is_err() {
            println!("Error handling messages: {}", result.err().unwrap());
        }
        start += batch_size;
    }

    // 删除标记的邮件
    imap_session.expunge()?;

    imap_session.logout()?;
    println!("Completed");
    Ok(())
}

fn handle_messages(
    messages: &ZeroCopy<Vec<Fetch>>,
    session: &mut Session<TlsStream<TcpStream>>,
) -> Result<()> {
    for msg in messages.iter() {
        let uid = msg.uid;
        if uid.is_none() {
            println!("uid is none");
            continue;
        }
        let uid = uid.unwrap();
        if let Some(body) = msg.body() {
            let parsed = parse_mail(body)?;

            // 邮件头
            let subject = parsed
                .headers
                .get_first_value("Subject")
                .unwrap_or_default();
            let from = parsed.headers.get_first_value("From").unwrap_or_default();
            let seen = msg.flags().iter().any(|f| matches!(f, Flag::Seen));
            if !seen {
                println!("Email '{}' (UID {}) has not been seen", subject, uid);
                continue;
            }
            if from.contains("联想") || subject.contains("校招") || subject.contains("应聘")
                || subject.contains("校园招聘") || from.contains("校园招聘") || from.contains("校招") || from.contains("yunying1@alimail.zhaopin.com") || from.contains("service@steelport.zhaopin.com") || from.contains("RMASERVER@msi.com") || from.contains("billing@microsoft.com") || from.contains("noreply@steampowered.com") || from.contains("MicrosoftOffice365@email.office.com") || subject.contains("投递进度") || from.contains("no-reply@gitmail.oschina.net") || from.contains("imooc@dm.mukewang.com")
                || subject.contains("漫画更新")
                || subject.contains("ACM TechNews")
                || subject.contains("简单百宝箱")
                || subject.contains("启动完成")
                || (subject.contains("提醒") && from.contains("1055894396@qq.com"))
                || subject.contains("This is jumpserver.")
                || subject.contains("对您很感兴趣，邀您沟通")
                // 阿里云
                || from.contains("aliyun.com")
                // GitHub
                || from.contains("notifications@github.com")
                || subject.contains("[GitHub]")
                // other
                || from.contains("acmhelp@acm.org")
                || from.contains("no-reply@unity3d.com")
                || subject.contains("验证码") || subject.contains("Verification Code") || subject.contains("统一身份认证平台通知") || subject.contains("激活码") || subject.contains("email verification code") || subject.contains("用户注册确认") || subject.contains("Verify your email address")
                || from.contains("support@codepen.io") || from.contains("noreply@topcoder.com") || from.contains("music@tencent.com") || from.contains("cloud_noreply@tencent.com")
                || from.contains("ccfdigital@ccfservice.cn")
                || from.contains("csdn.net")
                || from.contains("51job.com")
                || from.contains("noreply@icloud.com.cn")
                || from.contains("no-reply@email.leetcode.cn") || from.contains("no-reply@email.leetcode-cn.com") || from.contains("no-reply@leetcode.com")
                || from.contains("admin@qq.com") || from.contains("10000@qq.com")
                || from.contains("topcoder.com")
                || subject.contains("安全提醒")
                || from.contains("support@codepen.io")
                || from.contains("huawei_ebg@research-satisfaction.com")
                || from.contains("contact@gitpod.io")
                || from.contains("no_reply@email.apple.com") || from.contains("shipping_notification@orders.apple.com") || from.contains("MarketResearch@insideapple.apple.com>") || from.contains("contact@scenario.com") || from.contains("no-reply@email.apple.com") || from.contains("do_not_reply@apple.com") || from.contains("OnlineResearch@insideapple.apple.com")
                || from.contains("info@service.yuque.com")
                || from.contains("noreply@shmail.ibeisen.com")
                || from.contains("noreply@blizzardgames.cn")
                || from.contains("updates-noreply@linkedin.com")
                || from.contains("no-reply@notify.docker.com")
                || from.contains("maya@meilisearch.com")
                || from.contains("notifications@gitbook.com")
                || from.contains("noreply@wakatime.com")
                || from.contains("hello@promos.memrise.com") || from.contains("elasticon@elastic.co") || from.contains("replies@oracle-mail.com") || from.contains("jobs-listings@linkedin.com") || from.contains("support@gitguardian.com") || from.contains("e@notification.coding.net") || from.contains("membership@ccf.org.cn") || from.contains("developer@photonengine.com") || from.contains("film@tencent.com") || from.contains("welcome@openrouter.ai")
            {
                // 标记删除
                let uid = msg.uid.ok_or("无法获取 UID").unwrap();
                session.uid_store(uid.to_string(), "+FLAGS (\\Deleted)")?;
                session.expunge()?;
                println!("Marked email '{}' (UID {}) for deletion", subject, uid);
            }
        }
    }
    Ok(())
}

```

邮件清理

在很多实际应用场景中，我们无法依赖网络请求（如高德、百度地图 API），例如：
- 内网系统
- 数据安全要求高的环境
- 移动端离线应用
- 批量处理大量地理数据

这时，**离线地理编码（Offline Geocoding）** 就成为必要选择。本文将介绍如何使用 GeoJSON + Shapely 在 Python 中实现 **经纬度 ↔ 地区名称** 的双向转换，并支持计算两地距离。



## 核心思路
- 数据源：使用包含中国行政区划边界的 GeoJSON 文件（如省、市、区县）
- 空间判断：利用 shapely 判断点是否在多边形内（反向编码）
- 几何中心：取行政区多边形的质心作为代表经纬度（正向编码）
- 距离计算：采用 Haversine 公式计算球面距离

## 所需依赖
```python
pip install shapely
```

## 数据准备
以下 `GeoJSON` 文件（可从[阿里云 DataV 地理工具](https://datav.aliyun.com/portal/school/atlas/area_selector?spm=a2ty_o01.29997173.0.0.691f51719yR1dE)下载）：
- `geo_province.json`：省级边界
- `geo_city.json`：市级边界
- `geo_china.json`：区县级边界（全国）

## 核心代码
```python
import json
import math
from shapely.geometry import Point, shape

class OfflineGeocoder:
    def __init__(self, geojson_paths):
        self.features = []
        self.code2name = {}
        for geojson_path in geojson_paths:
            with open(geojson_path, 'r', encoding='utf-8') as f:
                geojson_data = json.load(f)
                self.features.extend(geojson_data['features'])
                for feature in geojson_data['features']:
                    self.code2name[feature['properties']['adcode']] = feature['properties']['name']

        self.name_index = {}
        for feat in self.features:
            props = feat['properties']
            key = f"{props.get('name', '')}"
            self.name_index[key] = feat

    def position2region(self, lat, lon):
        """经纬度 → 地区"""
        point = Point(lon, lat)
        features = []
        for feat in self.features:
            if shape(feat['geometry']).contains(point):
                features.append(feat)
        ans = ""
        for feat in features:
            props = feat['properties']
            temp = ""
            for code in props.get('acroutes', []):
                temp += f"{self.code2name.get(code, '')}-"
            temp += f"{props.get('name', '')}"
            if len(temp) > len(ans):
                ans = temp
        return ans

    def region2position(self, full_name):
        """地区 → 经纬度（质心）"""
        feat = self.name_index.get(full_name)
        if not feat:
            return None
        centroid = shape(feat['geometry']).centroid
        return {'lat': centroid.y, 'lon': centroid.x}

    def distance_of_regions(self, region1, region2):
        """
        地区 → 距离（千米），保留 2 位小数
        """
        pos1 = self.region2position(region1)
        pos2 = self.region2position(region2)
        if not pos1 or not pos2:
            return None
        dis = self.distance_of_position(pos1['lat'], pos1['lon'], pos2['lat'], pos2['lon']) / 1000
        return f"{dis:.2f} km"

    def distance_of_position(self, lat1, lon1, lat2, lon2):
        """经纬度 → 距离（米）"""

        # 将度转换为弧度
        lat1_rad = math.radians(lat1)
        lon1_rad = math.radians(lon1)
        lat2_rad = math.radians(lat2)
        lon2_rad = math.radians(lon2)

        # 地球半径（米）
        R = 6371000

        # Haversine公式计算两点间距离
        dlat = lat2_rad - lat1_rad
        dlon = lon2_rad - lon1_rad

        a = math.sin(dlat/2)**2 + math.cos(lat1_rad) * math.cos(lat2_rad) * math.sin(dlon/2)**2
        c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))

        distance = R * c
        return distance

Geo = OfflineGeocoder(["geo_china.json", "geo_province.json", "geo_city.json"])
```

测试

```python
from geo_helper import Geo

# 位置转地区
print(Geo.position2region(39.9087, 116.4729))

# 地区转位置
print(Geo.region2position("银川市"))

# 地区距离
print(Geo.distance_of_regions("银川市", "北京市"))
```

### ⚠️ 注意事项
- 地区重名问题：当前实现以“地区名”为 key，若存在重名（如多个“朝阳区”），会覆盖。生产环境建议使用 adcode 或完整路径作为 key。
- 性能优化：若需高频查询，可对多边形建立 R-tree 空间索引（使用 rtree 库）。
- 数据：可以自定义区域，新增对应的 json 文件即可。

离线环境下实现经纬度与地区名称双向转换

服务有的时候内存会升高，加个日志~



1. 先写个记录日志的脚本

```shell
#!/bin/bash

# 监控 systemctl status x 的脚本
# 作者: Assistant
# 日期: 2024

# 配置变量
SERVICE_NAME="x"
LOG_FILE="/var/log/x_status.log"
MAX_LOG_SIZE=100  # 最大日志文件大小（MB），超过则轮转

# 获取当前时间戳
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')

# 检查 systemctl 命令是否存在
if ! command -v systemctl &> /dev/null; then
    echo "[$TIMESTAMP] ERROR: systemctl command not found" >> "$LOG_FILE"
    exit 1
fi

# 检查服务是否存在
if ! systemctl list-units --full --all | grep -q "^${SERVICE_NAME}\."; then
    echo "[$TIMESTAMP] ERROR: Service '$SERVICE_NAME' not found" >> "$LOG_FILE"
    exit 1
fi

# 获取服务状态信息
STATUS_OUTPUT=$(systemctl status "$SERVICE_NAME" 2>&1)

# 写入日志文件
{
    echo "=== Status check at $TIMESTAMP ==="
    echo "$STATUS_OUTPUT"
    echo "=================================="
    echo ""
} >> "$LOG_FILE"

# 日志轮转功能（可选）
if [ -f "$LOG_FILE" ]; then
    # 获取当前日志文件大小（MB）
    CURRENT_SIZE=$(du -m "$LOG_FILE" 2>/dev/null | cut -f1)
    
    # 如果日志文件超过最大大小，进行轮转
    if [ "$CURRENT_SIZE" -gt "$MAX_LOG_SIZE" ]; then
        mv "$LOG_FILE" "${LOG_FILE}.old"
        echo "[$TIMESTAMP] Log file rotated due to size limit" >> "$LOG_FILE"
    fi
fi

echo "[$TIMESTAMP] Status check completed successfully"
```

2. 创建服务文件 `/etc/systemd/system/x-monitor.service`
```
[Unit]
Description=Monitor X service status
After=network.target

[Service]
Type=oneshot
ExecStart=/usr/local/bin/monitor_x_status.sh
User=root
```

3. 创建定时器文件 `/etc/systemd/system/x-monitor.timer`
```
[Unit]
Description=Run X service monitor every minute
Requires=x-monitor.service

[Timer]
OnCalendar=*:*:00
Persistent=true

[Install]
WantedBy=timers.target
```

4. 启用并启动定时器
```
# 重新加载 systemd 配置
sudo systemctl daemon-reload

# 启用并启动定时器
sudo systemctl enable --now x-monitor.timer

# 查看定时器状态
sudo systemctl status x-monitor.timer
```

5. 停止监控
```
systemctl disable --now x-monitor.timer
```

linux 系统监控

快速部署模型~




## 下载模型

`pip install -U huggingface_hub -i https://pypi.tuna.tsinghua.edu.cn/simple`

~~注册 `huggingface`，获得 Token~~

~~`huggingface-cli login`，使用 Token 登录~~

切换源：`export HF_ENDPOINT=https://hf-mirror.com`

`huggingface-cli download bartowski/Llama-3.2-1B-Instruct-GGUF Llama-3.2-1B-Instruct-Q4_K_M.gguf --local-dir ./models`

## 安装 shimmy
安装 rust
```shell
# 安装依赖
sudo apt install curl build-essential gcc
# 使用脚本下载并安装
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```

安装 cmake
```shell
sudo apt update
sudo apt install cmake
```

安装使用 shimmy
```shell
cargo install shimmy --features huggingface
shimmy serve --bind 0.0.0.0:11435 &
```

注：使用的目录
> Hugging Face cache: ~/.cache/huggingface/hub/
> 
> Ollama models: ~/.ollama/models/
> 
> Local directory: ./models/
> 
> Environment: SHIMMY_BASE_GGUF=path/to/model.gguf