Conky, ma configuration

Ubunlog

Minutes 37

Fecfactor m'a demandé hier de publier la configuration du conky que je montre dans la capture d'écran ci-dessous

Comme vous pouvez le voir, il y a 3 conkys, qui sont exécutés au moyen d'un script, la configuration de celui-ci est basée sur ce poste posté par l'utilisateur Bruce M. dans les forums de Ubuntu-Ar avec quelques modifications dans le mail conky, qui dans mon cas est pour Gmail.

Dans le post de référence il est très bien expliqué par Bruce, mais aussi comme aide-mémoire pour moi, je vais copier les étapes à suivre et le code de mes conkys pour celui qui l'a.

Eh bien, bien sûr, nous devons avoir conky, curl et python installés afin que nous tapions dans une console:

sudo apt-get installer conky curl python

La source de weather.ttf et flèches.ttf il est ici. La source de moon.ttf il est ici une fois téléchargés, vous devez les copier dans / usr / share / fonts

Créons maintenant notre script appelé ~. / Startconky

gksudo gedit ~ / .startconky

à l'intérieur du fichier vide, nous collons ce qui suit

#! / Bin / bash
sleep 0 & # 0 bon pour Xfce - utilisez 20 à 30 pour Gnome
conky -c ~ / Conky / conkymain &
#sleep 0 & # 0 bon pour Xfce - utilisez 1 pour Gnome
conky -c ~ / Conky / conkyforecast &
#sleep 0 & # 0 bon pour Xfce - utilisez 1 pour Gnome
conky -c ~ / Conky / conkymail &

Maintenant, nous créons le fichier conkymain dans le dossier ~ / Conky, si nous n'avons pas le dossier Conky, nous devrons le créer.

gedit ~ / Conky / conkymain

J'utilise la police Calibri, si vous ne l'avez pas, remplacez-la par ce que vous voulez.

Nous nous en tenons à l'intérieur de ce qui suit

fond non
own_window oui
own_window_transparent oui
own_window_hints non décoré, ci-dessous, collant, skip_taskbar, skip_pager
own_window_colour noir
double_buffer oui
use_spacer gauche
use_xft oui
font calibri: taille = 9
xftfont calibri: taille = 9
xftalpha 0.5
update_interval 5.0
uppercase no # mis à yes si vous voulez que tout le texte soit en majuscules
pointillé_borders 3
bordure_margin 9
bordure_largeur 10
default_color blanc
default_outline_color noir
default_shade_color noir
couleur0 cyan
color1 bleu clair
couleur2 orange
color3 jaune
blé color4
color5 blanc
color6 blanc
color7 blanc
color8 blanc
color9 blanc
alignement top_right # ou top_left, bottom_left, bottom_right
écart_x 10
écart_y 35
text_buffer_size 128 # utilise 1024 pour les prévisions
no_buffers yes # Soustraire les tampons du système de fichiers de la mémoire utilisée?
draw_borders non
draw_outline yes # amplifie le texte si oui
draw_shades oui # shadecolor noir

TEXTE
$ {font calibri: size = 12} $ {alignc} $ {color1} $ sysname $ kernel sur $ machine} $ color $ font
$ {font calibri: size = 12} $ {alignc} $ {color2} $ {exec whoami} @ $ nodename $ color $ font
$ {color0} $ {hr 1} $ couleur
$ {font calibri: size = 20} $ {alignc} $ {time% H:% M} $ font
$ {font calibri: size = 12} $ {color1} $ {alignc} $ {time% A,% d% b. % Y} $ couleur $ police
$ {color3} UpTime: $ {alignr 2} $ uptime $ color
$ {color0} $ {hr 1} $ couleur
$ {voffset 5} $ {color2} CPU: $ {alignc} $ color $ running_processes $ {color1} / $ couleur $ processus $ {alignr 2} $ {color2} $ {cpubar cpu0 14,80} $ color
$ {color1} $ {voffset -16} $ {alignr 5} $ cpu% $ color
$ {voffset 2} $ {color1} Charge moyenne ($ {color3} Min $ {color1}): $ {alignr 2} $ {color3} 1: $ color $ {loadavg 1} $ {color3} 5: $ color $ {loadavg 2} $ {color3} 15: $ color $ {loadavg 3}
$ {voffset 5} $ {color2} RAM: $ color $ mem $ {color2} / $ color $ memmax $ {alignr 2} $ {color2} $ {membar 14,80} $ color
$ {color1} $ {voffset -16} $ {alignr 5} $ memperc% $ color
$ {voffset 2} $ {color1} Buffered: $ color $ {buffers} $ {alignr 2} $ {color1} Cached: $ color $ {cached}
$ {voffset 5} $ {color2} SWAP: $ color $ swap $ {color2} / $ color $ {swapmax} $ {alignr 2} $ {color2} $ {swapbar 14,80} $ color
$ {color1} $ {voffset -16} $ {alignr 5} $ swapperc%
$ {color0} $ {hr 1} $ couleur
$ {voffset 5} $ {color2} HD Info $ {color1} - $ color Gratuit $ {color1} - Utilisé - $ {color2} Total
$ {voffset 5} $ {color1} Racine: $ color $ {fs_free_perc /}% $ {alignr 2} $ {fs_free /} $ {color2} / $ {color1} $ {fs_used /} $ color / $ {color2} $ {fs_size /} $ couleur
$ {color1} Accueil: $ color $ {fs_free_perc / home / user}% $ {alignr 2} $ {fs_free / home / user} $ {color2} / $ {color1} $ {fs_used / home / user} $ color / $ {color2} $ {fs_size / home / user} $ color
$ {color0} $ {hr 1} $ couleur
$ {color1} De: $ color Buenos Aires, Argentine
$ {color1} Lat: $ {color2} 34 ° 35'S $ {color1} Long: $ {color2} 58 ° 21'W $ {color1} Alt: $ {color2} 25 m $ color
$ {voffset 5} $ {color2} $ {font calibri: size = 12} aujourd'hui: $ font $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = CC} $ color $ {alignr 2} $ {color1} ST: $ {color2} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = LT}
$ {color3} $ {font Weather: size = 50} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = WF} $ font $ color
$ {alignr 50} $ {voffset -55} $ {font calibri: size = 25} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = HT} $ font
$ {alignc 20} $ {voffset -30} $ {font Flèches: size = 20} $ {color4} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = BF} $ color $ Police de caractère
$ {alignc 10} $ {voffset 5} $ {color4} Vent: $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = WS} $ color
$ {color1} Humidité: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = HM} $ {alignr 2} $ {color1} Précipitations: $ {color3} $ { execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = PC} $ couleur
$ {alignc} $ {color1} Pression: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = BR} - $ {color3} $ {execi 3600 python ~ / Conky /scripts/conkyForecast.py –location = ARBA0009 –datatype = BD} $ couleur
$ {color4} $ {hr} $ couleur
$ {color1} Sunrise: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = SR} $ {alignr 2} $ {color1} Sunset: $ {color3} $ { execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = SS} $ couleur
$ {voffset 15} $ {color1} Lune: $ {color4} $ {alignr 2} $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = MP} $ color
$ {voffset -20} $ {offset 80} $ {color4} $ {font moon phases: size = 20} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = MF} $ font $ couleur
$ {color0} $ {hr} $ couleur
$ {voffset 5} $ {color2} IP: $ {alignc} $ color $ {addr eth0}
$ {color1} Bas: $ color $ {downspeed eth0} k / s $ {alignr 2} $ {color1} Up: $ color $ {upspeed eth0} k / s
$ {color1} Total: $ color $ {totaldown eth0} $ {alignr 2} $ {color1} Total: $ color $ {totalup eth0}
$ {color1} Entrant: $ color $ {tcp_portmon 1 32767 count} $ {color1} Sortant: $ color $ {tcp_portmon 32768 61000 count} $ {alignr 2} $ {color1} Total: $ color $ {tcp_portmon 1 65535 count}
$ {voffset 5} $ {color2} Connexions: $ color $ {tcp_portmon 32768 61000 count} $ {alignr 2} $ {color2} Service / Port $ color
$ {voffset 5} $ {tcp_portmon 32768 61000 rhost 0} $ {alignr 2} $ {tcp_portmon 32768 61000 rservice 0}
$ {tcp_portmon 32768 61000 rhost 1} $ {alignr 2} $ {tcp_portmon 32768 61000 rservice 1}
$ {tcp_portmon 32768 61000 rhost 2} $ {alignr 2} $ {tcp_portmon 32768 61000 rservice 2}
$ {tcp_portmon 32768 61000 rhost 3} $ {alignr 2} $ {tcp_portmon 32768 61000 rservice 3}
$ {tcp_portmon 32768 61000 rhost 4} $ {alignr 2} $ {tcp_portmon 32768 61000 rservice 4}
$ {tcp_portmon 32768 61000 rhost 5} $ {alignr 2} $ {tcp_portmon 32768 61000 rservice 5} $ couleur

nous créons le fichier ~ / Conky / conkyforecast

gedit ~ / Conky / conkyforecast

et nous collons ce qui suit à l'intérieur

