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

shancx/wtx/hjnMiscellaneous.py

@@ -1,201 +0,0 @@
-import numpy as np
-import os
-import datetime
-import argparse
-from hjnwtx.mkNCHJN import LeftTopCornerPairArr
-import time
-from dateutil.relativedelta import relativedelta
-import hashlib
-
-def degMinSectoDeg(a):
-    deg = int(a.split("°")[0])
-    sec = int(a.split("'")[-1][:-1])
-    min = int(a.replace(f"{deg}°","").replace(f"'{sec}\"",""))
-    return deg+min/60+sec/3600
-
-def normal(data, min=None, max=None):
-    if max is None:
-        max = np.max(data)
-    if min is None:
-        min = np.min(data)
-    rangeLat = max-min
-    dataB = (data - min) / rangeLat
-    return dataB
-
-def mkDir(path):
-    if "." in path:
-        os.makedirs(os.path.dirname(path),exist_ok=True)
-    else:
-        os.makedirs(path, exist_ok=True)
-
-def options():
-    parser = argparse.ArgumentParser(description='hjn')
-    parser.add_argument('--times', type=str, default='2018060700,2018060700')
-    parser.add_argument('--isDebug',action='store_true',default=False)
-    config= parser.parse_args()
-    config.times = config.times.split(",")
-    if len(config.times) == 1:
-        config.times = [config.times[0], config.times[0]]
-    config.times = [datetime.datetime.strptime(config.times[0], "%Y%m%d%H%M"),
-                    datetime.datetime.strptime(config.times[1], "%Y%m%d%H%M")]
-
-    return config
-
-
-def totalTimes(delta,second):
-    return (delta.days*24*3600+delta.seconds)//second
-
-def timeSeq(start,end,secInter,endPoint=True):
-    times=totalTimes((end-start),secInter)
-    end = 1 if endPoint else 0
-    return list(map(lambda x:start+relativedelta(seconds=x*secInter),range(times+end)))
-
-def normalNC(data):
-    mx=np.nanmax(data)
-    mn = np.nanmin(data)
-    rangeV=mx-mn
-    scale = rangeV/254
-    offset = (mx+mn)/2
-    data1=(data - offset)/scale
-    data1[np.isnan(data1)] = -128
-    return data1,scale,offset
-
-
-def expend(data,latArr,lonArr,dim=2):
-    latOffset = int((LeftTopCornerPairArr[0]["evn"].n - latArr[0]) / 0.01)
-    latOffsetDown = int((latArr[-1] - LeftTopCornerPairArr[3]["evn"].s) / 0.01)
-    lonOffset = int((lonArr[0] - LeftTopCornerPairArr[6]["evn"].w) / 0.01)
-    lonOffsetRight = int((LeftTopCornerPairArr[0]["evn"].e - lonArr[-1]) / 0.01)
-    appendLat = np.asarray(list(map(lambda x: latArr[0] + x * 0.01, range(1, latOffset + 2)))[::-1])
-    appendLatDown = np.asarray(list(map(lambda x: latArr[-1] - x * 0.01, range(1, latOffsetDown + 2))))
-    latArr = np.r_[appendLat, latArr]
-    latArr = np.r_[latArr, appendLatDown]
-    appendLon = np.asarray(list(map(lambda x: lonArr[0] - x * 0.01, range(1, lonOffset + 2)))[::-1])
-    appendLonRight = np.asarray(list(map(lambda x: lonArr[-1] + x * 0.01, range(1, lonOffsetRight + 2))))
-    lonArr = np.r_[appendLon, lonArr]
-    lonArr = np.r_[lonArr, appendLonRight]
-
-    if latOffset<0:
-        latOffset=0
-    if latOffsetDown < 0:
-        latOffsetDown = 0
-    if lonOffset < 0:
-        lonOffset = 0
-    if lonOffsetRight < 0:
-        lonOffsetRight = 0
-
-    if dim==2:
-        data = np.pad(data, ((latOffset+1 , latOffsetDown+1 ), (lonOffset+1 , lonOffsetRight+1)),constant_values=np.nan)
-    elif dim==3:
-        data = np.pad(data, ((0, 0), (latOffset+1, latOffsetDown+1), (lonOffset+1, lonOffsetRight+1)), constant_values=np.nan)
-    elif dim==4:
-        data = np.pad(data, ((0, 0),(0, 0), (latOffset+1, latOffsetDown+1), (lonOffset+1, lonOffsetRight+1)), constant_values=np.nan)
-    return data,latArr,lonArr
-
-def UV2WSWD(U,V):
-    ws = np.sqrt(np.square(U) + np.square(V))
-    wd = (np.degrees(np.arctan2(-U, -V))+ 360)%360
-    return ws,wd
-
-def WSWD2UV(ws,wd):
-    u=- ws*np.sin(np.radians(wd))
-    v=- ws*np.cos(np.radians(wd))
-    return u,v
-
-def findAllIPV4(segment="10."):
-    import psutil
-    from socket import AddressFamily
-    local_addrs = ""
-    for name, info in psutil.net_if_addrs().items():
-        for addr in info:
-            if AddressFamily.AF_INET == addr.family:
-                if segment in addr.address:
-                    local_addrs = addr.address
-    return local_addrs
-
-def sendEmail(message,subject = "fail"):
-    import requests
-    IP = findAllIPV4()
-    response = None
-    try:
-        response = requests.get("http://10.16.50.218:5004/sendmail?address=408037825@qq.com&subject=%s:%s&message=%s"%(subject,IP,message))
-    except Exception as e:
-        print(e)
-    return response
-
-def seconds2datetime(seconds):
-    return datetime.datetime.strptime(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(seconds)), "%Y-%m-%d %H:%M:%S")
-
-def datetime2seconds(UTC):
-    return time.mktime(UTC.timetuple())
-
-def readJulianDateTime(juliandata, hms):
-    jd = juliandata + 2440587
-    L = jd + 68569
-    N = (4 * L) // 146097
-    L = L - (146097 * N + 3) // 4
-    I = 4000 * (L + 1) // 1461001
-    L = L - (1461 * I) // 4 + 31
-    J = 80 * L // 2447
-    day = L - 2447 * J // 80
-    L = int(J // 11)
-    month = J + 2 - 12 * L
-    year = 100 * (N - 49) + I + L
-    seconds = hms // 1000
-    h = seconds // 3600
-    m = (seconds - h * 3600) // 60
-    s = seconds - (60 * h + m) * 60
-    return datetime.datetime(year, month, day, h, m, s)
-
-def RGB_to_Hex(tmp):
-    rgb = tmp.split(',')  # 将RGB格式划分开来
-    strs = '#'
-    for i in rgb:
-        num = int(i)  # 将str转int
-        # 将R、G、B分别转化为16进制拼接转换并大写
-        strs += str(hex(num))[-2:].replace('x', '0').upper()
-
-    return strs
-
-def genLatLon(evn,resolution,isEndPoint=True):
-    if isEndPoint:
-        latArr = np.linspace(evn.n,evn.s,int(((evn.n-evn.s)/resolution+1)))
-        lonArr = np.linspace(evn.w,evn.e,int(((evn.e-evn.w)/resolution+1)))
-    else:
-        evn.s+=resolution
-        evn.e -= resolution
-        latArr = np.linspace(evn.n, evn.s, int(((evn.n - evn.s) / resolution + 1)))
-        lonArr = np.linspace(evn.w, evn.e, int(((evn.e - evn.w) / resolution + 1)))
-    return latArr,lonArr
-
-
-def calSHA1(path):
-    encrypt = hashlib.sha1()
-    with open(path,"rb") as f:
-        while True:
-            b = f.read(128000)
-            encrypt.update(b)
-            if not b:
-                break
-    sha1Result = encrypt.hexdigest()
-    return sha1Result
-
-def wait(path,sepSec,timeoutSec,debug=True):
-    t0 = datetime.datetime.now()
-    t1 = datetime.datetime.now()
-    flag= True
-    while not os.path.exists(path) and flag:
-        if (t1-t0).total_seconds()>timeoutSec:
-            flag =False
-            break
-        else:
-            if debug:
-                print(f"{path} missing wait for {sepSec}s")
-            time.sleep(sepSec)
-            t1 = datetime.datetime.now()
-
-    if not flag:
-        return False
-    else:
-        return True
-

shancx/wtx/hjnProj.py

@@ -1,161 +0,0 @@
-import numpy as np
-import warnings
-
-class FY4Proj():
-    def __init__(self,lonD=104.7,resolution=4000):
-
-        self.ea=6378.137
-        self.eb=6356.7523
-        self.h=42164
-        self.lambdaD=np.radians(lonD)        
-
-        OFF={500:10991.5,1000:5495.5,2000:2747.5,4000:1373.5}
-        FAC={500:81865099,1000:40932549,2000:20466274,4000:10233137}       
-        
-        self.COFF=OFF[resolution]
-        self.LOFF=OFF[resolution]
-        self.CFAC=FAC[resolution]
-        self.LFAC=FAC[resolution]
-
-    def transform(self,latD,lonDe):
-        lat=np.radians(latD)
-        lon=np.radians(lonDe)
-        ba2=np.square(self.eb/self.ea)
-        phie=np.arctan(ba2*np.tan(lat))
-        diffLon0=lon-self.lambdaD
-        re=self.eb/np.sqrt(1-(1-ba2)*np.square(np.cos(phie)))
-
-        r1=self.h-re*np.cos(phie)*np.cos(diffLon0)
-        r2= -re*np.cos(phie)*np.sin(diffLon0)
-        r3=re*np.sin(phie)
-        rn=np.sqrt(np.square(r1)+np.square(r2)+np.square(r3))
-
-
-        x= np.degrees(np.arctan(-r2/r1))
-        y= np.degrees(np.arcsin(-r3/rn))
-
-        c=(self.COFF+x*np.power(2.0,-16)*self.CFAC -0.5).astype(np.int32)
-        l=(self.LOFF+y*np.power(2.0,-16)*self.LFAC -0.5).astype(np.int32)
-        return (l,c)
-
-    def transform_inver(self,l,c):
-        eab2 = (self.ea / self.eb) ** 2
-        x = np.radians((c - self.COFF) / (np.power(2.0, -16) * self.CFAC))
-        y = np.radians((l - self.LOFF) / (np.power(2.0, -16) * self.LFAC))
-        sd = np.sqrt((self.h*np.cos(x)*np.cos(y))**2-(np.cos(y)**2+eab2*np.sin(y)**2)*(self.h**2-self.ea**2))
-        sn = (self.h*np.cos(x)*np.cos(y)-sd)/(np.cos(y)**2+eab2*np.sin(y)**2)
-        s1 = self.h-sn*np.cos(x)*np.cos(y)
-        s2 = sn*np.sin(x)*np.cos(y)
-        s3 = -sn*np.sin(y)
-        sxy = np.sqrt(s1**2+s2**2)
-        lon = np.degrees(np.arctan(s2/s1))+np.degrees(self.lambdaD)
-
-        lon[lon>180] -=360
-        lat = np.degrees(np.arctan(eab2*s3 / sxy))
-        return (lat,lon)
-    
-
-
-    def transforMat(self,ltc,step,SNCmat):
-        _,_,latMat,lonMat = getLatlonMat(ltc,step)
-        (l,c)=self.transform(latMat,lonMat)
-        snclatlon=SNCmat[l,c]
-        return snclatlon
-
-class H8Proj():
-    def __init__(self, lonD=140.7, resolution=2000):
-        self.ea = 6378.137
-        self.eb = 6356.7523
-        self.h = 42165.32745491
-        self.lambdaD = np.radians(lonD)
-
-        OFF = {500: 11000.5, 1000: 5500.5 , 2000: 2750.5}
-        FAC = {500: 81865099, 1000: 40932549, 2000: 20466275}
-
-        self.COFF = OFF[resolution]
-        self.LOFF = OFF[resolution]
-        self.CFAC = FAC[resolution]
-        self.LFAC = FAC[resolution]
-
-
-    def transform(self,latD, lonDe):
-        lat = np.radians(latD)
-        lon = np.radians(lonDe)
-        ba2 = np.square(self.eb / self.ea)
-        phie = np.arctan(ba2 * np.tan(lat))
-        diffLon0 = lon - self.lambdaD
-        re = self.eb / np.sqrt(1 - (1 - ba2) * np.square(np.cos(phie)))
-
-        r1 = self.h - re * np.cos(phie) * np.cos(diffLon0)
-        r2 = -re * np.cos(phie) * np.sin(diffLon0)
-        r3 = re * np.sin(phie)
-        rn = np.sqrt(np.square(r1) + np.square(r2) + np.square(r3))
-
-        x = np.degrees(np.arctan(-r2 / r1))
-        y = np.degrees(np.arcsin(-r3 / rn))
-
-        c = (self.COFF + x * np.power(float(2), -16) * self.CFAC - 0.5).astype(np.int32)
-        l = (self.LOFF + y * np.power(float(2), -16) * self.LFAC - 0.5).astype(np.int32)
-        return (l, c)
-
-    def transforMat(self,ltc,step,SNCmat,loff):
-        _,_,latMat,lonMat = getLatlonMat(ltc,step)
-        (l,c)=self.transform(latMat,lonMat)
-        snclatlon=SNCmat[l-int(loff),c]
-        return snclatlon
-
-
-
-def getLatlonMat(ltc,step,endPoint=True):
-    end = 1 if endPoint else 0
-    latArr = np.linspace(ltc.n, ltc.s, int(np.round((ltc.n - ltc.s) / step, 4)) + end)
-    if ltc.e<ltc.w:
-        E = ltc.e+360
-        lonRange = E - ltc.w
-        lonArr = np.linspace(ltc.w, E, int(np.round(lonRange / step, 4)) + end)
-        lonArr[lonArr>=180] -=360
-    else:
-        lonRange = ltc.e - ltc.w
-        lonArr = np.linspace(ltc.w, ltc.e, int(np.round(lonRange / step,4)) + end)
-    latMat = np.dot(latArr.reshape(-1, 1), np.ones([1, len(lonArr)]))
-    lonMat = np.dot(np.ones([len(latArr), 1]), np.expand_dims(lonArr, axis=0))
-    return latArr,lonArr,latMat,lonMat
-
-def getLatlonMat1(ltc,step,endPoint=True):
-    end = 1 if endPoint else 0
-    latArr = np.linspace(ltc.n, ltc.s, int((ltc.n - ltc.s) / step) + end)
-    lonArr = np.linspace(ltc.w, ltc.e, int((ltc.e - ltc.w) / step) + end)
-    latMat = np.dot(latArr.reshape(-1, 1), np.ones([1, len(lonArr)]))
-    lonMat = np.dot(np.ones([len(latArr), 1]), np.expand_dims(lonArr, axis=0))
-    return latArr,lonArr,latMat,lonMat
-
-def cartesian_to_geographic_aeqd(x, y, lon_0, lat_0, R=6370997.):
-    x = np.atleast_1d(np.asarray(x))
-    y = np.atleast_1d(np.asarray(y))
-
-    lat_0_rad = np.deg2rad(lat_0)
-    lon_0_rad = np.deg2rad(lon_0)
-
-    rho = np.sqrt(x*x + y*y)
-    c = rho / R
-
-    with warnings.catch_warnings():
-        # division by zero may occur here but is properly addressed below so
-        # the warnings can be ignored
-        warnings.simplefilter("ignore", RuntimeWarning)
-        lat_rad = np.arcsin(np.cos(c) * np.sin(lat_0_rad) +
-                            y * np.sin(c) * np.cos(lat_0_rad) / rho)
-    lat_deg = np.rad2deg(lat_rad)
-    # fix cases where the distance from the center of the projection is zero
-    lat_deg[rho == 0] = lat_0
-
-    x1 = x * np.sin(c)
-    x2 = rho*np.cos(lat_0_rad)*np.cos(c) - y*np.sin(lat_0_rad)*np.sin(c)
-    lon_rad = lon_0_rad + np.arctan2(x1, x2)
-    lon_deg = np.rad2deg(lon_rad)
-    # Longitudes should be from -180 to 180 degrees
-    lon_deg[lon_deg > 180] -= 360.
-    lon_deg[lon_deg < -180] += 360.
-
-    return lon_deg, lat_deg
-

shancx/wtx/inotify.py

@@ -1,41 +0,0 @@
-import os
-from pyinotify import WatchManager, Notifier,ProcessEvent,IN_DELETE, IN_CREATE,IN_MODIFY
-
-
-class EventHandler(ProcessEvent):
-    """事件处理"""
-    def process_IN_CREATE(self, event):
-        print("Create file: %s " %  os.path.join(event.path,event.name))
-        
-    def process_IN_DELETE(self, event):
-        print("Delete file: %s " %  os.path.join(event.path,event.name))
- 
-    def process_IN_MODIFY(self, event):
-        filePath=os.path.join(event.path,event.name)
-        if "tweet" in event.name:
-            print("Modify file: %s " % filePath )
-            print("*"*30)
-            try:
-                with  open(filePath , 'r') as f:
-                    print (f.read())
-            except Exception as e:
-                print(e)
-
-def FSMonitor(path='.'):
-    wm = WatchManager() 
-    mask = IN_DELETE | IN_CREATE |IN_MODIFY
-    notifier = Notifier(wm, EventHandler())
-    wm.add_watch(path, mask,auto_add=True,rec=True)
-    print('now starting monitor %s'%(path))
-    while True:
-        try:
-            notifier.process_events()
-            if notifier.check_events():
-                notifier.read_events()
-        except KeyboardInterrupt:
-            notifier.stop()
-            break
-
-if __name__ == "__main__":
-    FSMonitor('/var/log/shiny-server')
-

shancx/wtx/matplotlibMess.py

@@ -1,87 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-@author: Yichen Wang
-@date: 06/30/2020
-"""
-import matplotlib.pyplot as plt
-from matplotlib import cm, colors
-import numpy as np
-
-def generateCmap(breakPointColors, breakPoints=None, sensitivity=256, 
-               name="userCmap"):
-    '''
-    Aimed at generate user customized ListedColormap instance, to be used when 
-    plotting with matplotlib.
-    Arguments:
-    ----------
-    breakPointColors: 
-        An array of color difinitions. Can be "rgba" vector or a string (like 
-        "red") that `matplotlib.colors.to_rgba()` accepts.
-    breakPoints: 
-        Optional. An array of numbers that defines the border of color 
-        gradients. The values does not necessarily match the border of the 
-        data to plot, but will be reflected as ratio on the plot. Must be of 
-        the same length as `breakPointColors`.
-    sensitivity: 
-        An integer for how many intrinsic intervals in the colormap. Default 
-        `256`. Should use larger value if there are breakpoints close to each 
-        other.
-    Return:
-    ----------
-        a matplotlib.colors.ListedColormap object, that can be used for "cmap"
-    argument in matplotlib plotting function.
-    Example:
-    ----------
-    >>> import matplotlib.pyplot as plt
-    >>> cmap = generateCmap(['blue', 'white', 'red'])
-    >>> plt.scatter(range(100), range(100), c=range(100), cmap=cmap)
-    '''
-    # Input Check
-    assert len(breakPointColors) >= 2
-    if breakPoints != None:
-        assert len(breakPoints) == len(breakPointColors)
-        assert len(set(breakPoints)) == len(breakPoints), \
-               "Should not give duplicated value in 'breakPoints'"
-    else:
-        breakPoints = list(range(len(breakPointColors)))
-    
-    breakPointColors = np.array(breakPointColors)
-    assert len(breakPointColors.shape) == 1 or \
-           len(breakPointColors.shape) == 2
-    if len(breakPointColors.shape) == 1:
-        assert str(breakPointColors.dtype).startswith('<U'), \
-               "Color specification dtype not understandable"
-    elif len(breakPointColors.shape) == 2:
-        assert breakPointColors.shape[1] in [3, 4] and \
-               breakPointColors.dtype in ['int32', 'float64'], \
-               "'rgb(a)' color specification not understandable."
-
-    ## Randomly fetch an ListedColormap object, and modify the colors inside
-    cmap = cm.get_cmap("viridis", sensitivity)
-    cmap.name = name
-    
-    # Format the input
-    minBP, maxBP = min(breakPoints), max(breakPoints)
-    scaledBP = [round((i-minBP)/(maxBP-minBP)*(sensitivity-1)) \
-                for i in breakPoints]
-    assert len(set(scaledBP)) == len(breakPoints), \
-           "Sensitivity too low"
-    sortedBP = sorted(scaledBP)
-    sortedBPC = []
-    for i in sortedBP:
-        idx = scaledBP.index(i)
-        sortedBPC.append(breakPointColors[idx])
-    BPC_rgba = np.array([colors.to_rgba(i) for i in sortedBPC])
-    # Now replace colors in the Colormap object
-    for i in range(1, len(sortedBP)):
-        ## Indices when slicing colormap.colors
-        start = sortedBP[i-1]
-        end = sortedBP[i] + 1
-        n = end - start
-        ## Color range
-        startC = BPC_rgba[i-1]
-        endC = BPC_rgba[i]
-        for i in range(3):
-            cmap.colors[start:end, i] = np.linspace(startC[i], endC[i], n)
-        
-    return cmap