Goodies pour Python

Ce module fournit divers outils pour la gestion de fichiers, les calculs astronomiques, la manipulation de chaînes, et d’autres opérations utilitaires, facilitant ainsi plusieurs tâches courantes en programmation.

Classes

property

Une classe pour gérer des propriétés sous forme de paires clé-valeur séparées par des points-virgules.
- Méthodes :
  - __init__(self, data: str) : Initialise l’objet avec des paires clé-valeur.
  - get(self, key: str) -> str : Retourne la valeur associée à une clé, ou « ? » si la clé n’existe pas.

Fonctions

copyFile(source: str, destination: str)

Copie un fichier d’un emplacement source vers un emplacement de destination.
Arguments :
- source : Le chemin du fichier source.
- destination : Le chemin de destination pour le fichier copié.

createDico(path: str, section: str) -> dict

Crée un dictionnaire à partir d’un fichier INI pour une section donnée.
Arguments :
- path : Le chemin du fichier INI.
- section : La section du fichier INI à lire.
Retourne : Un dictionnaire des éléments de la section.

executerCmd(cmd: str) -> Tuple[int, str]

Exécute une commande système et retourne le code de retour ainsi que la sortie standard.
Arguments :
- cmd : La commande à exécuter.
Retourne :
- Un tuple contenant le code de retour et la sortie standard de la commande.

exceptionToString(e: Exception) -> str

Retourne une chaîne décrivant une exception donnée.
Arguments :
- e : L’exception à décrire.
Retourne : La description de l’exception.

getDir(chemin: str) -> List[str]

Retourne une liste de tous les fichiers et sous-répertoires dans un répertoire donné.
Arguments :
- chemin : Le chemin du répertoire à explorer.
Retourne : Une liste de chemins de fichiers.

getEphem(latitude: str, longitude: str, annee: int, mois: int, jour: int) -> Tuple[str, str, str, str, str, str, str]

Retourne les informations sur les événements astronomiques pour une date et un lieu donnés.
Arguments :
- latitude : Latitude de l’observateur.
- longitude : Longitude de l’observateur.
- annee, mois, jour : La date d’observation.
Retourne : Un tuple contenant le lever et coucher du soleil, la durée du jour, la variation de durée du jour, le lever et coucher de la lune, et la phase de la lune.

getFtp(server: str, user: str, passwd: str, localpath: str, remotepath: str)

Télécharge un fichier depuis un serveur FTP.
Arguments :
- server : Adresse du serveur FTP.
- user : Nom d’utilisateur pour la connexion FTP.
- passwd : Mot de passe pour la connexion FTP.
- localpath : Chemin local pour sauvegarder le fichier.
- remotepath : Chemin du fichier sur le serveur FTP.

getHttp(url: str, outpath: str) -> int

Effectue une requête HTTP GET et sauvegarde le contenu dans un fichier local.
Arguments :
- url : L’URL à requêter.
- outpath : Le chemin local pour sauvegarder le contenu.
Retourne : Le code HTTP de la réponse.

getFileArray(path: str, encoding="utf-8") -> List[str]

Retourne une liste de chaînes, chaque élément correspondant à une ligne du fichier.
Arguments :
- path : Le chemin du fichier.
- encoding : L’encodage du fichier (par défaut « utf-8 »).
Retourne : Une liste de lignes du fichier.

getFileString(path: str, encoding="utf-8") -> str

Retourne le contenu d’un fichier sous forme de chaîne de caractères.
Arguments :
- path : Le chemin du fichier.
- encoding : L’encodage du fichier (par défaut « utf-8 »).
Retourne : Le contenu du fichier.

haversine_distance(lat1: float, lon1: float, lat2: float, lon2: float) -> float

Calcule la distance en kilomètres entre deux points géographiques.
Arguments :
- lat1, lon1 : Latitude et longitude du premier point.
- lat2, lon2 : Latitude et longitude du second point.
Retourne : La distance entre les deux points en kilomètres.

kmhToBeaufort(vitesse_vent_kmh: int) -> int

Convertit la vitesse du vent en km/h en l’échelle de Beaufort.
Arguments :
- vitesse_vent_kmh : La vitesse du vent en kilomètres par heure.
Retourne : La force du vent sur l’échelle de Beaufort.

mkdir(path: str)

Crée un répertoire, sans générer d’erreur si le répertoire existe déjà.
Arguments :
- path : Le chemin du répertoire à créer.

