shancx 1.8.92__py3-none-any.whl → 1.9.33.218__py3-none-any.whl

shancx/RdPzl/__init__.py

@@ -0,0 +1,32 @@
+ 
+
+def start_points(size, split_size, overlap=0.0): 
+    stride = int(split_size * (1 - overlap))  # 计算步长
+    points = [i * stride for i in range((size - split_size) // stride + 1)]   
+    if size > points[-1] + split_size:   
+        points.append(size - split_size)
+    return points
+
+"""
+    b = np.zeros(sat_data[0].shape)
+    x_point = start_points(sat_data[0].shape[0], 256, 0.14)
+    y_point = start_points(sat_data[0].shape[1], 256, 0.14)
+    overlap1 = 17
+    for x in x_point:
+        for y in y_point:
+            cliped = sat_data[:, x:x + 256, y:y + 256]
+            img1 = cliped[np.newaxis].float()
+            img1 = img1.cpu().numpy()
+            img1 = np.where(np.isnan(img1), 0, img1)
+            img2 = img1.reshape(1, 6, 256, 256).astype(np.float32)  # Ensure correct shape and type
+            radarpre = run_onnx_inference(ort_session, img2)
+            radarpre = (radarpre * 72).squeeze()
+            radarpre[radarpre < 13] = 0
+            radarpre = QC_ref(radarpre[None], areaTH=30)[0]
+
+            b[x + overlap1:x + 256, y + overlap1:y + 256] = radarpre[overlap1:, overlap1:]
+
+    return b
+
+"""
+ 

shancx/Read.py

@@ -0,0 +1,72 @@
+import pygrib
+import numpy as np
+import pandas as pd
+def readGrib(file_path, target_param=None):
+    try:
+        with pygrib.open(file_path) as grbs:
+            field_info = []
+            for grb in grbs:
+                field_info.append({
+                                   'messageNumber': grb.messagenumber,
+                                   'parameterName': getattr(grb, 'parameterName', 'N/A'),
+                                   'shortName': getattr(grb, 'shortName', 'N/A'),
+                                   'level': getattr(grb, 'level', -999),
+                                   'typeOfLevel': getattr(grb, 'typeOfLevel', 'N/A'),
+                                   'validDate': getattr(grb, 'validDate', 'N/A'),
+                                   'units': getattr(grb, 'units', 'N/A'),
+                                   'shape': grb.values.shape
+                                 })             
+            if target_param:
+                try:
+                    grb = grbs.select(shortName=target_param)[0]
+                except:
+                    try:
+                        grb = grbs.select(parameterName=target_param)[0]
+                    except:
+                        raise ValueError(f"未找到参数: {target_param}")
+            else:
+                grb = grbs[1]
+            data = grb.values
+            lats, lons = grb.latlons()            
+            return {
+                'data': data,
+                'lats': lats,
+                'lons': lons,
+                'metadata': {
+                    'parameterName': grb.parameterName,
+                    'level': grb.level,
+                    'validDate': grb.validDate,
+                    'units': grb.units
+                }
+            }            
+    except Exception as e:
+        print(f"GRIB读取错误: {str(e)}")
+        return None
+if __name__ == "__main__":
+    path = "/mnt/wtx_weather_forecast/CMA_DATA/NAFP/EC/C1D/2024/2024112720/ECMFC1D_PRTY_1_2024112712_GLB_1_2.grib2"
+    result = readGrib(path)    
+    if result:
+        print("\n数据矩阵形状:", result['data'].shape)
+        print("经度范围:", np.min(result['lons']), "~", np.max(result['lons']))
+        print("纬度范围:", np.min(result['lats']), "~", np.max(result['lats']))
+        print("参数单位:", result['metadata']['units'])
+        """
+        latArr = latMat[:,0]
+        lonArr = lonMat[0]
+        """    
+
+import numpy as np
+from pathlib import Path
+def npsavez(output, data):
+    output = output.replace('.npy', '.npz')
+    output_path = Path(output).with_suffix('.npz')
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    np.savez_compressed(output_path, data=data)
+    print(f"{output_path} done")
+def nploadz(output_path):
+    return np.load(Path(output_path).with_suffix('.npz'))['data']
+
+"""
+savez(output, data)
+nploadz(output_path)
+"""

shancx/Resize.py

@@ -0,0 +1,79 @@
+import numpy as np
+import random
+# import albumentations as A
+# import cv2
+
+# def resize_array(array, size):
+#     # 定义变换管道
+#     transform = A.Compose([
+#         A.SmallestMaxSize(max_size=size, interpolation=cv2.INTER_AREA)
+#     ])
+#     transformed_array = transform(image=array)["image"]
+#     return transformed_array
+
+def crop_array(array, crop_side_len):
+    cropper = A.RandomCrop(height=crop_side_len, width=crop_side_len)
+    cropped_array = cropper(image=array)["image"]
+    return cropped_array
+
+def crop_cna_pair(min_side_len, low_res_data, high_res_data):
+    crop_side_len = min_side_len
+    top = random.randint(0, low_res_data.shape[-2] - crop_side_len)
+    left = random.randint(0, low_res_data.shape[-1] - crop_side_len)
+    super_factor = high_res_data.shape[-2] / low_res_data.shape[-2] # Assuming the ratio in height dimensio
+    cropped_low_res = low_res_data[top:top + crop_side_len, left:left + crop_side_len]
+    cropped_high_res = high_res_data[int(top * super_factor):int((top + crop_side_len) * super_factor),
+                                     int(left * super_factor):int((left + crop_side_len) * super_factor)]
+    return cropped_low_res, cropped_high_res
+def random_crop_pair(min_side_len, low_res_data, high_res_data):
+    crop_side_len = min_side_len
+    top = random.randint(0, low_res_data.shape[-2] - crop_side_len)
+    left = random.randint(0, low_res_data.shape[-1] - crop_side_len)
+    super_factor = high_res_data.shape[-2] / low_res_data.shape[-2] # Assuming the ratio in height dimension
+    cropped_low_res = low_res_data[top:top + crop_side_len, left:left + crop_side_len]
+    cropped_high_res = high_res_data[int(top * super_factor):int((top + crop_side_len) * super_factor),
+                                     int(left * super_factor):int((left + crop_side_len) * super_factor)]
+    return cropped_low_res, cropped_high_res
+
+import random
+
+def random_crop_triplet(min_side_len, low_res_data, high_res_data1, high_res_data2):
+    top = random.randint(0, low_res_data.shape[-2] - min_side_len)
+    left = random.randint(0, low_res_data.shape[-1] - min_side_len)
+    cropped_low_res = low_res_data[..., top:top + min_side_len, left:left + min_side_len]
+    factor1_h = high_res_data1.shape[-2] / low_res_data.shape[-2]
+    factor1_w = high_res_data1.shape[-1] / low_res_data.shape[-1]
+    cropped_high_res1 = high_res_data1[...,
+                                       int(top * factor1_h):int((top + min_side_len) * factor1_h),
+                                       int(left * factor1_w):int((left + min_side_len) * factor1_w)]
+    factor2_h = high_res_data2.shape[-2] / low_res_data.shape[-2]
+    factor2_w = high_res_data2.shape[-1] / low_res_data.shape[-1]
+    cropped_high_res2 = high_res_data2[...,
+                                       int(top * factor2_h):int((top + min_side_len) * factor2_h),
+                                       int(left * factor2_w):int((left + min_side_len) * factor2_w)]
+    return cropped_low_res, cropped_high_res1, cropped_high_res2
+
+def random_crop_single(cropsize, input_data):
+    # 确定裁剪的边长
+    crop_side_len = cropsize
+
+    # 随机选择左上角裁剪点
+    top = random.randint(0, input_data.shape[0] - crop_side_len)
+    left = random.randint(0, input_data.shape[1] - crop_side_len)
+
+    # 裁剪输入数据
+    cropped_data = input_data[top:top + crop_side_len, left:left + crop_side_len]
+
+    return cropped_data
+
+
+if __name__ == "__main__":
+    low_res_data = np.load("./SAT_202507010900_49.42_117.82_100.npy")
+    high_res_data = np.load("./CR_202507010900_49.42_117.82_100.npy")
+    high_res_data1 = np.load("./mask_202507010900_49.42_117.82_100.npy")
+    d1,d2,d3 =  random_crop_triplet(128, low_res_data, high_res_data[0], high_res_data1[0])
+    transformed_low_res_data = resize_array(low_res_data, 240)
+    transformed_high_res_data = resize_array(high_res_data, 960)
+    np.save("transformed_low_res_data.npy", transformed_low_res_data)
+    np.save("transformed_high_res_data.npy", transformed_high_res_data)
+

shancx/SN/__init__.py

@@ -11,128 +11,67 @@ __author__ = 'shancx'
 __author_email__ = 'shancx@126.com'
 
 
-
-# @Time : 2023/09/27 下午8:52
-# @Author : shanchangxi
-# @File : util_log.py
-import time
-import logging  
-from logging import handlers
-
-def mkDir(path):
-    if "." in path:
-        os.makedirs(os.path.dirname(path),exist_ok=True)
-    else:
-        os.makedirs(path, exist_ok=True)
-
-loggers = logging.getLogger()
-loggers.setLevel(logging.INFO) 
-log_name =  './project_S.log'
-mkDir(log_name)
-logfile = log_name
-time_rotating_file_handler = handlers.TimedRotatingFileHandler(filename=logfile, when='D', encoding='utf-8')
-time_rotating_file_handler.setLevel(logging.INFO)   
-formatter = logging.Formatter("%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s")
-time_rotating_file_handler.setFormatter(formatter)
-loggers.addHandler(time_rotating_file_handler)
-
-
-"""      
-import tracback
-try:
-
-except Exception as e:
-   
-     logger.info(traceback.format_exc())
-"""
-
-
-'''
- ##定義一個streamHandler
-# print_handler = logging.StreamHandler()  
-# print_handler.setFormatter(formatter) 
-# loggers.addHandler(print_handler)
-'''
-
-"""
-from main import makeAll,options
-from multiprocessing import Pool
-import datetime
-from config import logger,output
-import time
-import pandas as pd
+import json
 import os
-from itertools import product
-import threading
-
-def excuteCommand(cmd):
-    print(cmd)
-    os.system(cmd)
-
-def gpuPro(makeListUTC, isPhase, isDebug, gpu, isOverwrite):
-    productList = product(makeListUTC, [isPhase], [isDebug], [gpu], [isOverwrite])
-
-    with Pool(4) as p:
-        p.map(makeAll, productList)
-
-if __name__ == '__main__':
-    cfg = options()
-    isPhase = cfg.isPhase
-    isDebug = cfg.isDebug
-    sepSec = cfg.sepSec
-    gpu = cfg.gpu
-    pool = cfg.pool
-    isOverwrite = cfg.isOverwrite
-    timeList = pd.date_range(cfg.times[0], cfg.times[-1], freq=f"{sepSec}s")
-    logger.info(f"时间段check {timeList}")
-    gpuNum = 2
-    eachGPU = 4
-
-    makeListUTC = []
-    for UTC in timeList:
-        UTCStr = UTC.strftime("%Y%m%d%H%M")
-        outpath = f"{output}/{UTCStr[:4]}/{UTCStr[:8]}/MSP2_WTX_AIW_QPF_L88_CHN_{UTCStr}_00000-00300-00006.nc"
-        if not os.path.exists(outpath) or isOverwrite:
-            makeListUTC.append(UTC)
-    [print(element) for element in makeListUTC]
-
-    phaseCMD = "--isPhase" if isPhase else ""
-    debugCMD = "--isDebug" if isDebug else ""
-    OverwriteCMD = "--isOverwrite"  
-    gpuCMD = f"--gpu={gpu}"
-    # cmdList = list(map(lambda x:f"python main.py --times={x.strftime('%Y%m%d%H%M')} {phaseCMD} {debugCMD} {OverwriteCMD} {gpuCMD}",makeListUTC))
-    cmdList = list(map(lambda x:f"python main.py --times={x.strftime('%Y%m%d%H%M')} {phaseCMD} {debugCMD} {gpuCMD}",makeListUTC))
-
-    with Pool(pool) as p:
-        p.map(excuteCommand, cmdList)
+from cryptography.fernet import Fernet, InvalidToken
+from shancx import crDir
+class UserManager:
+    def __init__(self, storage_file=None, info=None):
+        self.storage_file = storage_file
+        self.usersdata = info
+        self.data = self._load_or_initialize_data()
+        self.cipher = Fernet(self.data["key"])
+
+    def _load_or_initialize_data(self):
+        if self.storage_file and os.path.exists(self.storage_file) and os.path.getsize(self.storage_file) > 0:
+            with open(self.storage_file, "r") as file:
+                try:
+                    data = json.load(file)
+                    if "key" in data and "users" in data:
+                        return data
+                except json.JSONDecodeError:
+                    print("错误: 数据文件损坏，请删除文件并重新运行。")
+        key = Fernet.generate_key().decode("utf-8")
+        return {"key": key, "users": {}} if self.usersdata is None else self.usersdata
+    def _save_data(self):
+        if self.storage_file:
+            crDir(self.storage_file)
+            with open(self.storage_file, "w") as file:
+                json.dump(self.data, file, indent=4)
+
+    def add_user(self, user_id, secret_value):
+        encrypted_secret = self.cipher.encrypt(secret_value.encode("utf-8")).decode("utf-8")
+        self.data["users"][user_id] = {"s": encrypted_secret}
+        self._save_data()
+        print(f"用户 {user_id} 的秘钥已成功保存。")
+
+    def get_user(self, user_id):
+        user_data = self.data["users"].get(user_id)
+        if user_data:
+            try:
+                decrypted_secret = self.cipher.decrypt(user_data["s"].encode("utf-8")).decode("utf-8")
+                return json.loads(decrypted_secret)
+            except InvalidToken:
+                print("错误: 秘钥解密失败。")
+        else:
+            print(f"未找到用户 {user_id} 的数据。")
+        return None 
+import requests
+def sendMESplus(message,base = None):
+    webHookUrl = f'{base[1]}{base[0]}'  
+    response=None
+    try:
+        url=webHookUrl
+        headers = {"Content-Type":"application/json"}
+        data = {'msgtype':'text','text':{"content":message}}
+        res = requests.post(url,json=data,headers=headers)
+    except Exception as e:
+        print(e)
 """
-
-
-'''
-# @Time : 2023/09/27 下午8:52
-# @Author : shanchangxi
-# @File : util_log.py
-import time
-import logging  
-from logging import handlers
- 
-logger = logging.getLogger()
-logger.setLevel(logging.INFO) 
-log_name =  'project_tim_tor.log'
-logfile = log_name
-time_rotating_file_handler = handlers.TimedRotatingFileHandler(filename=logfile, when='D', encoding='utf-8')
-time_rotating_file_handler.setLevel(logging.INFO)   
-formatter = logging.Formatter("%(asctime)s - %(filename)s[line:%(lineno)d] - %(levelname)s: %(message)s")
-time_rotating_file_handler.setFormatter(formatter)
-logger.addHandler(time_rotating_file_handler)
-print_handler = logging.StreamHandler()   
-print_handler.setFormatter(formatter)   
-logger.addHandler(print_handler)
-
-'''
-
-'''
-###解决方法  pip install torch==2.4.0  torchvision    torchaudio三个同时安装  python 3.12  解决cuda启动不了的问题
-
-Res网络
-'''
+    import torch.nn as nn
+    # gpu_ids = [3, 4, 5]
+    device = torch.device(f"cuda:{gpu_ids[0]}" if torch.cuda.is_available() else "cpu")
+    model = get_model(model_name, in_channels=in_channels).to(device)
+    if len(gpu_ids) > 1:
+        model = torch.nn.DataParallel(model, device_ids=gpu_ids)  
+"""

shancx/Time/GetTime.py

@@ -27,6 +27,12 @@ def Datetime2str(datetime_):
     return formatted_time
 
 from dateutil.relativedelta import relativedelta
-def Relativedelta(T_,Th = 0,Tm=0):
- mktime = T_+relativedelta(hours=Th,minutes=Tm)
- return mktime
+def relativeDelta(UTC,H = 8,M=0):
+    mktime = UTC + relativedelta(hours=H,minutes=M)
+    return mktime
+
+def get30m(UTC):
+    for m in range(6):
+        T = 30
+        UTCStr = (UTC+relativedelta(minutes=(-m)*T-UTC.minute%T)).strftime("%Y%m%d%H%M")
+        return UTCStr

shancx/Time/__init__.py

@@ -22,7 +22,7 @@ def UTCStr():
     now_utcstr = now_utc.strftime('%Y%m%d%H%M%S')
     return now_utcstr
 
-def UTCStr():    
+def CSTStr():    
     now_cst = datetime.datetime.now() 
     now_cststr = now_cst.strftime('%Y%m%d%H%M%S')
     return now_cststr
@@ -45,5 +45,70 @@ def Relativedelta(T_,Th = 0,Tm=0):
  mktime = T_+relativedelta(hours=Th,minutes=Tm)
  return mktime
 
+def nearest_hour():
+    now = datetime.datetime.now()
+    # 计算当前小时整点时间
+    minute = now.minute
+    second = now.second
+    # 如果分钟数大于等于30分钟，则向上取整
+    if minute >= 57:
+        next_hour = now + datetime.timedelta(hours=1)
+        nearest_hour = next_hour.replace(minute=0, second=0, microsecond=0)
+    elif minute <= 3:
+        nearest_hour = now.replace(minute=0, second=0, microsecond=0)
+    else:
+        nearest_hour = now
+    return nearest_hour.strftime("%Y%m%d%H%M")
+
+import pandas as pd
+def gtr(sUTC,eUTC, freq='6min'):
+    minute = sUTC.minute
+    if minute in [15, 45]:
+        start_time = sUTC + relativedelta(minutes=3)  # 15 或 45 分钟时，起始点加 3 分钟
+    elif minute in [0, 30]:
+        start_time = sUTC + relativedelta(minutes=6)  # 0 或 30 分钟时，起始点加 6 分钟
+    else:
+        raise ValueError("sUTC 的分钟数必须是 0、15、30 或 45 分钟")
+    new_times = pd.date_range(start_time, eUTC, freq=freq)
+    return new_times 
+
+def gtr10min(sUTC,eUTC, freq='6min'):
+    minute = sUTC.minute
+    if minute in [10,40]:
+        start_time = sUTC + relativedelta(minutes=2)  # 15 或 45 分钟时，起始点加 2 分钟
+    elif minute in [20, 50]:
+        start_time = sUTC + relativedelta(minutes=4)  # 0 或 30 分钟时，起始点加 4 分钟
+    elif minute in [0, 30]:
+        start_time = sUTC + relativedelta(minutes=6)   # 0 或 30 分钟时，起始点加 4 分钟
+    else:
+        raise ValueError("sUTC 的分钟数必须是 0、10、20、30 或40、50 分钟")
+    new_times = pd.date_range(start_time, eUTC, freq=freq)
+    return new_times 
+
+import datetime as dt
+import pandas as pd
+def ldom(d):  # last day of month
+    if d.month == 12:
+        return d.replace(year=d.year+1, month=1, day=1) - dt.timedelta(days=1)
+    return d.replace(month=d.month+1, day=1) - dt.timedelta(days=1)
+def gen_dt(s, e, t="trn"):  # generate dates
+    dr = pd.date_range(start=s, end=e, freq='1h')
+    res = []    
+    for d in dr:
+        me = ldom(d)
+        is_me = d.day >= (me.day - 1)        
+        if (t == "trn" and not is_me) or (t == "val" and is_me):
+            res.append(d.strftime('%Y%m%d%H%M'))    
+    return res
+"""
+if __name__ == "__main__":
+    s = dt.datetime(2023, 1, 28)
+    e = dt.datetime(2023, 2, 3)    
+    print("Train dt (excl month end):")
+    print(gen_dt(s, e, "trn"))    
+    print("\nValid dt (only month end):")
+    print(gen_dt(s, e, "val"))
+"""
+