fond non
own_window oui
own_window_transparent oui
own_window_hints non décoré, ci-dessous, collant, skip_taskbar, skip_pager
own_window_colour noir
double_buffer oui
use_spacer gauche
use_xft oui
font calibri: taille = 8
xftfont calibri: taille = 8
xftalpha 0.5
update_interval 5.0
uppercase no # mis à yes si vous voulez que tout le texte soit en majuscules
pointillé_borders 3
bordure_margin 9
bordure_largeur 10
default_color blanc
default_outline_color noir
default_shade_color noir
couleur0 cyan
color1 bleu clair
couleur2 orange
color3 jaune
blé color4
color5 blanc
color6 blanc
color7 blanc
color8 blanc
color9 blanc
alignement bottom_left # ou top_left, bottom_left, bottom_right
écart_x 10
écart_y 35
text_buffer_size 1024 # utilise 1024 pour les prévisions
no_buffers yes # Soustraire les tampons du système de fichiers de la mémoire utilisée?
draw_borders non
draw_outline yes # amplifie le texte si oui
draw_shades oui # shadecolor noir

TEXTE
$ {color4} $ {font calibri: size = 11} Prévisions étendues $ font $ color
$ {color0} $ {hr} $ couleur
$ {color4} $ {font calibri: size = 9} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –template = / home / user / Conky / scripts / myweather.template} $ font $ Couleur

nous créons le fichier ~ / Conky / conkymail

gedit ~ / Conky / conkymail

nous collons ce qui suit dans le fichier

fond non
own_window oui
own_window_transparent oui
own_window_hints non décoré, ci-dessous, collant, skip_taskbar, skip_pager
own_window_colour noir
double_buffer oui
use_spacer gauche
use_xft oui
font calibri: taille = 8
xftfont calibri: taille = 8
xftalpha 0.5
update_interval 5.0
uppercase no # mis à yes si vous voulez que tout le texte soit en majuscules
pointillé_borders 3
bordure_margin 9
bordure_largeur 10
default_color blanc
default_outline_color noir
default_shade_color noir
couleur0 cyan
color1 bleu clair
couleur2 orange
color3 jaune
blé color4
color5 blanc
color6 blanc
color7 blanc
color8 blanc
color9 blanc
alignement bottom_left # ou top_left, bottom_left, bottom_right
écart_x 565
écart_y 35
text_buffer_size 128 # utilise 1024 pour les prévisions
no_buffers yes # Soustraire les tampons du système de fichiers de la mémoire utilisée?
draw_borders non
draw_outline yes # amplifie le texte si oui
draw_shades oui # shadecolor noir

TEXTE
$ {font calibri: size = 11} $ {alignc} $ {color4} Gmail
$ {color0} $ {hr} $ couleur
$ {font calibri: size = 11} $ {color4} Nous avons $ {color3} $ {execi 300 python ~ / Conky / scripts / mail / conkyEmail.py} $ {color4} email (s) $ font

Nous créons un fichier dans ~ / Conky / scripts / conkyForecast.py (nous devons créer le dossier scripts)

gedit ~ / Conky / scripts / conkyForecast.py

#! / usr / bin / python
# - * - codage: utf-8 - * -
################################################ ############################
# conkyForecast.py est un script python (pas si) simple (plus) à rassembler
# détails de la météo actuelle pour une utilisation à conky.
#
# Auteur: Kaivalagi
# Créé: 13/04/2008
#Modifications:
# 14/04/2008 Autoriser les plages de jours pour les données de prévision
# 14/04/2008 Vérifier la connectivité au service xoap
# 18/04/2008 Autoriser le réglage d'espaces pour la sortie à distance
# 18/04/2008 Autoriser la sortie des prévisions de nuit et de jour
# 18/04/2008 Prise en charge des paramètres régionaux pour le texte du code de condition option «CC», en attente de traduction en espagnol
# 18/04/2008 Utilisez le pickling pour les données de classe plutôt que d'ouvrir xml, cela évite le besoin d'interroger les données mises en cache
# 19/04/2008 Ajout du texte de condition espagnol - Merci Bruce M
# 19/04/2008 Ajout d'un contrôle isnumérique sur toutes les sorties numériques avec le suffixe d'unités
# 19/04/2008 Modification du nom du fichier pickle pour inclure le code de localisation
# 19/04/2008 Ajout de la conversion des jours de semaine en espagnol via les paramètres régionaux
# 20/04/2008 Ajout d'un analyseur d'argument de commande décent
# 20/04/2008 Ajout de l'option –shortweekday, si le type de données du jour de la semaine est raccourci à 3 caractères
# 21/04/2008 Correction des options de paramètres régionaux pour la sortie des prévisions
# 21/04/2008 Ajout de l'option –template pour permettre une sortie personnalisée à l'aide d'un seul appel exec 
# 21/04/2008 Ajout de l'option –hideunits pour supprimer, par exemple, mph et C de la sortie
# 23/04/2008 Suppression de l'option –imperial du modèle, elle DOIT être définie comme une option standard lors de l'appel de script et non utilisée dans le fichier modèle.
# 23/04/2008 Option –imperial lue dans le modèle, activant les valeurs métriques ou impériales par type de données. Remarque lors de l'utilisation de l'option de ligne de commande des modèles ne fonctionnera pas.
# 23/04/2008 Ajout d'une sortie avertissant l'utilisateur si l'emplacement indiqué est incorrect
# 24/04/2008 Ajout de la gestion pour aucune connectivité, reviendra aux données mises en cache maintenant (erreur s'il n'y a pas de cache). Tests en essayant d'ouvrir xoap.weather.com
# 24/04/2008 Correction de la conversion Celsius en Fahrenheit
# 06/05/2008 URL mise à jour utilisée après la mise à jour du webservice
# 09/05/2008 État actuel consolidé et données de prévision récupérées en un seul appel
# 09/05/2008 Ajout du lever et du coucher du soleil aux types de données, ceux-ci sont spécifiques aux conditions actuelles et aux données de prévision
# 09/05/2008 Ajout de la phase de lune, de la lecture du baromètre et de la description du baromètre aux types de données, ceux-ci ne sont spécifiques qu'aux conditions actuelles et sont donc N / A dans la sortie prévue
# 09/05/2008 Ajout des conversions d'unités pour le baromètre de mb en pouces (impérial)
# 09/05/2008 Texte de condition espagnol mis à jour - Merci Bruce M
# 10/05/2008 Ajout des données locales françaises - Merci benpaka
# 12/05/2008 Ajout d'un nouveau type de données BF (police de roulement) pour fournir un caractère de flèche (à utiliser avec la police Arrow.ttf) au lieu de la sortie NSEW de WD (direction du vent)
# 12/05/2008 Mise à jour de la sortie WD pour être spécifique aux paramètres régionaux, prend actuellement en charge l'anglais et l'espagnol par défaut - Merci Bruce M
# 18/05/2008 Ajout d'un nouveau type de données MF (police de lune) pour fournir un caractère de police de lune (caractères incorrects et pas encore de police dédiée).
# 21/05/2008 Pour les conditions actuelles, l'option –datatype = LT affiche désormais la température «ressentie» plutôt que la température actuelle
#
# TOUT:
# Consolider les fichiers pkl en un seul fichier / classe
# Ajouter une police météo basée sur la sortie de phase de lune basée sur les données d'icône de lune
# ??? Y a-t-il d'autres exigences là-bas?

importer sys, os, socket, urllib2, datetime, time
à partir de xml.dom import minidom
à partir de l'importation de statistiques *
depuis optparse import OptionParser
importer des paramètres régionaux
importer gettext
importer des cornichons
à partir de l'importation mathématique *

APP = »conkyForecast.py»
DIR = os.path.dirname (__file__) + '/ locale'
gettext.bindtextdomain (APP, DIR)
gettext.textdomain (APP)
_ = gettext.gettext

classe CommandLineParser:

parser = Aucun

def __init __ (soi):