nowToString() -> str

Retourne la date et l’heure courantes sous forme de chaîne lisible.
Retourne : La date et l’heure courantes sous forme de chaîne.

padIntZeroLeft(x: int, n: int) -> str

Retourne une chaîne représentant l’entier x complété à gauche avec des zéros jusqu’à ce que la chaîne ait n caractères.
Arguments :
- x : L’entier à formater.
- n : La longueur finale de la chaîne.
Retourne : La chaîne formatée avec des zéros à gauche.

p(d: str)

Affiche la chaîne d sans passer à la ligne suivante.
Arguments :
- d : La chaîne à afficher.

padr(d: str, n: int, car=" ") -> str

Retourne la chaîne d complétée à droite avec le caractère car jusqu’à ce que la chaîne ait n caractères.
Arguments :
- d : La chaîne de caractères à compléter.
- n : La longueur finale de la chaîne.
- car : Le caractère de remplissage (par défaut » « ).
Retourne : La chaîne complétée.

pl(d: str)

Affiche la chaîne d suivie d’un saut de ligne.
Arguments :
- d : La chaîne à afficher.

putFileArray(path: str, t: List[str], encoding="utf-8")

Sauvegarde une liste de chaînes de caractères dans un fichier, chaque chaîne étant une ligne.
Arguments :
- path : Le chemin du fichier.
- t : La liste de chaînes de caractères à sauvegarder.
- encoding : L’encodage à utiliser (par défaut « utf-8 »).

putFileString(path: str, d: str, encoding="utf-8")

Sauvegarde une chaîne de caractères dans un fichier spécifié.
Arguments :
- path : Le chemin du fichier.
- d : La chaîne de caractères à sauvegarder.
- encoding : L’encodage à utiliser (par défaut « utf-8 »).

putFtp(server: str, user: str, passwd: str, localpath: str, remotepath: str)

Téléverse un fichier vers un serveur FTP.
Arguments :
- server : Adresse du serveur FTP.
- user : Nom d’utilisateur pour la connexion FTP.
- passwd : Mot de passe pour la connexion FTP.
- localpath : Chemin du fichier local à téléverser.
- remotepath : Chemin où sauvegarder le fichier sur le serveur FTP.

stringToAsciiHex(d: str) -> str

Convertit les caractères non-ASCII en leur code hexadécimal, tout en gardant les caractères ASCII tels quels.
Arguments :
- d : La chaîne à convertir.
Retourne : La chaîne avec les caractères non-ASCII remplacés par leur code hexadécimal.

stampToAAAAMMJJHHMMSS(d: int) -> str

Retourne une chaîne représentant une date et heure au format « AAAAMMJJHHMMSS » à partir d’un timestamp.
Arguments :
- d : Le timestamp.
Retourne : La chaîne formatée.

ungzip(inpath: str, outpath: str)

Décompresse un fichier gzip et écrit le contenu dans un fichier spécifié.
Arguments :
- inpath : Chemin du fichier gzip à décompresser.
- outpath : Chemin où écrire le fichier décompressé.

jourToHHMMSS(duree_jours: int) -> str

Convertit une durée en jours en heures, minutes et secondes.
Arguments :
- duree_jours : La durée en jours.
Retourne : La chaîne formatée en heures, minutes et secondes.

Python

import traceback
import locale
import calendar
import requests
from datetime import datetime
import time
from ftplib import FTP
import os
from typing import *
import gzip
import ephem
import datetime
import shutil
import subprocess

def executerCmd(cmd:str):
    resultat = subprocess.run(cmd ,capture_output=True, text=True)
    return resultat.returncode,resultat.stdout
    
def p(d:str):
    #!Affiche d sans passer à la ligne
    print(d,end="")
    
def pl(d:str):
    #!Affiche d puis passe à la ligne
    print(d)
    
def getFtp(server:str,user:str,passwd:str,localpath:str,remotepath:str):
    #!Permet de recevoir un fichier à partir d'un serveur FTP
    ftp=FTP(server)
    ftp.login(user,passwd)
    flocal=open(localpath, "wb") 
    ftp.retrbinary("RETR " + remotepath, flocal.write)
    ftp.quit()
    flocal.close()

def putFtp(server:str,user:str,passwd:str,localpath:str,remotepath:str):
    #!Permet de transferer un fichier sur un serveur FTP
    ftp=FTP(server)
    ftp.login(user,passwd)
    flocal=open(localpath,"rb")
    ftp.storbinary("STOR "+remotepath,flocal)
    ftp.quit()
    flocal.close()
    