self.parser = OptionParser ()
self.parser.add_option («- l», »- location», dest = »emplacement», par défaut = »UKXX0103 ″, type =» chaîne », metavar =» CODE », help = u» code de localisation pour les données météorologiques [ par défaut:% default], utilisez l'url suivante pour déterminer votre code de localisation par nom de ville: http://xoap.weather.com/search/search?where=Norwich »)
self.parser.add_option ("- d", "- datatype", dest = "datatype", default = "HT", type = "string", metavar = "DATATYPE", help = u "[default:% default] Les options de type de données sont: DW (jour de la semaine), WF (sortie de police météo), LT (prévision: basse température, courant: se sent comme température), HT (prévision: haute température, courant: température actuelle), CC (courant Conditions), CT (texte des conditions), PC (probabilité de précipitations), HM (humidité), WD (direction du vent), WS (vitesse du vent), WG (rafales de vent), CN (nom de la ville), SR (lever du soleil), SS (coucher de soleil), MP (phase de lune), MF (police de la lune), BR (lecture du baromètre), BD (description du baromètre). Non applicable en ligne de commande lors de l'utilisation de modèles. »)
self.parser.add_option («- s», »- startday», dest = »startday», type = »int», metavar = »NUMBER», help = u »définit le numéro du jour de départ, si les conditions actuelles sont omises . Non applicable en ligne de commande lors de l'utilisation de modèles. »)
self.parser.add_option ("- e", "- endday", dest = "endday", type = "int", metavar = "NUMBER", help = u "définir le numéro du jour de fin, si omis uniquement les données du jour de début est affiché. Non applicable en ligne de commande lors de l'utilisation de modèles. »)
self.parser.add_option («- S», »- espaces», dest = »espaces», type = »int», par défaut = 1, metavar = »NUMBER», help = u »[par défaut:% par défaut] Définit le nombre d'espaces entre la sortie échelonnée. Non applicable en ligne de commande lors de l'utilisation de modèles. »)
self.parser.add_option («- t», »- template», dest = »template», type = »string», metavar = »FILE», help = u »définir un fichier modèle pour générer une sortie en un seul appel. A l'élément affichable dans le fichier se présente sous la forme {–datatype = HT –startday = 1}. Les options suivantes sont possibles pour chaque élément: –datatype, –startday, –endday, –night, –shortweekday, –imperial, –hideunits, –Espaces. Notez que les formes abrégées des options ne sont actuellement pas prises en charge! Aucune de ces options n'est applicable en ligne de commande lors de l'utilisation de modèles. »)
self.parser.add_option («- L», »- locale», dest = »locale», type = »chaîne», help = u »remplace les paramètres régionaux du système pour la sortie de la langue (en = anglais, es = espagnol, fr = français, plus à venir) »)
self.parser.add_option ("- i", "- imperial", dest = "imperial", default = False, action = "store_true", help = u "demande des unités impériales, si la sortie omise est en métrique. Non applicable à ligne de commande lors de l'utilisation de modèles. »)
self.parser.add_option («- n», »- night», dest = »night», default = False, action = »store_true», help = u »basculer la sortie vers les données de nuit, si omis, la sortie jour sera sortie. Non applicable en ligne de commande lors de l'utilisation de modèles. »)
self.parser.add_option («- w», »- shortweekday», dest = »shortweekday», default = False, action = »store_true», help = u »Raccourcit le type de données jour de la semaine à 3 caractères. Non applicable à ligne de commande lors de l'utilisation de modèles. »)
self.parser.add_option («- u», »- hideunits», dest = »hideunits», default = False, action = »store_true», help = u »Masquer les unités telles que mph ou C, les symboles de degré (°) sont toujours affiché. Non applicable en ligne de commande lors de l'utilisation de modèles. »)
self.parser.add_option ("- v", "- verbose", dest = "verbose", default = False, action = "store_true", help = u "demande une sortie verbeuse, ce n'est pas une bonne idée lors de l'exécution de conky!" )
self.parser.add_option ("- r", "- refetch", dest = "refetch", default = False, action = "store_true", help = u "récupérer les données indépendamment de l'expiration des données")

def parse_args (soi):
(options, arguments) = self.parser.parse_args ()
return (options, arguments)

def print_help (soi-même):
retourne self.parser.print_help ()

classe WeatherData :
def __init __ (self, day_of_week, low, high, condition_code, condition_text, précip, humidité, wind_dir, wind_speed, wind_gusts, city, sunrise, sunset, moon_phase, moon_icon, bar_read, bar_desc):
self.day_of_week = u »» + day_of_week
self.low = u »» + faible
self.high = u »» + élevé
self.condition_code = u »» + condition_code
self.condition_text = u »» + condition_text
self.precip = u »» + précip
auto.humidité = u »» + humidité
self.wind_dir = u »» + wind_dir
self.wind_speed = u »» + wind_speed
self.wind_gusts = u »» + wind_gusts
self.city = u »» + ville
self.sunrise = u »» + lever du soleil
self.sunset = u »» + coucher de soleil
self.moon_phase = u »» + moon_phase
self.moon_icon = u »» + moon_icon
self.bar_read = u »» + bar_read
self.bar_desc = u »» + bar_desc

classe WeatherText:

conditions_texte = {
«0»: _ (u »Tornade»),
«1»: _ (u »Tempête tropicale»),
«2»: _ (u »Ouragan»),
«3»: _ (u »Orages violents»),
«4»: _ (u »Orages»),
«5»: _ (u »Pluie et neige mixtes»),
«6»: _ (u »Mélange pluie et grésil»),
«7»: _ (u »Précipitations Mixtes»),
«8»: _ (u »Bruine verglaçante»),
«9»: _ (u »Bruine»),
«10»: _ (u »Pluie verglaçante»),
«11»: _ (u »Douches»),
«12»: _ (u »Douches»),
«13»: _ (u »Averses de neige»),
«14»: _ (u »Légères chutes de neige»),
«15»: _ (u »Poudrerie»),
«16»: _ (u »Neige»),
«17»: _ (u »Salut»),
«18»: _ (u »Sleet»),
«19»: _ (u »Poussière»),
«20»: _ (u »Brouillard»),
«21»: _ (u »Haze»),
«22»: _ (u »Fumée»),
«23»: _ (u »Blustery»),
«24»: _ (u »Venteux»),
«25»: _ (u »Froid»),
«26»: _ (u »Nuageux»),
«27»: _ (u »Nuageux»),
«28»: _ (u »Nuageux»),
«29»: _ (u »Partiellement nuageux»),
«30»: _ (u »Partiellement nuageux»),
«31»: _ (u »Effacer»),
«32»: _ (u »Effacer»),
«33»: _ (u »Juste»),
«34»: _ (u »Juste»),
«35»: _ (u »Pluie et grêle mixtes»),
«36»: _ (u »Chaud»),
«37»: _ (u »Orages isolés»),
«38»: _ (u »Orages épars»),
«39»: _ (u »Orages épars»),
«40»: _ (u »Averses éparses»),
«41»: _ (u »Forte neige»),
«42»: _ (u »Averses de neige éparses»),
«43»: _ (u »Forte neige»),
«44»: _ (u »Partiellement nuageux»),
«45»: _ (u »Thunder Showers»),
«46»: _ (u »Averses de neige»),
«47»: _ (u »Orages isolés»),
«Na»: _ (u »N / A»),
"-": _(ongle")
}

conditions_text_fr = {
«0»: _ (u »Tornade»),
«1»: _ (u »Tempête tropicale»),
«2»: _ (u »Huracá¡n»),
«3»: _ (u »Fortes tempêtes»),
«4»: _ (u »Tempêtes»),
«5»: _ (u »Pluie et neige mixtes»),
«6»: _ (u »Mélange pluie et grésil»),
«7»: _ (u »Sleet»),
«8»: _ (u »Bruine verglaçante»),
«9»: _ (u »Bruine»),
«10»: _ (u »Pluie verglaçante»), # ou pluie verglaçante
«11»: _ (u »Douches»),
«12»: _ (u »Douches»),
«13»: _ (u »Légère neige»),
«14»: _ (u »Légère neige»),
«15»: _ (u »Snow Blizzard»),
«16»: _ (u »Neige»),
«17»: _ (u »Grêle»),
«18»: _ (u »Sleet»),
«19»: _ (u »Poudre»),
«20»: _ (u »Brouillard»),
«21»: _ (u »Haze»),
«22»: _ (u »Fumée»),
«23»: _ (u »Tempête»),
«24»: _ (u »Venteux»),
«25»: _ (u »Fráo»),
«26»: _ (u »Très nuageux»),
«27»: _ (u »Nuageux»),
«28»: _ (u »Nuageux»),
«29»: _ (u »Partiellement nuageux»),
«30»: _ (u »Partiellement nuageux»),
«31»: _ (u »Effacer»),
«32»: _ (u »Effacer»),
«33»: _ (u »Quelque chose de nuageux»),
«34»: _ (u »Quelque chose de nuageux»),
«35»: _ (u »Pluie avec grêle»),
«36»: _ (u »Chaleur»),
«37»: _ (u »Tempêtes isolées»),
«38»: _ (u »Tempêtes éparses»),
«39»: _ (u »Tempêtes éparses»),
«40»: _ (u »Averses éparses»),
«41»: _ (u »Forte neige»),
«42»: _ (u »Chutes de neige faibles et éparses»),
«43»: _ (u »Nevada intense»),
«44»: _ (u »Nuages ​​épars»),
«45»: _ (u »Tempêtes»),
«46»: _ (u »Chutes de neige éparses»),
«47»: _ (u »Tempêtes isolées»),
«Na»: _ (u »N / A»),
"-": _(ongle")
}

conditions_text_fr = {
«0»: _ (u »Tornade»),
«1»: _ (u »Tempête Tropicale»),
«2»: _ (ou »Ouragan»),
«3»: _ (ou »Orages Violents»),
«4»: _ (ou »Orageux»),
«5»: _ (u »Pluie et Neige»),
«6»: _ (u »Pluie et Neige Mouillée»),
«7»: _ (u »Variable avec averses»),
«8»: _ (u »Bruine Givrante»),
«9»: _ (u »Bruine»),
«10»: _ (u »Pluie Glacante»),
«11»: _ (u »Averses»),
«12»: _ (u »Averses»),
«13»: _ (u »Légère Neige»),
«14»: _ (u »Forte Neige»),
«15»: _ (u »Tempête de Neige»),
«16»: _ (u »Neige»),
«17»: _ (u »Grêle»),
«18»: _ (u »Pluie / Neige»),
«19»: _ (u »Nuage de poussière»),
«20»: _ (u »Brouillard»),
«21»: _ (u »Brume»),
«22»: _ (u »Fumée»),
«23»: _ (u »Tres Venteux»),
«24»: _ (u »Venteux»),
«25»: _ (u »Froid»),
«26»: _ (u »Nuageux»),
«27»: _ (u »Tres Nuageux»),
«28»: _ (u »Tres Nuageux»),
«29»: _ (u »Nuages ​​Disséminés»),
«30»: _ (u »Nuages ​​Disséminés»),
«31»: _ (u »Beau»),
«32»: _ (u »Beau»),
«33»: _ (u »Belles Éclaircies»),
«34»: _ (u »Belles Éclaircies»),
«35»: _ (u »Pluie avec Grêle»),
«36»: _ (u »Chaleur»),
«37»: _ (ou »Orages Isolés»),
«38»: _ (ou »Orages Localisés»),
«39»: _ (ou »Orages Localisés»),
«40»: _ (u »Averses Localisées»),
«41»: _ (u »Neige Lourde»),
«42»: _ (u »Tempête de Neige Localisées»),
«43»: _ (u »Neige Lourde»),
«44»: _ (u »Nuages ​​Disséminés»),
«45»: _ (ou »Orages»),
«46»: _ (u »Tempête de Neige»),
«47»: _ (ou »Orages Isolés»),
«Na»: _ (u »N / A»),
"-": _(ongle")
}

conditions_weather_font = {
«0»: _ (u »W»),
«1»: _ (u »V»),
«2»: _ (u »W»),
«3»: _ (u »s»),
«4»: _ (u »p»),
«5»: _ (u »k»),
«6»: _ (u »k»),
«7»: _ (u »g»),
«8»: _ (u »g»),
«9»: _ (u »g»),
«10»: _ (u »h»),
«11»: _ (u »g»),
«12»: _ (u »g»),
«13»: _ (u »k»),
«14»: _ (u »k»),
«15»: _ (u »k»),
«16»: _ (u »k»),
«17»: _ (u »k»),
«18»: _ (u »k»),
«19»: _ (u »e»),
«20»: _ (u »e»),
«21»: _ (u »a»),
«22»: _ (u »d»),
«23»: _ (u »d»),
«24»: _ (u »d»),
«25»: _ (u »d»),
«26»: _ (u »e»),
«27»: _ (u »e»),
«28»: _ (u »e»),
«29»: _ (u »c»),
«30»: _ (u »c»),
«31»: _ (u »a»),
«32»: _ (u »a»),
«33»: _ (u »b»),
«34»: _ (u »b»),
«35»: _ (u »k»),
«36»: _ (u »a»),
«37»: _ (u »f»),
«38»: _ (u »f»),
«39»: _ (u »f»),
«40»: _ (u »g»),
«41»: _ (u »k»),
«42»: _ (u »k»),
«43»: _ (u »k»),
«44»: _ (u »b»),
«45»: _ (u »g»),
«46»: _ (u »k»),
«47»: _ (u »f»),
«Na»: _ (u »»),
"-": _(ou"")
}

conditions_moon_font = {
«0»: _ (u »1 ″),
«1»: _ (u »N»),
«2»: _ (u »O»),
«3»: _ (u »P»),
«4»: _ (u »Q»),
«5»: _ (u »R»),
«6»: _ (u »S»),
«7»: _ (u »T»),
«8»: _ (u »U»),
«9»: _ (u »V»),
«10»: _ (u »W»),
«11»: _ (u »X»),
«12»: _ (u »Y»),
«13»: _ (u »Z»),
«14»: _ (u »0 ″),
«15»: _ (u »0 ″),
«16»: _ (u »A»),
«17»: _ (u »B»),
«18»: _ (u »C»),
«19»: _ (u »D»),
«20»: _ (u »E»),
«21»: _ (u »F»),
«22»: _ (u »G»),
«23»: _ (u »H»),
«24»: _ (u »I»),
«25»: _ (u »J»),
«26»: _ (u »K»),
«27»: _ (u »L»),
«28»: _ (u »M»),
«29»: _ (u »1 ″),
«Na»: _ (u »»),
"-": _(ou"")
}

jour_de_semaine = {
"Aujourd'hui": _ (ou "Aujourd'hui"),
«Lundi»: _ (u »Lundi»),
«Mardi»: _ (u »mardi»),
«Mercredi»: _ (u »mercredi»),
«Jeudi»: _ (u »jeudi»),
«Vendredi»: _ (u »vendredi»),
"Samedi": _ (u "samedi"),
"Dimanche": _ (u "Dimanche")
}

jour_de_semaine_short = {
"Aujourd'hui": _ (u "Maintenant"),
«Lundi»: _ (u »Lun»),
«Mardi»: _ (u »mar»),
«Mercredi»: _ (u »Mer»),
«Jeudi»: _ (u »Jeu»),
«Vendredi»: _ (u »Ven»),
"Samedi": _ (u "Sam"),
"Dimanche": _ (u "Sun")
}

jour_de_la_semaine_es = {
"Aujourd'hui": _ (u "aujourd'hui"),
«Lundi»: _ (u »Lundi»),
«Mardi»: _ (ou »mardi»),
«Mercredi»: _ (u »mercredi»),
«Jeudi»: _ (u »jeudi»),
«Vendredi»: _ (u »vendredi»),
"Samedi": _ (u "samedi"),
"Dimanche": _ (u "Dimanche")
}

day_of_week_short_fr = {
"Aujourd'hui": _ (u "aujourd'hui"),
"Lundi": _ (u "mon"),
«Mardi»: _ (u »mer»),
«Mercredi»: _ (u »mer»),
«Jeudi»: _ (u »jeudi»),
«Vendredi»: _ (u »ven»),
"Samedi": _ (u "sam"),
"Dimanche": _ (u "dom")
}

jour_de_la_semaine_fr = {
«Aujourd'hui»: _ (u »Aujourd'hui»),
«Lundi»: _ (u »Lundi»),
«Mardi»: _ (u »Mardi»),
«Mercredi»: _ (u »Mercredi»),
«Jeudi»: _ (u »Jeudi»),
«Vendredi»: _ (u »Vendredi»),
"Samedi": _ (u "Samedi"),
"Dimanche": _ (u "Dimanche")
}

jour_de_semaine_short_fr = {
«Aujourd'hui»: _ (u »Auj»),
"Lundi": _ (u "Mon"),
«Mardi»: _ (u »mars»),
"Mercredi": _ (u "Mer"),
«Jeudi»: _ (u »Jeu»),
«Vendredi»: _ (u »Viens»),
"Samedi": _ (u "Sam"),
"Dimanche": _ (u "Dim")
}

roulement_arrow_font = {
«N»: _ (u »i»),
«NNE»: _ (u »j»),
«NE»: _ (u »k»),
«ENE»: _ (u »l»),
«E»: _ (u »m»),
«ESE»: _ (u »n»),
"SE": _ (u "o"),
«SSE»: _ (u »p»),
«S»: _ (u »a»),
«SSW»: _ (u »b»),
«SW»: _ (u »c»),
"WSW": _ (u "d"),
«W»: _ (u »e»),
"WNW": _ (u "f"),
«NW»: _ (u »g»),
«NNW»: _ (u »h»),
«N / A»: _ (u »«)
}

portant_text_es = {
«N»: _ (u »N»),
«NNE»: _ (u »NNE»),
«NE»: _ (u »NE»),
«ENE»: _ (u »ENE»),
«E»: _ (u »E»),
«ESE»: _ (u »ESE»),
«SE»: _ (u »SE»),
"SSE": _ (u "SSE"),
"Leur"),
"SSW": _ (u "SSO"),
«SW»: _ (u »SO»),
"WSW": _ (u "WOW"),
«W»: _ (u »O»),
«WNW»: _ (u »ONO»),
«NW»: _ (u »NON»),
«NNW»: _ (u »NNO»),
«N / A»: _ (u »N \ A»)
}

roulement_text_fr = {
«N»: _ (u »N»),
«NNE»: _ (u »NNE»),
«NE»: _ (u »NE»),
«ENE»: _ (u »ENE»),
«E»: _ (u »E»),
«ESE»: _ (u »ESE»),
«SE»: _ (u »SE»),
"SSE": _ (u "SSE"),
"Leur"),
"SSW": _ (u "SSO"),
«SW»: _ (u »SO»),
"WSW": _ (u "WOW"),
«W»: _ (u »O»),
«WNW»: _ (u »ONO»),
«NW»: _ (u »NON»),
«NNW»: _ (u »NNO»),
«N / A»: _ (u »N \ A»)
}

classe GlobalWeather:

conditions_courantes = []
jour_prévision = []
prévision_nuit = []

locale = "in"

options = Aucune
météoxmldoc = « »

TEMP_FILEPATH_CURRENT = "/tmp/conkyForecast-c-LOCATION.pkl"
TEMP_FILEPATH_DAYFORECAST = "/tmp/conkyForecast-df-LOCATION.pkl"
TEMP_FILEPATH_NIGHTFORECAST = "/tmp/conkyForecast-nf-LOCATION.pkl"
EXPIRY_MINUTES = 30
DEFAULT_SPACING = u »«

def __init __ (soi, options):

self.options = options

si self.options.locale == Aucun:
Essai:
# self.locale = locale.getdefaultlocale () [0] [0: 2]
self.locale = «es» # décommentez cette ligne pour forcer la langue espagnole
# self.locale = "fr" # décommentez cette ligne pour forcer la langue française
sauf:
print "locale non définie"
autre:
# self.locale = self.options.locale
self.locale = «es» # décommentez cette ligne pour forcer la langue espagnole
# self.locale = "fr" # décommentez cette ligne pour forcer la langue française

si self.options.verbose == True:
print >> sys.stdout, "locale définie sur", self.locale

def getText (self, nodelist):
rc = « »
pour le nœud dans la liste de nœuds:
si node.nodeType == node.TEXT_NODE:
rc = rc + noeud.data
retour rc

def getSpaces (self, espaces):
chaîne = u »»
si espaces == Aucun:
chaîne = self.DEFAULT_SPACING
autre:
pour i dans la plage (0, espaces + 1):
chaîne = chaîne + u »«
chaîne de retour

def isNumeric (soi, chaîne):
Essai:
dummy = float (chaîne)
retourne True
sauf:
retourne False

def isConnectionAvailable (self):
# nous assurer que nous pouvons accéder au serveur de weather.com en ouvrant l'URL
Essai:
Usock = urllib2.urlopen ('http://xoap.weather.com')
Usock.close ()
retourne True
sauf:
retourne False

def getBearingText (soi, roulement):
roulement = flotteur (roulement)
si relèvement <11.25:
retourne u »N»
palier elif <33.75:
revenir u »NNE»
palier elif <56.25:
retourne u »NE»
palier elif <78.75:
revenir u »JAN»
palier elif <101.25:
retourne u »E»
palier elif <123.75:
retour u »ESE»
palier elif <146.25:
retour u »SE»
palier elif <168.75:
retour u »SSE»
palier elif <191.25:
retourne u »S»
palier elif <213.75:
retour u »SSW»
palier elif <236.25:
retour u »SW»
palier elif <258.75:
retour u »WSW»
palier elif <281.25:
retourne u »W»
palier elif <303.75:
revenir u »WNW»
palier elif <326.25:
retour u »NW»
palier elif <348.75:
retour u »NNW»
autre:
retour «N / A»

def convertCelsiusToFahrenheit (self, temp):
return str (int (floor (((float (temp) * 9.0) /5.0) +32)))

def convertKilometresToMiles (self, dist):
return str (int (floor (float (dist) * 0.621371192)))

def convertMillibarsToInches (soi, mb):
return str (int (plancher (flottant (mb) /33.8582)))

def getTemplateList (soi, modèle):

liste de modèles = []

pour template_part dans template.split («{«):
si template_part! = «»:
pour template_part dans template_part.split ("}"):
si template_part! = «»:
templatelist.append (u »» + template_part)

retourner la liste des modèles

def getOutputText (self, type de données, startday, endday, night, shortweekday, impérial, masques, espaces):
#essayer:
sortie = u »»

# définir les unités de courant pour la sortie
si hideunits == False:
si impérial == Faux:
tempunit = u »° C»
speedunit = u »km / h»
pressureunit = u »mb»
autre:
tempunit = u »° F»
speedunit = u »mph»
pressureunit = u »dans»
autre:
tempunit = u »°»
speedunit = u »»
pressureunit = u »»

if startday == None: # conditions actuelles

si type de données == "DW":
si self.locale == "est":
si shortweekday == Vrai:
output = WeatherText.day_of_week_short_es [self.current_conditions [0] .day_of_week]
autre:
output = WeatherText.day_of_week_es [self.current_conditions [0] .day_of_week]
elif self.locale == "fr":
si shortweekday == Vrai:
output = WeatherText.day_of_week_short_fr [self.current_conditions [0] .day_of_week]
autre:
output = WeatherText.day_of_week_fr [self.current_conditions [0] .day_of_week]
autre:
si shortweekday == Vrai:
output = WeatherText.day_of_week_short [self.current_conditions [0] .day_of_week]
autre:
output = WeatherText.day_of_week [self.current_conditions [0] .day_of_week]
elif datatype == "WF": # police météo
output = WeatherText.conditions_weather_font [self.current_conditions [0] .condition_code]
elif datatype == "LT":
string = self.current_conditions [0] .low
si self.isNumeric (string) == True:
si impérial == Vrai:
string = self.convertCelsiusToFahrenheit (chaîne)
chaîne = chaîne + unité temporaire
sortie = chaîne
elif datatype == "HT":
string = self.current_conditions [0] .high
si self.isNumeric (string) == True:
si impérial == Vrai:
string = self.convertCelsiusToFahrenheit (chaîne)
chaîne = chaîne + unité temporaire
sortie = chaîne
elif datatype == "CC":
si self.locale == "est":
output = WeatherText.conditions_text_es [self.current_conditions [0] .condition_code]
elif self.locale == "fr":
output = WeatherText.conditions_text_fr [self.current_conditions [0] .condition_code]
autre:
output = WeatherText.conditions_text [self.current_conditions [0] .condition_code]
elif datatype == "CT":
output = self.current_conditions [0] .condition_text
elif datatype == "PC":
string = self.current_conditions [0] .precip
si self.isNumeric (string) == True:
chaîne = chaîne + u »%»
sortie = chaîne
elif datatype == "HM":
string = self.current_conditions [0] .humidity
si self.isNumeric (string) == True:
chaîne = chaîne + u »%»
sortie = chaîne
elif datatype == "WD":
string = self.current_conditions [0] .wind_dir
si self.isNumeric (string) == True:
string = self.getBearingText (chaîne)

si self.locale == "est":
output = WeatherText.bearing_text_es [chaîne]
elif self.locale == "fr":
output = WeatherText.bearing_text_fr [chaîne]
autre:
sortie = chaîne

elif datatype == "BF":
string = self.current_conditions [0] .wind_dir
si self.isNumeric (string) == True:
string = WeatherText.bearing_arrow_font [self.getBearingText (chaîne)]
sortie = chaîne
elif datatype == "WS":
string = self.current_conditions [0] .wind_speed
si self.isNumeric (string) == True:
si impérial == Vrai:
string = self.convertKilometresToMiles (chaîne)
chaîne = chaîne + unité de vitesse
sortie = chaîne
elif datatype == "WG":
string = self.current_conditions [0] .wind_gusts
si self.isNumeric (string) == True:
si impérial == Vrai:
string = self.convertKilometresToMiles (chaîne)
chaîne = chaîne + unité de vitesse
sortie = chaîne
elif datatype == "CN":
output = self.current_conditions [0] .city
elif datatype == "SR":
output = self.current_conditions [0] .sunrise
elif datatype == "SS":
output = self.current_conditions [0] .sunset
type de données elif == "MP":
output = self.current_conditions [0] .moon_phase
type de données elif == "MF":
output = WeatherText.conditions_moon_font [self.current_conditions [0] .moon_icon]
elif datatype == "BR":
string = self.current_conditions [0] .bar_read
si self.isNumeric (string) == True:
si impérial == Vrai:
string = self.convertMillibarsToInches (chaîne)
chaîne = chaîne + unité de pression
sortie = chaîne
elif datatype == "BD":
output = self.current_conditions [0] .bar_desc
autre:
output = "\ nERREUR: type de données inconnu demandé"

else: # données de prévision

if endday == None: # si aucun endday n'a été défini, utilisez startday
endday = jour de début

if night == True: # prévision de nuit requise

pour day_number dans la plage (startday, endday + 1):

si type de données == "DW":
si self.locale == "est":
si shortweekday == Vrai:
sortie = sortie + self.getSpaces (espaces) + WeatherText.day_of_week_short_es [self.night_forecast [day_number] .day_of_week]
autre:
sortie = sortie + self.getSpaces (espaces) + WeatherText.day_of_week_es [self.night_forecast [day_number] .day_of_week]
elif self.locale == "fr":
si shortweekday == Vrai:
sortie = sortie + self.getSpaces (espaces) + WeatherText.day_of_week_short_fr [self.night_forecast [day_number] .day_of_week]
autre:
sortie = sortie + self.getSpaces (espaces) + WeatherText.day_of_week_fr [self.night_forecast [day_number] .day_of_week]
autre:
si shortweekday == Vrai:
sortie = sortie + self.getSpaces (espaces) + WeatherText.day_of_week_short [self.night_forecast [day_number] .day_of_week]
autre:
sortie = sortie + self.getSpaces (espaces) + WeatherText.day_of_week [self.night_forecast [day_number] .day_of_week]
elif datatype == "WF": # police météo
sortie = sortie + self.getSpaces (espaces) + WeatherText.conditions_weather_font [self.night_forecast [day_number] .condition_code]
elif datatype == "LT":
string = self.night_forecast [numéro_jour] .low
si self.isNumeric (string) == True:
si impérial == Vrai:
string = self.convertCelsiusToFahrenheit (chaîne)
chaîne = chaîne + unité temporaire
sortie = sortie + self.getSpaces (espaces) + chaîne

elif datatype == "HT":
string = self.night_forecast [day_number] .high
si self.isNumeric (string) == True:
si impérial == Vrai:
string = self.convertCelsiusToFahrenheit (chaîne)
chaîne = chaîne + unité temporaire
sortie = sortie + self.getSpaces (espaces) + chaîne
elif datatype == "CC":
si self.locale == "est":
sortie = sortie + self.getSpaces (espaces) + WeatherText.conditions_text_es [self.night_forecast [day_number] .condition_code]
elif self.locale == "fr":
sortie = sortie + self.getSpaces (espaces) + WeatherText.conditions_text_fr [self.night_forecast [day_number] .condition_code]
autre:
sortie = sortie + self.getSpaces (espaces) + WeatherText.conditions_text [self.night_forecast [day_number] .condition_code]
elif datatype == "CT":
sortie = sortie + self.getSpaces (espaces) + self.night_forecast [numéro_jour] .condition_text
elif datatype == "PC":
string = self.night_forecast [numéro_jour] .precip
si self.isNumeric (string) == True:
chaîne = chaîne + u »%»
sortie = sortie + self.getSpaces (espaces) + chaîne
elif datatype == "HM":
string = self.night_forecast [day_number] .humidity
si self.isNumeric (string) == True:
chaîne = chaîne + u »%»
sortie = sortie + self.getSpaces (espaces) + chaîne
elif datatype == "WD":
string = self.night_forecast [day_number] .wind_dir
si self.locale == "est":
sortie = sortie + self.getSpaces (espaces) + WeatherText.bearing_text_es [chaîne]
elif self.locale == "fr":
sortie = sortie + self.getSpaces (espaces) + WeatherText.bearing_text_fr [chaîne]
autre:
sortie = sortie + self.getSpaces (espaces) + chaîne

elif datatype == "BF":
sortie = sortie + self.getSpaces (espaces) + WeatherText.bearing_arrow_font [self.night_forecast [day_number] .wind_dir]
elif datatype == "WS":
string = self.night_forecast [day_number] .wind_speed
si self.isNumeric (string) == True:
si impérial == Vrai:
string = self.convertKilometresToMiles (chaîne)
chaîne = chaîne + unité de vitesse
sortie = sortie + self.getSpaces (espaces) + chaîne
elif datatype == "WG":
string = self.night_forecast [day_number] .wind_gusts
si self.isNumeric (string) == True:
si impérial == Vrai:
string = self.convertKilometresToMiles (chaîne)
chaîne = chaîne + unité de vitesse
sortie = sortie + self.getSpaces (espaces) + chaîne
elif datatype == "CN":
sortie = sortie + self.getSpaces (espaces) + self.night_forecast [numéro_jour] .city
elif datatype == "SR":
sortie = sortie + self.getSpaces (espaces) + self.night_forecast [numéro_jour] .sunrise
elif datatype == "SS":
sortie = sortie + self.getSpaces (espaces) + self.night_forecast [day_number] .sunset
type de données elif == "MP":
sortie = sortie + self.getSpaces (espaces) + self.night_forecast [day_number] .moon_phase
type de données elif == "MF":
sortie = sortie + self.getSpaces (espaces) + WeatherText.conditions_moon_font [self.night_forecast [day_number] .moon_icon]
elif datatype == "BR":
sortie = sortie + self.getSpaces (espaces) + self.night_forecast [numéro_jour] .bar_read
elif datatype == "BD":
sortie = sortie + self.getSpaces (espaces) + self.night_forecast [numéro_jour] .bar_desc
autre:
output = "\ nERREUR: type de données inconnu demandé"
pause

sinon: prévision de # jour recherchée

pour day_number dans la plage (startday, endday + 1):

si type de données == "DW":
si self.locale == "est":
si shortweekday == Vrai:
sortie = sortie + self.getSpaces (espaces) + WeatherText.day_of_week_short_es [self.day_forecast [day_number] .day_of_week]
autre:
sortie = sortie + self.getSpaces (espaces) + WeatherText.day_of_week_es [self.day_forecast [day_number] .day_of_week]
elif self.locale == "fr":
si shortweekday == Vrai:
sortie = sortie + self.getSpaces (espaces) + WeatherText.day_of_week_short_fr [self.day_forecast [day_number] .day_of_week]
autre:
sortie = sortie + self.getSpaces (espaces) + WeatherText.day_of_week_fr [self.day_forecast [day_number] .day_of_week]
autre:
si shortweekday == Vrai:
sortie = sortie + self.getSpaces (espaces) + WeatherText.day_of_week_short [self.day_forecast [day_number] .day_of_week]
autre:
sortie = sortie + self.getSpaces (espaces) + WeatherText.day_of_week [self.day_forecast [day_number] .day_of_week]
elif datatype == "WF": # police météo
sortie = sortie + self.getSpaces (espaces) + WeatherText.conditions_weather_font [self.day_forecast [day_number] .condition_code]
elif datatype == "LT":
string = self.day_forecast [day_number] .low
si self.isNumeric (string) == True:
si impérial == Vrai:
string = self.convertCelsiusToFahrenheit (chaîne)
chaîne = chaîne + unité temporaire
sortie = sortie + self.getSpaces (espaces) + chaîne
elif datatype == "HT":
string = self.day_forecast [day_number] .high
si self.isNumeric (string) == True:
si impérial == Vrai:
string = self.convertCelsiusToFahrenheit (chaîne)
chaîne = chaîne + unité temporaire
sortie = sortie + self.getSpaces (espaces) + chaîne
elif datatype == "CC":
si self.locale == "est":
sortie = sortie + self.getSpaces (espaces) + WeatherText.conditions_text_es [self.day_forecast [day_number] .condition_code]
elif self.locale == "fr":
sortie = sortie + self.getSpaces (espaces) + WeatherText.conditions_text_fr [self.day_forecast [day_number] .condition_code]
autre:
sortie = sortie + self.getSpaces (espaces) + WeatherText.conditions_text [self.day_forecast [day_number] .condition_code]
elif datatype == "CT":
sortie = sortie + self.getSpaces (espaces) + self.day_forecast [numéro_jour] .condition_text
elif datatype == "PC":
string = self.day_forecast [day_number] .precip
si self.isNumeric (string) == True:
chaîne = chaîne + u »%»
sortie = sortie + self.getSpaces (espaces) + chaîne
elif datatype == "HM":
string = self.day_forecast [day_number] .humidity
si self.isNumeric (string) == True:
chaîne = chaîne + u »%»
sortie = sortie + self.getSpaces (espaces) + chaîne
elif datatype == "WD":
string = self.day_forecast [day_number] .wind_dir

si self.locale == "est":
sortie = sortie + self.getSpaces (espaces) + WeatherText.bearing_text_es [chaîne]
elif self.locale == "fr":
sortie = sortie + self.getSpaces (espaces) + WeatherText.bearing_text_fr [chaîne]
autre:
sortie = sortie + self.getSpaces (espaces) + chaîne

elif datatype == "BF":
sortie = sortie + self.getSpaces (espaces) + WeatherText.bearing_arrow_font [self.day_forecast [day_number] .wind_dir]
elif datatype == "WS":
string = self.day_forecast [day_number] .wind_speed
si self.isNumeric (string) == True:
si impérial == Vrai:
string = self.convertKilometresToMiles (chaîne)
chaîne = chaîne + unité de vitesse
sortie = sortie + self.getSpaces (espaces) + chaîne
elif datatype == "WG":
string = self.day_forecast [day_number] .wind_gusts
si self.isNumeric (string) == True:
si impérial == Vrai:
string = self.convertKilometresToMiles (chaîne)
chaîne = chaîne + unité de vitesse
sortie = sortie + self.getSpaces (espaces) + chaîne
elif datatype == "CN":
sortie = sortie + self.getSpaces (espaces) + self.day_forecast [day_number] .city
elif datatype == "SR":
sortie = sortie + self.getSpaces (espaces) + self.day_forecast [day_number] .sunrise
elif datatype == "SS":
sortie = sortie + self.getSpaces (espaces) + self.day_forecast [day_number] .sunset
type de données elif == "MP":
sortie = sortie + self.getSpaces (espaces) + self.day_forecast [day_number] .moon_phase
type de données elif == "MF":
sortie = sortie + self.getSpaces (espaces) + WeatherText.conditions_moon_font [self.day_forecast [day_number] .moon_icon]
elif datatype == "BR":
sortie = sortie + self.getSpaces (espaces) + self.day_forecast [day_number] .bar_read
elif datatype == "BD":
sortie = sortie + self.getSpaces (espaces) + self.day_forecast [numéro_jour] .bar_desc
autre:
output = u »\ nERREUR: type de données inconnu demandé»
pause

output = u »» + output.strip (u »«) # perd les espaces de début / de fin
sortie de retour

#sauf:
#print "getOutputText: Erreur inattendue:", sys.exc_info () [0]

def getOutputTextFromTemplate (soi, modèle):
#essayer:

# clés pour les données de modèle
DATATYPE_KEY = "–datatype ="
STARTDAY_KEY = "–startday ="
ENDDAY_KEY = "–endday ="
NIGHT_KEY = "–night"
SHORTWEEKDAY_KEY = "–shortweekday"
IMPERIAL_KEY = "–imperial"
HIDEUNITS_KEY = "–hideunits"
SPACES_KEY = "–spaces ="

sortie = u »»

optionfound = Faux

# télécharger le fichier
Essai:
fileinput = ouvert (self.options.template)
template = fileinput.read ()
fileinput.close ()
sauf:
output = u »Fichier modèle introuvable!»

templatelist = self.getTemplateList (modèle)

# permet de parcourir la liste des modèles et de déterminer la sortie pour chaque élément trouvé
pour i dans la plage (0, len (templatelist) -1):

pos = liste de modèles [i] .find (DATATYPE_KEY)
si pos! = -1:
optionfound = Vrai
pos = pos + len (DATATYPE_KEY)
datatype = templatelist [i] [pos: pos + 4] .strip («}»). strip («{«). strip («-«). strip (»«)
autre:
datatype = Aucun

pos = liste de modèles [i] .find (STARTDAY_KEY)
si pos! = -1:
optionfound = Vrai
pos = pos + len (STARTDAY_KEY)
startday = int (liste de modèles [i] [pos: pos + 4] .strip ("}"). strip ("{"). strip ("-"). strip (""))
autre:
startday = Aucun

pos = liste de modèles [i] .find (ENDDAY_KEY)
si pos! = -1:
optionfound = Vrai
pos = pos + len (ENDDAY_KEY)
endday = int (liste de modèles [i] [pos: pos + 4] .strip ("}"). strip ("{"). strip ("-"). strip (""))
autre:
endday = Aucun

pos = liste de modèles [i] .find (NIGHT_KEY)
si pos! = -1:
optionfound = Vrai
nuit = Vrai
autre:
nuit = Faux

pos = liste de modèles [i] .find (SHORTWEEKDAY_KEY)
si pos! = -1:
optionfound = Vrai
shortweekday = Vrai
autre:
shortweekday = Faux

pos = liste de modèles [i] .find (IMPERIAL_KEY)
si pos! = -1:
optionfound = Vrai
impérial = Vrai
autre:
impérial = Faux

pos = liste de modèles [i] .find (HIDEUNITS_KEY)
si pos! = -1:
optionfound = Vrai
hideunits = Vrai
autre:
hideunits = Faux

pos = liste de modèles [i] .find (SPACES_KEY)
si pos! = -1:
optionfound = Vrai
pos = pos + len (SPACES_KEY)
espaces = int (liste de modèles [i] [pos: pos + 4] .strip («}»). strip («{«). strip («-«). strip (»«))
autre:
espaces = 1

si option trouvée == Vrai:
templatelist [i] = self.getOutputText (type de données, startday, endday, night, shortweekday, impérial, masques, espaces)
optionfound = Faux

# parcourir la liste concaténant la sortie maintenant qu'elle a été remplie
pour l'élément dans la liste de modèles:
sortie = sortie + élément

sortie de retour

#sauf:
#print "getOutputTextFromTemplate: Erreur inattendue:", sys.exc_info () [0]

def fetchData (soi):

# récupère toujours les données métriques, utilise les fonctions de conversation sur ces données
file_path_current = self.TEMP_FILEPATH_CURRENT.replace ("LOCATION", self.options.location)
file_path_dayforecast = self.TEMP_FILEPATH_DAYFORECAST.replace ("LOCATION", self.options.location)
file_path_nightforecast = self.TEMP_FILEPATH_NIGHTFORECAST.replace ("LOCATION", self.options.location)

si self.isConnectionAvailable () == False:
si os.path.exists (file_path_current):
Récupérer les données = False
sinon: # pas de connexion, pas de cache, bang!
print "Aucune connexion Internet n'est disponible et aucune donnée météo mise en cache n'existe."
elif self.options.refetch == Vrai:
RefetchData = Vrai
autre:
# les données doivent-elles être récupérées à nouveau?
si os.path.exists (file_path_current):
lastmodDate = time.localtime (os.stat (chemin_fichier_actuel) [ST_MTIME])
expiryDate = (datetime.datetime.today () - datetime.timedelta (minutes = self.EXPIRY_MINUTES)). timesuple ()

if expiryDate> lastmodDate:
RefetchData = Vrai
autre:
Récupérer les données = False
autre:
RefetchData = Vrai

# récupérer les données des conditions actuelles, soit à partir du site Web, soit en "décrochement"
si RefetchData == True:

# obtenir des données sur les conditions actuelles du service xoap
Essai:

# http://xoap.weather.com/weather/local/UKXX0103?cc=*&dayf=5&link=xoap∏=xoap&par=1061785028&key=e374effbfd74930b

url = 'http://xoap.weather.com/weather/local/' + self.options.location + '? cc = * & dayf = 8 & link = xoap∏ = xoap & par = 1061785028 & key = e374effbfd74930b & unité = m '
si self.options.verbose == True:
print >> sys.stdout, «récupération des données météo de«, url

Usock = urllib2.urlopen (url)
xml = usock.read ()
Usock.close ()
self.weatherxmldoc = minidom.parseString (xml)
sauf:
print "fetchData: Erreur inattendue:", sys.exc_info () [0]
print "Impossible de contacter la source météo pour les conditions actuelles"

# dire à l'utilisateur si l'emplacement est mauvais…
found = xml.find ("Emplacement non valide fourni")
si trouvé! = -1:
print "Emplacement non valide fourni"

# interroger les données météorologiques, les charger dans la structure de la classe et les décaper
Essai:

# préparer des listes de données météorologiques
self.current_conditions = []
self.day_forecast = []
self.night_forecast = []

# collecter des données générales
météo_n = self.weatherxmldoc.documentElement
location_n = weather_n.getElementsByTagName ('loc') [0]
city_n = location_n.getElementsByTagName ('dnam') [0]
city ​​= self.getText (city_n.childNodes)

# collecter des données sur les conditions actuelles
day_of_week = u »Aujourd'hui»
précip = u »N / A»
sunrise_n = location_n.getElementsByTagName ('sunr') [0]
sunrise = self.getText (sunrise_n.childNodes)
sunset_n = location_n.getElementsByTagName ('soleils') [0]
sunset = self.getText (sunset_n.childNodes)
current_condition_n = weather_n.getElementsByTagName ('cc') [0]
current_desc_n = current_condition_n.getElementsByTagName ('t') [0]
current_desc = self.getText (current_desc_n.childNodes)
current_code_n = current_condition_n.getElementsByTagName ('icône') [0]
current_code = self.getText (current_code_n.childNodes)
current_temp_n = current_condition_n.getElementsByTagName ('tmp') [0]
current_temp = self.getText (current_temp_n.childNodes)
current_temp_feels_n = current_condition_n.getElementsByTagName ('flik') [0]
current_temp_feels = self.getText (current_temp_feels_n.childNodes)
bar_n = current_condition_n.getElementsByTagName ('bar') [0]
bar_read_n = bar_n.getElementsByTagName ('r') [0]
bar_read = self.getText (bar_read_n.childNodes)
bar_desc_n = bar_n.getElementsByTagName ('d') [0]
bar_desc = self.getText (bar_desc_n.childNodes)
wind_n = current_condition_n.getElementsByTagName ('vent') [0]
wind_speed_n = wind_n.getElementsByTagName ('s') [0]
wind_speed = self.getText (wind_speed_n.childNodes)
wind_gust_n = wind_n.getElementsByTagName ('rafale') [0]
wind_gusts = self.getText (wind_gust_n.childNodes)
wind_dir_n = wind_n.getElementsByTagName ('d') [0]
wind_direction = self.getText (wind_dir_n.childNodes)
humidité_n = current_condition_n.getElementsByTagName ('hmid') [0]
humidité = self.getText (humidité_n.childNodes)
moon_n = current_condition_n.getElementsByTagName ('moon') [0]
moon_icon_n = moon_n.getElementsByTagName ('icône') [0]
moon_icon = self.getText (moon_icon_n.childNodes)
moon_phase_n = moon_n.getElementsByTagName ('t') [0]
moon_phase = self.getText (moon_phase_n.childNodes)
current_conditions_data = WeatherData (day_of_week, current_temp_feels, current_temp, current_code, current_desc, précip, humidité, direction du vent, vitesse du vent, vent_gusts, ville, lever du soleil, coucher de soleil, lune_phase, moon_icon, bar_read, bar_desc)
self.current_conditions.append (current_conditions_data)

# collecter des données de prévision
bar_read = u »S / O»
bar_desc = u »S / O»
moon_phase = u »S / O»
moon_icon = u »na»
prévisions_n = weather_n.getElementsByTagName ('dayf') [0]
day_nodes = prévisions_n.getElementsByTagName ('jour')

pour day in day_nodes:
day_of_week = day.getAttribute ('t')
day_of_year = day.getAttribute ('dt')
high_temp_n = day.getElementsByTagName ('salut') [0]
high_temp = self.getText (high_temp_n.childNodes)
low_temp_n = day.getElementsByTagName ('faible') [0]
low_temp = self.getText (low_temp_n.childNodes)

sunrise_n = day.getElementsByTagName ('sunr') [0]
sunrise = self.getText (sunrise_n.childNodes)
sunset_n = day.getElementsByTagName ('soleils') [0]
sunset = self.getText (sunset_n.childNodes)

# jour de données spécifiques aux prévisions
daytime_n = day.getElementsByTagName ('part') [0] # jour
condition_code_n = daytime_n.getElementsByTagName ('icône') [0]
condition_code = self.getText (condition_code_n.childNodes)
condition_n = daytime_n.getElementsByTagName ('t') [0]
condition = self.getText (condition_n.childNodes)
précip_n = daytime_n.getElementsByTagName ('ppcp') [0]
précip = self.getText (precip_n.childNodes)
humidité_n = daytime_n.getElementsByTagName ('hmid') [0]
humidité = self.getText (humidité_n.childNodes)
wind_n = daytime_n.getElementsByTagName ('vent') [0]
wind_speed_n = wind_n.getElementsByTagName ('s') [0]
wind_speed = self.getText (wind_speed_n.childNodes)
wind_direction_n = wind_n.getElementsByTagName ('t') [0]
wind_direction = self.getText (wind_direction_n.childNodes)
wind_gusts_n = wind_n.getElementsByTagName ('rafale') [0]
wind_gusts = self.getText (wind_gusts_n.childNodes)
day_forecast_data = WeatherData (day_of_week, low_temp, high_temp, condition_code, condition, précip, humidité, direction du vent, vitesse du vent, vent_gusts, ville, lever, coucher de soleil, lune_phase, moon_icon, bar_read, bar_desc)
self.day_forecast.append (day_forecast_data)

# données spécifiques aux prévisions nocturnes
daytime_n = day.getElementsByTagName ('part') [1] # nuit
condition_code_n = daytime_n.getElementsByTagName ('icône') [0]
condition_code = self.getText (condition_code_n.childNodes)
condition_n = daytime_n.getElementsByTagName ('t') [0]
condition = self.getText (condition_n.childNodes)
précip_n = daytime_n.getElementsByTagName ('ppcp') [0]
précip = self.getText (precip_n.childNodes)
humidité_n = daytime_n.getElementsByTagName ('hmid') [0]
humidité = self.getText (humidité_n.childNodes)
wind_n = daytime_n.getElementsByTagName ('vent') [0]
wind_speed_n = wind_n.getElementsByTagName ('s') [0]
wind_speed = self.getText (wind_speed_n.childNodes)
wind_direction_n = wind_n.getElementsByTagName ('t') [0]
wind_direction = self.getText (wind_direction_n.childNodes)
wind_gusts_n = wind_n.getElementsByTagName ('rafale') [0]
wind_gusts = self.getText (wind_gusts_n.childNodes)
night_forecast_data = WeatherData (day_of_week, low_temp, high_temp, condition_code, condition, précip, humidité, direction du vent, vitesse du vent, vent_gusts, ville, lever, coucher de soleil, lune_phase, moon_icon, bar_read, bar_desc)
self.night_forecast.append (night_forecast_data)

# ramassez les données pour la prochaine fois!
fileoutput = open (file_path_current, 'w')
pickle.dump (self.current_conditions, fileoutput)
fileoutput.close ()

fileoutput = open (chemin_fichier_dayforecast, 'w')
pickle.dump (self.day_forecast, sortie de fichier)
fileoutput.close ()

fileoutput = open (chemin_fichier_nightforecast, 'w')
pickle.dump (self.night_forecast, sortie de fichier)
fileoutput.close ()

sauf:
print "fetchData: Erreur inattendue:", sys.exc_info () [0]
print "Impossible d'interroger les données météorologiques"

else: # récupère les données météorologiques à partir de fichiers de classe décapés
si self.options.verbose == True:
print >> sys.stdout, «récupération des données météo du fichier:«, file_path_current

fileinput = open (file_path_current, 'r')
self.current_conditions = pickle.load (entrée de fichier)
fileinput.close ()

si self.options.verbose == True:
print >> sys.stdout, "récupération des données de prévision du jour à partir de fichiers:", file_path_dayforecast, file_path_nightforecast

fileinput = open (chemin_fichier_jourforecast, 'r')
self.day_forecast = pickle.load (entrée de fichier)
fileinput.close ()

si self.options.verbose == True:
print >> sys.stdout, «récupération des données de prévision du jour à partir de fichiers:«, file_path_nightforecast, file_path_nightforecast

fileinput = open (chemin_fichier_nightforecast, 'r')
self.night_forecast = pickle.load (entrée de fichier)
fileinput.close ()

def outputData (soi):
#essayer:

if self.options.template! = Aucun:

sortie = self.getOutputTextFromTemplate (self.options.template)

autre:

output = self.getOutputText (self.options.datatype, self.options.startday, self.options.endday, self.options.night, self.options.shortweekday, self.options.imperial, self.options.hideunits, self. options.spaces)

print output.encode ("utf-8")

#sauf:
#print "outputData: Erreur inattendue:", sys.exc_info () [0]

si __name__ == "__main__":

analyseur = CommandLineParser ()
(options, arguments) = parser.parse_args ()

si options.verbose == True:
print >> sys.stdout, "location:", options.location
print >> sys.stdout, "impérial:", options.imperial
print >> sys.stdout, "datatype:", options.datatype
print >> sys.stdout, "night:", options.night
print >> sys.stdout, "jour de début:", options.startday
print >> sys.stdout, "end day:", options.endday
print >> sys.stdout, "espaces:", options.spaces
print >> sys.stdout, "verbose:", options.verbose
print >> sys.stdout, "refetch:", options.refetch

# créer un nouvel objet météo global
weather = GlobalWeather (options)
weather.fetchData ()
weather.outputData ()

Nous créons le fichier ~ / Conky / scripts / myweather.template

gedit ~ / Conky / scripts / myweather.template

nous collons ce qui suit à l'intérieur:

{–Datatype = DW –startday = 1}: {–datatype = CC –startday = 1}
{–Datatype = HT –startday = 1} / {–datatype = LT –startday = 1} Vent de {–datatype = WD –startday = 1} à {–datatype = WS –startday = 1}
Humidité: {–datatype = HM –startday = 1} Précipitations: {–datatype = PC –startday = 1}
Lever du soleil: {–datatype = SR –startday = 1} Coucher du soleil: {–datatype = SS –startday = 1}
----------------
{–Datatype = DW –startday = 2}: {–datatype = CC –startday = 2}
{–Datatype = HT –startday = 2} / {–datatype = LT –startday = 2} Vent de {–datatype = WD –startday = 2} à {–datatype = WS –startday = 2}
Humidité: {–datatype = HM –startday = 2} Précipitations: {–datatype = PC –startday = 2}
Lever du soleil: {–datatype = SR –startday = 2} Coucher du soleil: {–datatype = SS –startday = 2}
----------------
{–Datatype = DW –startday = 3}: {–datatype = CC –startday = 3}
{–Datatype = HT –startday = 3} / {–datatype = LT –startday = 3} Vent de {–datatype = WD –startday = 3} à {–datatype = WS –startday = 3}
Humidité: {–datatype = HM –startday = 3} Précipitations: {–datatype = PC –startday = 3}
Lever du soleil: {–datatype = SR –startday = 3} Coucher du soleil: {–datatype = SS –startday = 3}
----------------
{–Datatype = DW –startday = 4}: {–datatype = CC –startday = 4}
{–Datatype = HT –startday = 4} / {–datatype = LT –startday = 4} Vent de {–datatype = WD –startday = 4} à {–datatype = WS –startday = 4}
Humidité: {–datatype = HM –startday = 4} Précipitations: {–datatype = PC –startday = 4}
Lever du soleil: {–datatype = SR –startday = 4} Coucher du soleil: {–datatype = SS –startday = 4}

Nous créons le fichier ~ / Conky / scripts / mail / conkyEmail.py (nous devons créer le dossier mail)

gedit ~ / Conky / scripts / mail / conkyEmail.py

et collez ce qui suit à l'intérieur:

importer os
chaîne d'importation

# Entrez votre nom d'utilisateur et votre mot de passe ci-dessous entre guillemets
# par exemple. nom d'utilisateur = »nom d'utilisateur» et mot de passe = »mot de passe»
nom d'utilisateur = »VOTRE_USUARIO_SINARROBA«
mot de passe = »TA CLÉ«

com = »wget -O - https: //» + nom d'utilisateur + »:» + mot de passe + »@ mail.google.com / mail / feed / atom –no-check-certificate»

temp = os.popen (com)
msg = lecture de la température ()
index = string.find (msg, » »)
index2 = string.find (msg, » »)
fc = int (msg [index + 11: index2])

si fc == 0:
imprimer "0 nouveau"
autre:
print str (fc) + »nouveau»

Alors maintenant, vous avez 7 fichiers:

Dans le dossier: ~
-> .startconky << - rendre exécutable

Dans le dossier: ~ / Conky
-> conkymain
-> conkyforecast
-> conkymail

et dans le dossier: ~ / Conky / scripts
-> conkyForecast.py << - rendre exécutable
-> myweather.template

et dans le dossier: ~ / Conky / scripts / mail
conkyEmail.py << - rendre exécutable

Et c'est tout, clarifications, où il est dit / home / user / ... votre nom d'utilisateur va et dans la partie où vont les données Gmail, j'ai mis en évidence en couleurs où vous devez mettre vos données.

pour tuer le processus conky, écrivez sur une console

tuer tout conky

pour exécuter conky write sur une console

./.startconky

une fois que vous avez tout réglé, si vous voulez que conky démarre chaque session

Système—> Préférences—> Sessions et dans les programmes de démarrage, nous l'ajoutons

Dans Name, nous pouvons écrire Conky, dans Order ./.startconky avec cela, il démarrera chaque fois que vous allumerez le PC.

Voilà, j'espère que cela vous aidera.


Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont marqués avec *

*

*

  1. Responsable des données: Miguel Ángel Gatón
  2. Finalité des données: Contrôle du SPAM, gestion des commentaires.
  3. Légitimation: votre consentement
  4. Communication des données: Les données ne seront pas communiquées à des tiers sauf obligation légale.
  5. Stockage des données: base de données hébergée par Occentus Networks (EU)
  6. Droits: à tout moment, vous pouvez limiter, récupérer et supprimer vos informations.