def padIntZeroLeft(x:int,n:int)->str:
    #!Retourne une chaine de caractères ou l'entier x
    #!a été complété à gauche avec des zéros de telle
    #!sorte que la chaine fasse n caractères
    r = str(x)
    while len(r)<n:
        r="0"+r
    return r

def tos(x:float)->str:
    #!retourne une chaine faisant l'arrondi de x et
    #!conservant deux chifrres après le point décimal
    return str(round(x,2))

def getNomMois(num:int)->str:
    #!Retourne le nom du mois ou num est un entier compris
    #!dans l'intervalle [1,12]
    return calendar.month_name[num]
    
def nowToString()->str:
    #!Retourne la date et heure courante en clair, par exemple:
    #!18 janvier 2024 a 12:30
    return datetime.datetime.now().strftime("%d %B %Y à %H:%M")
   
def putFileString(path:str,d:str,encoding="utf-8"):
    #!sauvegarde la chaine de caractères d dans le fichier de chemin path
    fout=open(path,"w",encoding=encoding)
    fout.write(d)
    fout.close()
    
def getFileString(path:str,encoding="utf-8")->str:
    #!Retourne le contenu du fichier dans une chaine de caractères
    finp=open(path,"r",encoding=encoding)
    d=finp.read()
    finp.close()
    return d
    
def exceptionToString(e:Exception)->str:
    #!Retourne une chaine de caracteres decrivant l'exception
    return "".join(traceback.format_exception(type(e), e, e.__traceback__))

def getFileArray(path:str,encoding="utf-8")->List[str]:
    #!retourne une liste de chaines de caractères ou chaque
    #!élément est une ligne du fichier texte de chemin path
    t=[]
    finp=open(path,"r",encoding=encoding)
    for ligne in finp:
        t.append(ligne.strip())
    finp.close()    
    return t    
  
def putFileArray(path:str,t:List[str],encoding="utf-8"):
    fout=open(path,"w",encoding=encoding)
    for elt in t:
        fout.write(elt+"\n")
    fout.close()
    
def padr(d:str,n:int,car=" ")->str:
    #!retourne la chaine de caractères d complétée a droite avec
    #!la caractère car de remplissage de telle sorte que la chaine retournée ait n caractères
    r=d
    while len(r)<n:
        r+=car
    return r

def getHttp(url:str,outpath:str)->int:
    #!Retourne le code http :
    #!ok    200
    #!sinon code d'erreur
    headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"}
    response = requests.get(url,headers=headers)
    retcode=response.status_code
    if retcode == 200:
        content = response.content
        fout=open(outpath,"wb")
        fout.write(content)
        fout.close()
    return retcode

def mkdir(path:str):
    #!crée le répertoire, pas d'erreur si le répertoire existe déjà
    try:
        os.mkdir(path)
    except Exception:
        pass
    
def ungzip(inpath:str,outpath:str):
    #!decompresse le fichier gzip (inpath) dans le fichier (outpath)
    finp=gzip.open(inpath, "rb")
    fout=open(outpath, "wb")
    fout.write(finp.read())
    fout.close()
    finp.close()
    
def haversine_distance(lat1:float, lon1:float, lat2:float, lon2:float)->float:
    #!calcule la distance de deux points sur la terre
    lat1, lon1, lat2, lon2 = map(math.radians, [lat1, lon1, lat2, lon2])
    dlat = lat2 – lat1
    dlon = lon2 – lon1
    a = math.sin(dlat/2)**2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon/2)**2
    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))
    radius_of_earth = 6371  # Rayon moyen de la Terre en kilomètres
    return radius_of_earth * c

def stringToAsciiHex(d:str)->str:
    #!Retourne une chaine ou les caractères non compris entre 0 et 127
    #!sont remplacés par leur code hexadecimal sous la forme 0x..
    r=""
    n=len(d)
    for i in range(n):
        c=d[i]
        ic=ord(c)
        if ic>=32 and ic<=127:
            r+=c
        else:
            r+=hex(ic)
    return r

def createDico(path:str,section:str)->dict:
    #!Retourne un dictionnaire à partir d'un fichier ini dont on connait
    #!le chemin, et pour une section donnée
    config = configparser.ConfigParser()
    config.read(path)
    return dict(config.items(section))

def jourToHHMMSS(duree_jours:int)->str:
    #!Convertir un nombre de jours en heures, minutes et secondes
    duree_heures = int(duree_jours * 24)
    duree_minutes = int((duree_jours * 24 * 60) % 60)
    duree_secondes = int((duree_jours * 24 * 3600) % 60)
    return padIntZeroLeft(duree_heures,2)+":"+padIntZeroLeft(duree_minutes,2)+":"+padIntZeroLeft(duree_secondes,2)

def stampToAAAAMMJJHHMMSS(d:int)->str:
    #!Retourne ?
    r=str(d)[:19]
    return r
    
def getEphem(latitude:str,longitude:str,annee:int,mois:int,jour:int)->Tuple[str,str,str,str,str,str,str]:
    #!Retourne un t-uple avec:
    #!lever soleil  ,coucher soleil,durée jour,variation durée jour,lever lune    ,coucher lune
    #!AAAAMMJJHHMMSS,AAAAMMJJHHMMSS,HHMMSS    ,HHMMSS              ,AAAAMMJJHHMMSS,AAAAMMJJHHMMSS
    obs = ephem.Observer()
    obs.lat = latitude 
    obs.lon = longitude
    w=str(annee)+"/"+str(mois)+"/"+str(jour)+" 00:00:00"
    #pl(w)
    d = ephem.Date(w)
    #pl(d)
    di=datetime.date(annee, mois, jour)
    dp= di – datetime.timedelta(days=1)
    sunrisep=obs.next_rising(ephem.Sun(), start=dp)
    sunsetp=obs.next_setting(ephem.Sun(), start=dp)
    sunrise = obs.next_rising(ephem.Sun(), start=d)
    sunset = obs.next_setting(ephem.Sun(), start=d)
    duree=sunset-sunrise
    dureep=sunsetp-sunrisep
    obs.date=d
    lune=ephem.Moon(obs)
    moonrise=obs.next_rising(lune)
    moonset=obs.next_setting(lune)
    phase=ephem.Moon(obs).phase
    #pl(moonrise)
    #pl(moonset)
    #pl(phase)
    r1=stampToAAAAMMJJHHMMSS(ephem.localtime(sunrise))
    r2=stampToAAAAMMJJHHMMSS(ephem.localtime(sunset))
    r3=jourToHHMMSS(duree)
    r4=jourToHHMMSS(duree-dureep)
    r5=stampToAAAAMMJJHHMMSS(ephem.localtime(moonrise))
    r6=stampToAAAAMMJJHHMMSS(ephem.localtime(moonset))
    r7=tos(phase)
    return r1,r2,r3,r4,r5,r6,r7

def kmhToBeaufort(vitesse_vent_kmh:int)->int:
    #print("vit v ",vitesse_vent_kmh)
    if vitesse_vent_kmh < 1:
        return 0
    elif vitesse_vent_kmh < 6:
        return 1
    elif vitesse_vent_kmh < 12:
        return 2
    elif vitesse_vent_kmh < 20:
        return 3
    elif vitesse_vent_kmh < 29:
        return 4
    elif vitesse_vent_kmh < 39:
        return 5
    elif vitesse_vent_kmh < 50:
        return 6
    elif vitesse_vent_kmh < 62:
        return 7
    elif vitesse_vent_kmh < 75:
        return 8
    elif vitesse_vent_kmh < 89:
        return 9
    elif vitesse_vent_kmh < 103:
        return 10
    elif vitesse_vent_kmh < 118:
        return 11
    else:
        return 12

def getDir(chemin:str)->List[str]:
    #!Retourne la liste des fichiers et sous-répertoires d'un répertoire donné
    t=[]
    for dossier_racine, dossiers, fichiers in os.walk(chemin):
        for fichier in fichiers:
            t.append(os.path.join(dossier_racine,fichier).replace("\\","/"))
    return t

def copyFile(source:str, destination:str):
    #!Copie un fichier
    shutil.copy2(source, destination)
    
class property():
    def __init__(self,data):
        self.dico={}
        paires=data.split(";")
        for paire in paires:
            key,value=paire.split(":")
            self.dico[key]=value
    def get(self,key):
        return self.dico.get(key,"?")

Grimeco

Goodies pour Python

Classes

Fonctions

A DECOUVRIR EGALEMENT

Éditeur de Schémas Électroniques

Ollama : Intégration de LLMs en local

Raspberry Radio Internet (Partie 1)

Laisser un commentaire Annuler la réponse