Conky, configurarea mea

Ubunlog

Minute 37

Fecfactor mi-a cerut ieri să public configurația conky-ului pe care o afișez în captura de ecran de mai jos

După cum puteți vedea, este vorba de 3 conki, care sunt executate prin intermediul unui script, configurația acestuia se bazează pe acest post postat de utilizatorul Bruce M. în forumurile din Ubuntu-Ar cu unele modificări în conky-ul de e-mail, care în cazul meu este pentru Gmail.

În postarea de referință este foarte bine explicată de Bruce, dar și ca un ajutor de memorie pentru mine, voi copia pașii de urmat și codul conky-urilor mele pentru oricine o are.

Ei bine, desigur, trebuie să avem conky, curl și python instalate, așa că introducem o consolă:

sudo apt-get install conky curl python

Sursa weather.ttf și săgețile.ttf este aici. Sursa lunii.ttf este aici după descărcare, trebuie să le copiați în / usr / share / fonts

Să creăm acum scriptul nostru numit ~. / Startconky

gksudo gedit ~ / .startconky

în fișierul gol lipim următoarele

#! / Bin / bash
dormi 0 și # 0 bun pentru Xfce - folosește 20 până la 30 pentru Gnome
conky -c ~ / Conky / conkymain &
#sleep 0 & # 0 bun pentru Xfce - utilizați 1 pentru Gnome
conky -c ~ / Conky / conkyforecast &
#sleep 0 & # 0 bun pentru Xfce - utilizați 1 pentru Gnome
conky -c ~ / Conky / conkymail &

Acum creăm fișierul conkymain în folderul ~ / Conky, dacă nu avem folderul Conky, va trebui să îl creăm.

gedit ~ / Conky / conkymain

Folosesc fontul Calibri, dacă nu îl aveți, înlocuiți-l cu orice doriți.

Rămânem în interiorul a ceea ce urmează

fundal nr
own_window da
own_window_transparent da
own_window_hints nedecorat, dedesubt, lipicios, skip_taskbar, skip_pager
own_window_colour negru
double_buffer da
use_spacer stânga
use_xft da
font calibri: size = 9
xftfont calibri: size = 9
xftalpha 0.5
update_interval 5.0
majuscule nu # setat la da dacă doriți ca întregul text să fie în majuscule
borduri_punctate 3
border_margin 9
lățime_graniță 10
default_color alb
default_outline_color negru
default_shade_color negru
culoare0 cyan
culoare1 albastru deschis
culoare2 portocaliu
culoare3 galben
culoare4 grâu
culoare5 alb
culoare6 alb
culoare7 alb
culoare8 alb
culoare9 alb
aliniament top_right # sau top_left, bottom_left, bottom_right
decalaj_x 10
35
text_buffer_size 128 # folosiți 1024 pentru prognoză
no_buffers da # Scăderea bufferelor sistemului de fișiere din memoria utilizată?
draw_borders nr
draw_outline yes # amplifică textul dacă da
draw_shades yes # shadecolor black

TEXT
$ {font calibri: size = 12} $ {alignc} $ {color1} $ sysname $ kernel on $ machine} $ color $ font
$ {font calibri: size = 12} $ {alignc} $ {color2} $ {exec whoami} @ $ nodename $ color $ font
$ {color0} $ {hr 1} $ culoare
$ {font calibri: size = 20} $ {alignc} $ {time% H:% M} $ font
$ {font calibri: size = 12} $ {color1} $ {alignc} $ {time% A,% d% b. % Y} $ color $ font
$ {color3} UpTime: $ {alignr 2} $ uptime $ culoare
$ {color0} $ {hr 1} $ culoare
$ {voffset 5} $ {color2} CPU: $ {alignc} $ color $ running_processes $ {color1} / $ color $ procese $ {alignr 2} $ {color2} $ {cpubar cpu0 14,80} $ color
$ {color1} $ {voffset -16} $ {alignr 5} $ cpu% $ culoare
$ {voffset 2} $ {color1} Încărcare medie ($ {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% $ culoare
$ {voffset 2} $ {color1} Buffered: $ color $ {buffers} $ {alignr 2} $ {color1} În cache: $ 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} $ culoare
$ {voffset 5} $ {color2} Informații HD $ {color1} - $ color Gratuit $ {color1} - Folosit - $ {color2} Total
$ {voffset 5} $ {color1} Rădăcină: $ color $ {fs_free_perc /}% $ {alignr 2} $ {fs_free /} $ {color2} / $ {color1} $ {fs_used /} $ color / $ {color2} $ {fs_size /} $ culoare
$ {color1} Acasă: $ color $ {fs_free_perc / home / user}% $ {alignr 2} $ {fs_free / home / user} $ {color2} / $ {color1} $ {fs_used / home / user} $ color / $ {color2} $ {fs_size / home / user} $ culoare
$ {color0} $ {hr 1} $ culoare
$ {color1} De la: $ color Buenos Aires, Argentina
$ {color1} Lat: $ {color2} 34 ° 35'S $ {color1} Lung: $ {color2} 58 ° 21'W $ {color1} Alt: $ {color2} 25 m $ color
$ {voffset 5} $ {color2} $ {font calibri: size = 12} astăzi: $ font $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = CC} $ culoare $ {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 Săgeți: size = 20} $ {color4} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = BF} $ color $ font
$ {alignc 10} $ {voffset 5} $ {color4} Vânt: $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = WS} $ color
$ {color1} Umiditate: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = HM} $ {alignr 2} $ {color1} Precipitații: $ {color3} $ { execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = PC} $ color
$ {alignc} $ {color1} Presiune: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = BR} - $ {color3} $ {execi 3600 python ~ / Conky /scripts/conkyForecast.py –location = ARBA0009 –datatype = BD} $ culoare
$ {color4} $ {hr} $ culoare
$ {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} $ color
$ {voffset 15} $ {color1} Moon: $ {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 $ culoare
$ {color0} $ {hr} $ culoare
$ {voffset 5} $ {color2} IP: $ {alignc} $ color $ {addr eth0}
$ {color1} Jos: $ 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} Intrat: $ color $ {tcp_portmon 1 32767 count} $ {color1} Outbound: $ color $ {tcp_portmon 32768 61000 count} $ {alignr 2} $ {color1} Total: $ color $ {tcp_portmon 1 65535 count}
$ {voffset 5} $ {color2} Conexiuni: $ color $ {tcp_portmon 32768 61000 count} $ {alignr 2} $ {color2} Serviciu / 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} $ culoare

creăm fișierul ~ / Conky / conkyforecast

gedit ~ / Conky / conkyforecast

și lipim următoarele în interior

fundal nr
own_window da
own_window_transparent da
own_window_hints nedecorat, dedesubt, lipicios, skip_taskbar, skip_pager
own_window_colour negru
double_buffer da
use_spacer stânga
use_xft da
font calibri: size = 8
xftfont calibri: size = 8
xftalpha 0.5
update_interval 5.0
majuscule nu # setat la da dacă doriți ca întregul text să fie în majuscule
borduri_punctate 3
border_margin 9
lățime_graniță 10
default_color alb
default_outline_color negru
default_shade_color negru
culoare0 cyan
culoare1 albastru deschis
culoare2 portocaliu
culoare3 galben
culoare4 grâu
culoare5 alb
culoare6 alb
culoare7 alb
culoare8 alb
culoare9 alb
aliniament bottom_left # sau top_left, bottom_left, bottom_right
decalaj_x 10
35
text_buffer_size 1024 # folosiți 1024 pentru prognoză
no_buffers da # Scăderea bufferelor sistemului de fișiere din memoria utilizată?
draw_borders nr
draw_outline yes # amplifică textul dacă da
draw_shades yes # shadecolor black

TEXT
$ {color4} $ {font calibri: size = 11} Prognoză extinsă $ font $ color
$ {color0} $ {hr} $ culoare
$ {color4} $ {font calibri: size = 9} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –template = / home / user / Conky / scripts / myweather.template} $ font $ culoare

creăm fișierul ~ / Conky / conkymail

gedit ~ / Conky / conkymail

lipim următoarele în fișier

fundal nr
own_window da
own_window_transparent da
own_window_hints nedecorat, dedesubt, lipicios, skip_taskbar, skip_pager
own_window_colour negru
double_buffer da
use_spacer stânga
use_xft da
font calibri: size = 8
xftfont calibri: size = 8
xftalpha 0.5
update_interval 5.0
majuscule nu # setat la da dacă doriți ca întregul text să fie în majuscule
borduri_punctate 3
border_margin 9
lățime_graniță 10
default_color alb
default_outline_color negru
default_shade_color negru
culoare0 cyan
culoare1 albastru deschis
culoare2 portocaliu
culoare3 galben
culoare4 grâu
culoare5 alb
culoare6 alb
culoare7 alb
culoare8 alb
culoare9 alb
aliniament bottom_left # sau top_left, bottom_left, bottom_right
decalaj_x 565
35
text_buffer_size 128 # folosiți 1024 pentru prognoză
no_buffers da # Scăderea bufferelor sistemului de fișiere din memoria utilizată?
draw_borders nr
draw_outline yes # amplifică textul dacă da
draw_shades yes # shadecolor black

TEXT
$ {font calibri: size = 11} $ {alignc} $ {color4} Gmail
$ {color0} $ {hr} $ culoare
$ {font calibri: size = 11} $ {color4} Avem $ {color3} $ {execi 300 python ~ / Conky / scripts / mail / conkyEmail.py} $ {color4} email (e) $ font

Creăm un fișier în ~ / Conky / scripts / conkyForecast.py (trebuie să creăm folderul de scripturi)

gedit ~ / Conky / scripts / conkyForecast.py

#! / usr / bin / python
# - * - codare: utf-8 - * -
###################################################### ###############################
# conkyForecast.py este un script Python (nu mai simplu) (mai) simplu de adunat
# detalii despre vremea actuală pentru utilizare în conky.
#
# Autor: Kaivalagi
# Creat: 13
# Modificări:
# 14/04/2008 Permite intervale de zile pentru datele prognozate
# 14/04/2008 Verificați conectivitatea la serviciul xoap
# 18/04/2008 Permiteți setarea spațiilor pentru ieșire la distanță
# 18 Permite ieșirea prognozei pe timp de noapte și zi
# 18/04/2008 Asistență locală pentru opțiunea „CC” a codului condiției, în așteptarea traducerii în limba spaniolă
# 18/04/2008 Utilizați decaparea pentru datele clasei, mai degrabă decât deschiderea xml, aceasta ocolește necesitatea de a interoga datele memorate în cache
# 19/04/2008 A fost adăugat textul condiției spaniole - Mulțumesc Bruce M
# 19/04/2008 A fost adăugată verificarea numerică a tuturor ieșirilor numerice cu sufixul unităților
# 19/04/2008 Denumirea modificată a fișierelor murate pentru a include codul de locație
# 19/04/2008 A fost adăugată conversia zilelor de săptămână spaniolă prin localizare
# 20/04/2008 S-a adăugat un analizor decent al argumentelor de comandă
# 20/04/2008 Adăugată opțiunea - scurtă săptămână, dacă se dă ziua săptămânii, tipul de date este scurtat la 3 caractere
# 21/04/2008 S-au remediat opțiunile locale pentru ieșirea prognozată
# 21/04/2008 Adăugată - opțiunea de șablon pentru a permite ieșirea personalizată utilizând un singur apel execut 🙂
# 21/04/2008 Adăugată opțiunea –hideunits pentru a elimina, de exemplu, mph și C din ieșire
# 23/04/2008 Eliminată - opțiune imperială din șablon, aceasta TREBUIE să fie setată ca opțiune standard pe apelul script și să nu fie folosită în fișierul șablon.
# 23/04/2008 Citit - opțiune imperială pentru șablon, permițând valori metrice sau imperiale pe tip de date. Rețineți când utilizați șabloanele opțiunea liniei de comandă nu va funcționa.
# 23/04/2008 S-a adăugat ieșirea notificând utilizatorului dacă locația dată este greșită
# 24/04/2008 S-a adăugat gestionarea fără conectivitate, va reveni la datele cache acum (erori dacă nu există cache). Teste încercând să deschideți xoap.weather.com
# 24 S-a remediat conversia Celsius la Fahrenheit
# 06/05/2008 Adresa URL actualizată utilizată după actualizarea serviciului web
# 09/05/2008 Condiția actuală consolidată și datele de prognoză sunt preluate într-un singur apel
# 09/05/2008 S-au adăugat răsăritul și apusul la tipurile de date, acestea sunt specifice atât condițiilor curente, cât și datelor prognozate
# 09/05/2008 S-au adăugat fazei lunii, citirea barometrului și descrierea barometrului la tipurile de date, acestea sunt specifice doar condițiilor actuale și la fel sunt N / A în ieșirea prognozată
# 09/05/2008 S-au adăugat conversii de unități pentru barometru de la mb la inci (imperial)
# 09/05/2008 Actualizat textul condiției spaniole - Mulțumesc Bruce M
# 10/05/2008 S-au adăugat date locale franceze - Mulțumesc benpaka
# 12/05/2008 A fost adăugat un nou tip de date BF (care poartă) pentru a furniza un caracter săgeată (utilizați cu fontul Arrow.ttf) în locul ieșirii NSEW din WD (direcția vântului)
# 12/05/2008 Ieșirea WD actualizată trebuie să fie specifică localizării, în prezent acceptă implicit engleza și spaniola - Mulțumesc Bruce M
# 18/05/2008 A fost adăugat un nou tip de date MF (font lunar) pentru a furniza un caracter de font lunar (caractere incorecte și încă nu există un font dedicat).
# 21/05/2008 Pentru condițiile actuale, opțiunea –datatype = LT afișează acum temperatura „se simte ca” mai degrabă decât temperatura curentă
#
# TOT:
# Consolidați fișierele pkl într-un singur fișier / clasă
# Adăugați un font meteo bazat pe ieșirea fazei lunii pe baza datelor pictogramei lunii
# ??? Mai sunt cerințe acolo?

import sys, os, socket, urllib2, datetime, time
din xml.dom import minidom
din importul statistic *
din optparse import OptionParser
import localizare
import gettext
import murat
din importul matematic *

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

clasa CommandLineParser:

parser = Nici unul

def __init __ (auto):

self.parser = OptionParser ()
self.parser.add_option («- l», »- locație», dest = »locație», implicit = »UKXX0103 ″, tastați =» șir », metavar =» COD », ajutor = u» cod de locație pentru datele meteo [ implicit:% implicit], Utilizați următoarea adresă URL pentru a determina codul locației după numele orașului: http://xoap.weather.com/search/search?where=Norwich »)
self.parser.add_option ("- d", "- datatype", dest = "datatype", implicit = "HT", tip = "șir", metavar = "DATATYPE", help = u "[implicit:% implicit] Opțiunile pentru tipul de date sunt: ​​DW (ziua săptămânii), WF (Weather Font Output), LT (prognoză: temperatură scăzută, curent: se simte ca temperatura), HT (prognoză: temperatură înaltă, curent: temperatura curentă), CC (curent Condiții), CT (Text condiții), PC (șanse de precipitații), HM (umiditate), WD (direcția vântului), WS (viteza vântului), WG (rafale de vânt), CN (numele orașului), SR (răsărit), SS (apus), MP (faza lunii), MF (fontul lunii), BR (citirea barometrului), BD (descrierea barometrului). Nu se aplică la linia de comandă atunci când se utilizează șabloanele. »)
self.parser.add_option («- s», »- startday», dest = »startday», tastați = »int», metavar = »NUMBER», help = u »definiți numărul zilei de început, dacă sunt afișate condițiile curente omise . Nu se aplică la linia de comandă atunci când se utilizează șabloane. »)
self.parser.add_option ("- e", "- endday", dest = "endday", tip = "int", metavar = "NUMBER", help = u "definiți numărul zilei de final, dacă este omis doar datele din ziua de început nu este aplicabil la linia de comandă atunci când se utilizează șabloane. »)
self.parser.add_option («- S», »- spații», dest = »spații», tip = »int», implicit = 1, metavar = »NUMĂR», ajutor = u »[implicit:% implicit] Definește numărul de spații între ieșirea la distanță. Nu se aplică la linia de comandă atunci când utilizați șabloane. »)
self.parser.add_option («- t», »- template», dest = »template», tip = »string», metavar = »FILE», help = u »definește un fișier template pentru a genera ieșirea într-un singur apel. A elementul afișabil din fișier are forma {–datatype = HT –startday = 1}. Următoarele sunt opțiuni posibile în cadrul fiecărui articol: –datatype, –startday, –endday, –night, –shortweekday, –imperial, –hideunits, –Spații. Rețineți că formele scurte ale opțiunilor nu sunt acceptate în prezent! Niciuna dintre aceste opțiuni nu este aplicabilă la linia de comandă atunci când utilizați șabloane. »)
self.parser.add_option («- L», »- locale», dest = »locale», tastați = »șir», ajutor = u »suprascrie localizarea sistemului pentru ieșirea limbii (en = engleză, es = spaniolă, fr = franceză, mai mult să vină) »)
self.parser.add_option ("- i", "- imperial", dest = "imperial", implicit = False, action = "store_true", help = u "solicitați unități imperiale, dacă ieșirea omisă este în metrică. Nu se aplică la linie de comandă atunci când utilizați șabloane. »)
self.parser.add_option («- n», »- night», dest = »night», implicit = False, action = »store_true», help = u »comutați ieșirea la datele nocturne, dacă va fi ieșită ieșirea zilei omisă. Nu se aplică la linia de comandă atunci când se utilizează șabloane. »)
self.parser.add_option («- w», »- shortweekday», dest = »shortweekday», implicit = False, acțiune = »store_true», help = u »Scurtați tipul de date din ziua săptămânii la 3 caractere. Nu se aplică la linie de comandă atunci când utilizați șabloane. »)
self.parser.add_option («- u», »- hideunits», dest = »hideunits», implicit = False, acțiune = »store_true», help = u »Ascundeți unitățile precum mph sau C, simbolurile gradului (°) sunt încă afișat. Nu se aplică la linia de comandă atunci când utilizați șabloane. »)
self.parser.add_option ("- v", "- verbose", dest = "verbose", implicit = False, action = "store_true", help = u "solicitați o ieșire detaliată, nu este o idee bună când rulați prin conky!" )
self.parser.add_option ("- r", "- refetch", dest = "refetch", implicit = False, acțiune = "store_true", ajutor = u "preluați date indiferent de expirarea datelor")

def parse_args (self):
(opțiuni, argumente) = self.parser.parse_args ()
return (opțiuni, argumente)

def print_help (self):
returnează self.parser.print_help ()

clasă Date meteo:
def __init __ (self, day_of_week, low, high, condition_code, condition_text, precip, umiditate, wind_dir, wind_speed, wind_gusts, oraș, răsărit, apus, moon_phase, moon_icon, bar_read, bar_desc):
self.day_of_week = u »» + day_of_week
self.low = u »» + low
self.high = u »» + high
self.condition_code = u »» + condition_code
self.condition_text = u »» + condition_text
self.precip = u »» + precip
auto.umiditate = u »» + umiditate
self.wind_dir = u »» + wind_dir
self.wind_speed = u »» + wind_speed
self.wind_gusts = u »» + wind_gusts
self.city = u »» + city
self.sunrise = u »» + răsărit
self.sunset = u »» + apus
self.moon_phase = u »» + moon_phase
self.moon_icon = u »» + moon_icon
self.bar_read = u »» + bar_read
self.bar_desc = u »» + bar_desc

clasa WeatherText:

context_text = {
«0»: _ (u »Tornado»),
«1»: _ (u »Furtună tropicală»),
«2»: _ (u »Hurricane»),
«3»: _ (u »Furtuni puternice»),
«4»: _ (u »Furtuni»),
«5»: _ (u »Ploaie și zăpadă mixte»),
«6»: _ (u »Ploaie și lapoviță mixtă)),
«7»: _ (u »Precipitații mixte»),
«8»: _ (u »Ploaie înghețată»),
«9»: _ (u »Ploaie»),
«10»: _ (u »Freezing Rain»),
«11»: _ (u »Dusuri»),
«12»: _ (u »Dusuri»),
«13»: _ (u »Zăpadă de zăpadă»),
«14»: _ (u »Averse cu zăpadă ușoară»),
«15»: _ (u »Blowing Snow»),
«16»: _ (u »Zăpadă»),
«17»: _ (u »Salut»),
«18»: _ (u »Sleet»),
«19»: _ (u »Praf»),
«20»: _ (u »Ceață»),
«21»: _ (u »Haze»),
«22»: _ (u »Fum»),
«23»: _ (u »Blustery»),
«24»: _ (u »Windy»),
«25»: _ (u »rece»),
«26»: _ (u »Înnorat»),
«27»: _ (u »Parțial noros»),
«28»: _ (u »Parțial noros»),
«29»: _ (u »Parțial noros»),
«30»: _ (u »Parțial noros»),
«31»: _ (u »Clear»),
«32»: _ (u »Clear»),
«33»: _ (u »Târg»),
«34»: _ (u »Târg»),
«35»: _ (u »Mixt de ploaie și de grindină»),
«36»: _ (u »Hot»),
«37»: _ (u »Furtuni izolate»),
«38»: _ (u »Furtuni împrăștiate»),
«39»: _ (u »Furtuni împrăștiate»),
«40»: _ (u »Averse împrăștiate»),
«41»: _ (u »Zăpadă puternică»),
«42»: _ (u »Averse de zăpadă împrăștiate»),
«43»: _ (u »Zăpadă puternică»),
«44»: _ (u »Parțial noros»),
«45»: _ (u »Thunder Showers»),
«46»: _ (u »Averse de zăpadă»),
«47»: _ (u »Furtuni izolate»),
«Na»: _ (u »N / A»),
"-": _(A")
}

conditions_text_en = {
«0»: _ (u »Tornado»),
«1»: _ (u »Furtună tropicală»),
«2»: _ (u »Huracá¡n»),
«3»: _ (u »Furtuni puternice»),
«4»: _ (u »Furtuni»),
«5»: _ (u »Ploaie și zăpadă mixte»),
«6»: _ (u »Ploaie și lapoviță mixtă)),
«7»: _ (u »Sleet»),
«8»: _ (u »Ploaie înghețată»),
«9»: _ (u »Ploaie»),
«10»: _ (u »Ploaie înghețată»), # sau ploaie înghețată
«11»: _ (u »Dusuri»),
«12»: _ (u »Dusuri»),
«13»: _ (u »Zăpadă ușoară»),
«14»: _ (u »Zăpadă ușoară»),
«15»: _ (u »Viscol de zăpadă»),
«16»: _ (u »Zăpadă»),
«17»: _ (u »Salut»),
«18»: _ (u »Sleet»),
«19»: _ (u »Pulbere»),
«20»: _ (u »Ceață»),
«21»: _ (u »Haze»),
«22»: _ (u »Fum»),
«23»: _ (u »Furtună»),
«24»: _ (u »Windy»),
«25»: _ (u »Fráo»),
«26»: _ (u »Foarte înnorat»),
«27»: _ (u »Parțial noros»),
«28»: _ (u »Parțial noros»),
«29»: _ (u »Parțial noros»),
«30»: _ (u »Parțial noros»),
«31»: _ (u »Clear»),
«32»: _ (u »Clear»),
«33»: _ (u »Ceva înnorat»),
«34»: _ (u »Ceva înnorat»),
«35»: _ (u »Ploaia cu grindină»),
«36»: _ (u »Căldură»),
«37»: _ (u »Furtuni izolate»),
«38»: _ (u »Furtuni împrăștiate»),
«39»: _ (u »Furtuni împrăștiate»),
«40»: _ (u »Averse împrăștiate»),
«41»: _ (u »Zăpadă puternică»),
«42»: _ (u »Zăpezi slabe și împrăștiate»),
«43»: _ (u »Nevada intens»),
«44»: _ (u »Nori împrăștiați»),
«45»: _ (u »Furtuni»),
«46»: _ (u »Zăpezi împrăștiate»),
«47»: _ (u »Furtuni izolate»),
«Na»: _ (u »N / A»),
"-": _(A")
}

conditions_text_fr = {
«0»: _ (u »Tornade»),
«1»: _ (u »Tempête Tropicale»),
«2»: _ (sau »Ouragan»),
«3»: _ (sau »Orages Violents»),
«4»: _ (sau »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»: _ (sau »Orages Isolés»),
«38»: _ (sau »Orages Localisés»),
«39»: _ (sau »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»: _ (sau »Orages»),
«46»: _ (u »Tempête de Neige»),
«47»: _ (sau »Orages Isolés»),
«Na»: _ (u »N / A»),
"-": _(A")
}

condition_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 »»),
"-": _ (sau "")
}

condition_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 »»),
"-": _ (sau "")
}

ziua_săptămânii = {
„Azi”: _ (sau „Astăzi”),
«Luni»: _ (u »luni»),
«Marți»: _ (u »marți»),
«Miercuri»: _ (u »miercuri»),
«Joi»: _ (u »joi»),
„Vineri”: _ (u „Vineri”),
„Sâmbătă”: _ (u „sâmbătă”),
„Duminică”: _ (u „duminică”)
}

zi_de_săptămână_scurtă = {
„Azi”: _ (u „Acum”),
«Luni»: _ (u »luni»),
«Marți»: _ (u »marți»),
«Miercuri»: _ (u »miercuri»),
«Joi»: _ (u »joi»),
«Vineri»: _ (u »vin»),
„Sâmbătă”: _ (u „Sat”),
„Duminică”: _ (u „Soare”)
}

day_of_week_en = {
„Azi”: _ (u „azi”),
"Luni": _ (u "luni"),
«Marți»: _ (sau »marți»),
«Miercuri»: _ (u »miercuri»),
«Joi»: _ (u »joi»),
«Vineri»: _ (u »Vineri»),
„Sâmbătă”: _ (u „sâmbătă”),
„Duminică”: _ (u „duminică”)
}

day_of_week_short_en = {
„Azi”: _ (u „azi”),
"Luni": _ (u "lun"),
«Marți»: _ (u »mare»),
«Miercuri»: _ (u »miercuri»),
«Joi»: _ (u »joi»),
«Vineri»: _ (u »fri»),
"Sâmbătă": _ (u "sat"),
"Duminică": _ (u "dom")
}

day_of_week_fr = {
«Astăzi»: _ (u »Aujourd'hui»),
«Luni»: _ (u »Lundi»),
«Marți»: _ (u »Mardi»),
«Miercuri»: _ (u »Mercredi»),
«Joi»: _ (u »Jeudi»),
«Vineri»: _ (u »Vendredi»),
„Sâmbătă”: _ (u „Samedi”),
„Duminică”: _ (u „Dimanche”)
}

day_of_week_short_fr = {
«Astăzi»: _ (u »Auj»),
"Luni": _ (u "Luni"),
«Marți»: _ (u »mar»),
„Miercuri”: _ (u „Mer”),
«Joi»: _ (u »Jeu»),
«Vineri»: _ (u »Vino»),
"Sâmbătă": _ (u "Sam"),
„Duminică”: _ (u „Dim”)
}

bearing_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 »«)
}

bearing_text_en = {
«N»: _ (u »N»),
«NNE»: _ (u »NNE»),
«NE»: _ (u »NE»),
«ENE»: _ (u »ENE»),
"Eu e"),
«ESE»: _ (u »ESE»),
«SE»: _ (u »SE»),
„SSE”: _ (u „SSE”),
"Al lor"),
„SSW”: _ (u „SSO”),
«SW»: _ (u »SO»),
„WSW”: _ (u „WOW”),
«W»: _ (u »O»),
«WNW»: _ (u »ONO»),
«NW»: _ (u »NO»),
«NNW»: _ (u »NNO»),
«N / A»: _ (u »N \ A»)
}

bearing_text_fr = {
«N»: _ (u »N»),
«NNE»: _ (u »NNE»),
«NE»: _ (u »NE»),
«ENE»: _ (u »ENE»),
"Eu e"),
«ESE»: _ (u »ESE»),
«SE»: _ (u »SE»),
„SSE”: _ (u „SSE”),
"Al lor"),
„SSW”: _ (u „SSO”),
«SW»: _ (u »SO»),
„WSW”: _ (u „WOW”),
«W»: _ (u »O»),
«WNW»: _ (u »ONO»),
«NW»: _ (u »NO»),
«NNW»: _ (u »NNO»),
«N / A»: _ (u »N \ A»)
}

clasa GlobalWeather:

condiții_curente = []
day_forecast = []
night_forecast = []

locale = "în"

opțiuni = Niciuna
weatherxmldoc = ""

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 __ (auto, opțiuni):

self.options = opțiuni

dacă self.options.locale == Nici unul:
încerca:
# self.locale = locale.getdefaultlocale () [0] [0: 2]
self.locale = «es» #uncomment this line to force Spanish language
# self.locale = "fr" #comentează această linie pentru a forța localizarea franceză
cu exceptia:
tipăriți „localizarea nu este setată”
altceva:
# self.locale = self.options.locale
self.locale = «es» #uncomment this line to force Spanish language
# self.locale = "fr" #comentează această linie pentru a forța localizarea franceză

dacă self.options.verbose == Adevărat:
print >> sys.stdout, "setare locală la", self.locale

def getText (auto, nodelist):
rc = ""
pentru nodul din lista de noduri:
dacă node.nodeType == node.TEXT_NODE:
rc = rc + nod.date
întoarce rc

def getSpaces (auto, spații):
șir = u »»
dacă spații == Nici unul:
șir = self.DEFAULT_SPACING
altceva:
pentru i în interval (0, spații + 1):
șir = șir + u »«
returnează șirul

def isNumeric (self, string):
încerca:
manechin = float (șir)
returnează Adevărat
cu exceptia:
returnează Fals

def isConnectionAvailable (auto):
# asigurați-vă că putem accesa serverul weather.com deschizând adresa URL
încerca:
Usock = urllib2.urlopen („http://xoap.weather.com”)
Usock.close ()
returnează Adevărat
cu exceptia:
returnează Fals

def getBearingText (auto, rulment):
rulment = plutitor (rulment)
dacă poartă <11.25:
returnează tu »N»
rulment elif <33.75:
returnează-ți »NNE»
rulment elif <56.25:
returnează tu »NE»
rulment elif <78.75:
întoarce-te »JAN»
rulment elif <101.25:
returnează tu »E»
rulment elif <123.75:
returnează-te »ESE»
rulment elif <146.25:
returnează tu »SE»
rulment elif <168.75:
returnează tu »SSE»
rulment elif <191.25:
returnează tu »S»
rulment elif <213.75:
returnează tu »SSW»
rulment elif <236.25:
returnează tu »SW»
rulment elif <258.75:
returnează-ți »WSW»
rulment elif <281.25:
întoarce-te »W»
rulment elif <303.75:
returnează-te »WNW»
rulment elif <326.25:
întoarce-te »NW»
rulment elif <348.75:
returnează-te »NNW»
altceva:
retur «N / A»

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

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

convert convertMillibarsToInches (auto, mb):
return str (int (etaj (float (mb) /33.8582)))

def getTemplateList (auto, șablon):

listă șabloane = []

pentru template_part din template.split («{«):
dacă șablon_partea! = «»:
pentru template_part din template_part.split ("}"):
dacă șablon_partea! = «»:
templatelist.append (u »» + template_part)

returnează lista de șabloane

def getOutputText (self, tip de date, startday, endday, night, shortweekday, imperial, hideunits, spaces):
#încerca:
ieșire = u »»

# definiți unitățile curente pentru ieșire
dacă hideunits == False:
dacă imperial == Fals:
tempunit = u »° C»
speedunit = u »kph»
unitate de presiune = u »mb»
altceva:
tempunit = u »° F»
speedunit = u »mph»
unitate de presiune = u »în»
altceva:
tempunit = u »°»
speedunit = u »»
unitate de presiune = u »»

if startday == None: # condiții actuale

dacă tipul de date == "DW":
dacă self.locale == "este":
dacă shortweekday == Adevărat:
output = WeatherText.day_of_week_short_es [self.current_conditions [0] .day_of_week]
altceva:
output = WeatherText.day_of_week_es [self.current_conditions [0] .day_of_week]
elif self.locale == "fr":
dacă shortweekday == Adevărat:
output = WeatherText.day_of_week_short_fr [self.current_conditions [0] .day_of_week]
altceva:
output = WeatherText.day_of_week_fr [self.current_conditions [0] .day_of_week]
altceva:
dacă shortweekday == Adevărat:
output = WeatherText.day_of_week_short [self.current_conditions [0] .day_of_week]
altceva:
output = WeatherText.day_of_week [self.current_conditions [0] .day_of_week]
elif datatype == "WF": # font meteo
output = WeatherText.conditions_weather_font [self.current_conditions [0] .condition_code]
tip de date elif == "LT":
string = self.current_conditions [0] .low
dacă self.isNumeric (șir) == Adevărat:
if imperial == Adevărat:
șir = self.convertCelsiusToFahrenheit (șir)
sfoară = sfoară + tempunit
ieșire = șir
tip de date elif == "HT":
șir = self.current_conditions [0] .high
dacă self.isNumeric (șir) == Adevărat:
if imperial == Adevărat:
șir = self.convertCelsiusToFahrenheit (șir)
sfoară = sfoară + tempunit
ieșire = șir
tip de date elif == "CC":
dacă self.locale == "este":
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]
altceva:
output = WeatherText.conditions_text [self.current_conditions [0] .condition_code]
tip de date elif == "CT":
output = self.current_conditions [0] .condition_text
tip de date elif == "PC":
șir = self.current_conditions [0] .precip
dacă self.isNumeric (șir) == Adevărat:
șir = șir + u »%»
ieșire = șir
tip de date elif == "HM":
șir = self.current_conditions [0] .umiditate
dacă self.isNumeric (șir) == Adevărat:
șir = șir + u »%»
ieșire = șir
tip de date elif == "WD":
șir = self.current_conditions [0] .wind_dir
dacă self.isNumeric (șir) == Adevărat:
șir = self.getBearingText (șir)

dacă self.locale == "este":
output = WeatherText.bearing_text_es [șir]
elif self.locale == "fr":
output = WeatherText.bearing_text_fr [șir]
altceva:
ieșire = șir

tip de date elif == "BF":
șir = self.current_conditions [0] .wind_dir
dacă self.isNumeric (șir) == Adevărat:
șir = WeatherText.bearing_arrow_font [self.getBearingText (șir)]
ieșire = șir
tip de date elif == "WS":
șir = self.current_conditions [0] .wind_speed
dacă self.isNumeric (șir) == Adevărat:
if imperial == Adevărat:
șir = self.convertKilometresToMiles (șir)
șir = șir + unitate de viteză
ieșire = șir
tip de date elif == "WG":
șir = self.current_conditions [0] .wind_gusts
dacă self.isNumeric (șir) == Adevărat:
if imperial == Adevărat:
șir = self.convertKilometresToMiles (șir)
șir = șir + unitate de viteză
ieșire = șir
tip de date elif == "CN":
output = self.current_conditions [0] .city
tip de date elif == "SR":
output = self.current_conditions [0] .sunrise
tip de date elif == "SS":
output = self.current_conditions [0] .sunset
tip de date elif == "MP":
output = self.current_conditions [0] .moon_phase
tip de date elif == "MF":
output = WeatherText.conditions_moon_font [self.current_conditions [0] .moon_icon]
tip de date elif == "BR":
șir = self.current_conditions [0] .bar_read
dacă self.isNumeric (șir) == Adevărat:
if imperial == Adevărat:
șir = self.convertMillibarsToInches (șir)
șir = șir + unitate de presiune
ieșire = șir
tip de date elif == "BD":
output = self.current_conditions [0] .bar_desc
altceva:
output = "\ nERROR: Tip de date necunoscut solicitat"

else: # date prognozate

if endday == None: # if no endday has set set startday
endday = ziua de început

dacă noapte == Adevărat: este necesară # prognoza de noapte

pentru day_number în interval (startday, endday + 1):

dacă tipul de date == "DW":
dacă self.locale == "este":
dacă shortweekday == Adevărat:
output = output + self.getSpaces (spații) + WeatherText.day_of_week_short_es [self.night_forecast [day_number] .day_of_week]
altceva:
output = output + self.getSpaces (spații) + WeatherText.day_of_week_es [self.night_forecast [day_number] .day_of_week]
elif self.locale == "fr":
dacă shortweekday == Adevărat:
output = output + self.getSpaces (spații) + WeatherText.day_of_week_short_fr [self.night_forecast [day_number] .day_of_week]
altceva:
ieșire = ieșire + self.getSpaces (spații) + WeatherText.day_of_week_fr [self.night_forecast [day_number] .day_of_week]
altceva:
dacă shortweekday == Adevărat:
output = output + self.getSpaces (spații) + WeatherText.day_of_week_short [self.night_forecast [day_number] .day_of_week]
altceva:
ieșire = ieșire + self.getSpaces (spații) + WeatherText.day_of_week [self.night_forecast [day_number] .day_of_week]
elif datatype == "WF": # font meteo
ieșire = ieșire + self.getSpaces (spații) + WeatherText.conditions_weather_font [self.night_forecast [day_number] .condition_code]
tip de date elif == "LT":
string = self.night_forecast [day_number] .low
dacă self.isNumeric (șir) == Adevărat:
if imperial == Adevărat:
șir = self.convertCelsiusToFahrenheit (șir)
sfoară = sfoară + tempunit
output = output + self.getSpaces (spații) + șir

tip de date elif == "HT":
string = self.night_forecast [day_number] .high
dacă self.isNumeric (șir) == Adevărat:
if imperial == Adevărat:
șir = self.convertCelsiusToFahrenheit (șir)
sfoară = sfoară + tempunit
output = output + self.getSpaces (spații) + șir
tip de date elif == "CC":
dacă self.locale == "este":
output = output + self.getSpaces (spații) + WeatherText.conditions_text_es [self.night_forecast [day_number] .condition_code]
elif self.locale == "fr":
ieșire = ieșire + self.getSpaces (spații) + WeatherText.conditions_text_fr [self.night_forecast [day_number] .condition_code]
altceva:
output = output + self.getSpaces (spații) + WeatherText.conditions_text [self.night_forecast [day_number] .condition_code]
tip de date elif == "CT":
output = output + self.getSpaces (spații) + self.night_forecast [day_number] .condition_text
tip de date elif == "PC":
șir = self.night_forecast [day_number] .precip
dacă self.isNumeric (șir) == Adevărat:
șir = șir + u »%»
output = output + self.getSpaces (spații) + șir
tip de date elif == "HM":
string = self.night_forecast [day_number] .humidity
dacă self.isNumeric (șir) == Adevărat:
șir = șir + u »%»
output = output + self.getSpaces (spații) + șir
tip de date elif == "WD":
string = self.night_forecast [day_number] .wind_dir
dacă self.locale == "este":
output = output + self.getSpaces (spații) + WeatherText.bearing_text_es [șir]
elif self.locale == "fr":
output = output + self.getSpaces (spații) + WeatherText.bearing_text_fr [șir]
altceva:
output = output + self.getSpaces (spații) + șir

tip de date elif == "BF":
ieșire = ieșire + self.getSpaces (spații) + WeatherText.bearing_arrow_font [self.night_forecast [day_number] .wind_dir]
tip de date elif == "WS":
string = self.night_forecast [day_number] .wind_speed
dacă self.isNumeric (șir) == Adevărat:
if imperial == Adevărat:
șir = self.convertKilometresToMiles (șir)
șir = șir + unitate de viteză
output = output + self.getSpaces (spații) + șir
tip de date elif == "WG":
string = self.night_forecast [day_number] .wind_gusts
dacă self.isNumeric (șir) == Adevărat:
if imperial == Adevărat:
șir = self.convertKilometresToMiles (șir)
șir = șir + unitate de viteză
output = output + self.getSpaces (spații) + șir
tip de date elif == "CN":
output = output + self.getSpaces (spații) + self.night_forecast [day_number] .city
tip de date elif == "SR":
ieșire = ieșire + self.getSpaces (spații) + self.night_forecast [day_number] .sunrise
tip de date elif == "SS":
ieșire = ieșire + self.getSpaces (spații) + self.night_forecast [day_number] .sunset
tip de date elif == "MP":
output = output + self.getSpaces (spații) + self.night_forecast [day_number] .moon_phase
tip de date elif == "MF":
ieșire = ieșire + self.getSpaces (spații) + WeatherText.conditions_moon_font [self.night_forecast [day_number] .moon_icon]
tip de date elif == "BR":
output = output + self.getSpaces (spații) + self.night_forecast [day_number] .bar_read
tip de date elif == "BD":
ieșire = ieșire + self.getSpaces (spații) + self.night_forecast [day_number] .bar_desc
altceva:
output = "\ nERROR: Tip de date necunoscut solicitat"
rupe

altfel: prognoza de # zi dorită

pentru day_number în interval (startday, endday + 1):

dacă tipul de date == "DW":
dacă self.locale == "este":
dacă shortweekday == Adevărat:
output = output + self.getSpaces (spații) + WeatherText.day_of_week_short_es [self.day_forecast [day_number] .day_of_week]
altceva:
ieșire = ieșire + self.getSpaces (spații) + WeatherText.day_of_week_es [self.day_forecast [day_number] .day_of_week]
elif self.locale == "fr":
dacă shortweekday == Adevărat:
ieșire = ieșire + self.getSpaces (spații) + WeatherText.day_of_week_short_fr [self.day_forecast [day_number] .day_of_week]
altceva:
output = output + self.getSpaces (spații) + WeatherText.day_of_week_fr [self.day_forecast [day_number] .day_of_week]
altceva:
dacă shortweekday == Adevărat:
ieșire = ieșire + self.getSpaces (spații) + WeatherText.day_of_week_short [self.day_forecast [day_number] .day_of_week]
altceva:
ieșire = ieșire + self.getSpaces (spații) + WeatherText.day_of_week [self.day_forecast [day_number] .day_of_week]
elif datatype == "WF": # font meteo
output = output + self.getSpaces (spații) + WeatherText.conditions_weather_font [self.day_forecast [day_number] .condition_code]
tip de date elif == "LT":
șir = self.day_forecast [day_number] .low
dacă self.isNumeric (șir) == Adevărat:
if imperial == Adevărat:
șir = self.convertCelsiusToFahrenheit (șir)
sfoară = sfoară + tempunit
output = output + self.getSpaces (spații) + șir
tip de date elif == "HT":
string = self.day_forecast [day_number] .high
dacă self.isNumeric (șir) == Adevărat:
if imperial == Adevărat:
șir = self.convertCelsiusToFahrenheit (șir)
sfoară = sfoară + tempunit
output = output + self.getSpaces (spații) + șir
tip de date elif == "CC":
dacă self.locale == "este":
output = output + self.getSpaces (spații) + WeatherText.conditions_text_es [self.day_forecast [day_number] .condition_code]
elif self.locale == "fr":
output = output + self.getSpaces (spații) + WeatherText.conditions_text_fr [self.day_forecast [day_number] .condition_code]
altceva:
output = output + self.getSpaces (spații) + WeatherText.conditions_text [self.day_forecast [day_number] .condition_code]
tip de date elif == "CT":
output = output + self.getSpaces (spații) + self.day_forecast [day_number] .condition_text
tip de date elif == "PC":
string = self.day_forecast [day_number] .precip
dacă self.isNumeric (șir) == Adevărat:
șir = șir + u »%»
output = output + self.getSpaces (spații) + șir
tip de date elif == "HM":
string = self.day_forecast [day_number] .humidity
dacă self.isNumeric (șir) == Adevărat:
șir = șir + u »%»
output = output + self.getSpaces (spații) + șir
tip de date elif == "WD":
string = self.day_forecast [day_number] .wind_dir

dacă self.locale == "este":
output = output + self.getSpaces (spații) + WeatherText.bearing_text_es [șir]
elif self.locale == "fr":
output = output + self.getSpaces (spații) + WeatherText.bearing_text_fr [șir]
altceva:
output = output + self.getSpaces (spații) + șir

tip de date elif == "BF":
ieșire = ieșire + self.getSpaces (spații) + WeatherText.bearing_arrow_font [self.day_forecast [day_number] .wind_dir]
tip de date elif == "WS":
șir = self.day_forecast [day_number] .wind_speed
dacă self.isNumeric (șir) == Adevărat:
if imperial == Adevărat:
șir = self.convertKilometresToMiles (șir)
șir = șir + unitate de viteză
output = output + self.getSpaces (spații) + șir
tip de date elif == "WG":
șir = self.day_forecast [day_number] .wind_gusts
dacă self.isNumeric (șir) == Adevărat:
if imperial == Adevărat:
șir = self.convertKilometresToMiles (șir)
șir = șir + unitate de viteză
output = output + self.getSpaces (spații) + șir
tip de date elif == "CN":
ieșire = ieșire + self.getSpaces (spații) + self.day_forecast [day_number] .city
tip de date elif == "SR":
ieșire = ieșire + self.getSpaces (spații) + self.day_forecast [day_number] .sunrise
tip de date elif == "SS":
ieșire = ieșire + self.getSpaces (spații) + self.day_forecast [day_number] .sunset
tip de date elif == "MP":
ieșire = ieșire + self.getSpaces (spații) + self.day_forecast [day_number] .moon_phase
tip de date elif == "MF":
output = output + self.getSpaces (spații) + WeatherText.conditions_moon_font [self.day_forecast [day_number] .moon_icon]
tip de date elif == "BR":
output = output + self.getSpaces (spații) + self.day_forecast [day_number] .bar_read
tip de date elif == "BD":
output = output + self.getSpaces (spații) + self.day_forecast [day_number] .bar_desc
altceva:
output = u »\ nERROR: Tip de date necunoscut solicitat»
rupe

ieșire = u »» + ieșire.strip (u »«) # pierde spații de conducere / de urmărire
returnează ieșirea

#cu exceptia:
#print "getOutputText: Eroare neașteptată:", sys.exc_info () [0]

def getOutputTextFromTemplate (auto, șablon):
#încerca:

# taste pentru datele șablonului
DATATYPE_KEY = "–datatype ="
STARTDAY_KEY = "–startday ="
ENDDAY_KEY = "–endday ="
NIGHT_KEY = "– noapte"
SHORTWEEKDAY_KEY = "–shortweekday"
IMPERIAL_KEY = "–imperial"
HIDEUNITS_KEY = "–hideunits"
SPACES_KEY = "–spaces ="

ieșire = u »»

opțiune găsită = Fals

#încărcați fișierul
încerca:
fileinput = deschis (self.options.template)
template = fileinput.read ()
fileinput.close ()
cu exceptia:
output = u »Fișierul șablon nu a fost găsit!»

templatelist = self.getTemplateList (șablon)

# permite parcurgerea listei de șabloane și determinarea rezultatului pentru fiecare element găsit
pentru i în intervalul (0, len (templatelist) -1):

pos = templatelist [i] .find (DATATYPE_KEY)
dacă pos! = -1:
optionfound = Adevărat
pos = pos + len (DATATYPE_KEY)
datatype = templatelist [i] [pos: pos + 4] .strip ("}"). strip ("{"). strip ("-"). strip ("")
altceva:
tip de date = None

pos = templatelist [i] .find (STARTDAY_KEY)
dacă pos! = -1:
optionfound = Adevărat
pos = pos + len (STARTDAY_KEY)
startday = int (templatelist [i] [pos: pos + 4] .strip ("}"). strip ("{"). strip ("-"). strip (""))
altceva:
startday = Niciuna

pos = templatelist [i] .find (ENDDAY_KEY)
dacă pos! = -1:
optionfound = Adevărat
pos = pos + len (ENDDAY_KEY)
endday = int (templatelist [i] [pos: pos + 4] .strip ("}"). strip ("{"). strip ("-"). strip (""))
altceva:
endday = Nici unul

pos = templatelist [i] .find (NIGHT_KEY)
dacă pos! = -1:
optionfound = Adevărat
noapte = Adevărat
altceva:
noapte = Fals

pos = templatelist [i] .find (SHORTWEEKDAY_KEY)
dacă pos! = -1:
optionfound = Adevărat
shortweekday = Adevărat
altceva:
shortweekday = Fals

pos = templatelist [i] .find (IMPERIAL_KEY)
dacă pos! = -1:
optionfound = Adevărat
imperial = Adevărat
altceva:
imperial = Fals

pos = templatelist [i] .find (HIDEUNITS_KEY)
dacă pos! = -1:
optionfound = Adevărat
hideunits = Adevărat
altceva:
hideunits = False

pos = templatelist [i] .find (SPACES_KEY)
dacă pos! = -1:
optionfound = Adevărat
pos = pos + len (SPACES_KEY)
spaces = int (templatelist [i] [pos: pos + 4] .strip («}»). strip («{«). strip («-«). strip (»«))
altceva:
spații = 1

dacă opțiunea găsită == Adevărat:
templatelist [i] = self.getOutputText (tip de date, startday, endday, night, shortweekday, imperial, hideunits, spaces)
opțiune găsită = Fals

# parcurgeți lista concatenând ieșirea acum că a fost completată
pentru elementul din lista de șabloane:
ieșire = ieșire + element

returnează ieșirea

#cu exceptia:
#print "getOutputTextFromTemplate: Eroare neașteptată:", sys.exc_info () [0]

def fetchData (auto):

# preluați întotdeauna date metrice, utilizați funcțiile de conversație pe aceste date
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)

dacă self.isConnectionAvailable () == False:
dacă os.path.exists (file_path_current):
RefetchData = Fals
else: # fără conexiune, fără cache, bang!
print "Nu este disponibilă nicio conexiune la internet și nu există date meteo în cache."
elif self.options.refetch == Adevărat:
RefetchData = Adevărat
altceva:
# datele trebuie să fie recuperate din nou?
dacă os.path.exists (file_path_current):
lastmodDate = time.localtime (os.stat (file_path_current) [ST_MTIME])
expiryDate = (datetime.datetime.today () - datetime.timedelta (minute = self.EXPIRY_MINUTES)). scheduluple ()

dacă expiredDate> lastmodDate:
RefetchData = Adevărat
altceva:
RefetchData = Fals
altceva:
RefetchData = Adevărat

# preluați datele despre condițiile actuale, fie de pe site, fie prin „descărcare”
dacă RefetchData == Adevărat:

# obțineți date despre condițiile actuale de la serviciul xoap
încerca:

# 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 & unitate = m '
dacă self.options.verbose == Adevărat:
print >> sys.stdout, «preluarea datelor meteo din«, url

Usock = urllib2.urlopen (url)
xml = usock.read ()
Usock.close ()
self.weatherxmldoc = minidom.parseString (xml)
cu exceptia:
print "fetchData: Eroare neașteptată:", sys.exc_info () [0]
print "Imposibil de contactat sursa meteo pentru condițiile actuale"

# spuneți utilizatorului dacă locația este proastă ...
found = xml.find ("Locație nevalidă furnizată")
dacă se găsește! = -1:
print "Locație nevalidă furnizată"

# interogați datele meteo, încărcați-le în structura clasei și opriți-le
încerca:

# pregătește liste de date meteo
self.current_conditions = []
self.day_forecast = []
self.night_forecast = []

# colectează date generale
weather_n = self.weatherxmldoc.documentElement
location_n = weather_n.getElementsByTagName ('loc') [0]
city_n = location_n.getElementsByTagName ('dnam') [0]
city ​​= self.getText (city_n.childNodes)

# colectează date despre condițiile actuale
day_of_week = u »Azi»
precip = u »N / A»
sunrise_n = location_n.getElementsByTagName ('sunr') [0]
răsărit = self.getText (sunrise_n.childNodes)
sunset_n = location_n.getElementsByTagName ('suns') [0]
apus = 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 („pictogramă”) [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 ('wind') [0]
wind_speed_n = wind_n.getElementsByTagName ('s') [0]
wind_speed = self.getText (wind_speed_n.childNodes)
wind_gust_n = wind_n.getElementsByTagName ('rafală') [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)
moist_n = current_condition_n.getElementsByTagName ('hmid') [0]
umiditate = self.getText (umiditate_n.childNodes)
moon_n = current_condition_n.getElementsByTagName („luna”) [0]
moon_icon_n = moon_n.getElementsByTagName („pictogramă”) [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, precip, umiditate, wind_direction, wind_speed, wind_gusts, city, răsărit, apus, moon_phase, moon_icon, bar_read, bar_desc)
self.current_conditions.append (current_conditions_data)

# colectează date prognozate
bar_read = u »N / A»
bar_desc = u »N / A»
luna_faza = u »N / A»
moon_icon = u »na»
forecast_n = weather_n.getElementsByTagName ('dayf') [0]
day_nodes = forecast_n.getElementsByTagName ('zi')

pentru zi în zi_noduri:
day_of_week = day.getAttribute ('t')
day_of_year = day.getAttribute ('dt')
high_temp_n = day.getElementsByTagName ('hi') [0]
high_temp = self.getText (high_temp_n.childNodes)
low_temp_n = day.getElementsByTagName ('low') [0]
low_temp = self.getText (low_temp_n.childNodes)

sunrise_n = day.getElementsByTagName ('sunr') [0]
răsărit = self.getText (sunrise_n.childNodes)
sunset_n = day.getElementsByTagName ('suns') [0]
apus = self.getText (sunset_n.childNodes)

prognoză date specifice de # zi
daytime_n = day.getElementsByTagName („parte”) [0] # zi
condition_code_n = daytime_n.getElementsByTagName („pictogramă”) [0]
condition_code = self.getText (condition_code_n.childNodes)
condition_n = daytime_n.getElementsByTagName ('t') [0]
condition = self.getText (condition_n.childNodes)
precip_n = daytime_n.getElementsByTagName ('ppcp') [0]
precip = self.getText (precip_n.childNodes)
moist_n = daytime_n.getElementsByTagName ('hmid') [0]
umiditate = self.getText (umiditate_n.childNodes)
wind_n = daytime_n.getElementsByTagName („vânt”) [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 ('rafală') [0]
wind_gusts = self.getText (wind_gusts_n.childNodes)
day_forecast_data = WeatherData (day_of_week, low_temp, high_temp, condition_code, condition, precip, umiditate, wind_direction, wind_speed, wind_gusts, city, sunrise, sunset, moon_phase, moon_icon, bar_read, bar_desc
self.day_forecast.append (day_forecast_data)

# prognoza nocturnă date specifice
daytime_n = day.getElementsByTagName („parte”) [1] # noapte
condition_code_n = daytime_n.getElementsByTagName („pictogramă”) [0]
condition_code = self.getText (condition_code_n.childNodes)
condition_n = daytime_n.getElementsByTagName ('t') [0]
condition = self.getText (condition_n.childNodes)
precip_n = daytime_n.getElementsByTagName ('ppcp') [0]
precip = self.getText (precip_n.childNodes)
moist_n = daytime_n.getElementsByTagName ('hmid') [0]
umiditate = self.getText (umiditate_n.childNodes)
wind_n = daytime_n.getElementsByTagName („vânt”) [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 ('rafală') [0]
wind_gusts = self.getText (wind_gusts_n.childNodes)
night_forecast_data = WeatherData (day_of_week, low_temp, high_temp, condition_code, condition, precip, umiditate, direcția_vântului, speed_speed, wind_gusts, city, răsărit, apus de soare, moon_phase, moon_icon, bar_read, bar_desc)
self.night_forecast.append (night_forecast_data)

# murăm datele pentru data viitoare!
fileoutput = deschis (file_path_current, 'w')
pickle.dump (self.current_conditions, fileoutput)
fileoutput.close ()

fileoutput = deschis (file_path_dayforecast, 'w')
pickle.dump (self.day_forecast, fileoutput)
fileoutput.close ()

fileoutput = deschis (file_path_nightforecast, 'w')
pickle.dump (self.night_forecast, fileoutput)
fileoutput.close ()

cu exceptia:
print "fetchData: Eroare neașteptată:", sys.exc_info () [0]
print "Imposibil de interogat datele meteo"

else: # preluați date despre vreme din fișierele claselor murate
dacă self.options.verbose == Adevărat:
print >> sys.stdout, «preluarea datelor meteo din fișier:«, file_path_current

fileinput = deschis (file_path_current, 'r')
self.current_conditions = pickle.load (fileinput)
fileinput.close ()

dacă self.options.verbose == Adevărat:
print >> sys.stdout, "preluarea datelor de prognoză pe zi din fișiere:", file_path_dayforecast, file_path_nightforecast

fileinput = deschis (file_path_dayforecast, 'r')
self.day_forecast = pickle.load (introducere fișier)
fileinput.close ()

dacă self.options.verbose == Adevărat:
print >> sys.stdout, «preluarea datelor de prognoză pe zi din fișiere:«, file_path_nightforecast, file_path_nightforecast

fileinput = deschis (file_path_nightforecast, 'r')
self.night_forecast = pickle.load (introducere fișier)
fileinput.close ()

def outputData (auto):
#încerca:

if self.options.template! = Nici unul:

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

altceva:

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")

#cu exceptia:
#print «outputData: Eroare neașteptată:«, sys.exc_info () [0]

dacă __name__ == "__main__":

parser = CommandLineParser ()
(opțiuni, argumente) = parser.parse_args ()

if options.verbose == Adevărat:
print >> sys.stdout, "location:", options.location
print >> sys.stdout, "imperial:", options.imperial
print >> sys.stdout, "datatype:", options.datatype
print >> sys.stdout, "night:", options.night
print >> sys.stdout, "start day:", options.startday
print >> sys.stdout, "end end:", options.endday
print >> sys.stdout, "spații:", options.spaces
print >> sys.stdout, "verbose:", options.verbose
print >> sys.stdout, "refetch:", options.refetch

# creați un nou obiect meteo global
weather = GlobalWeather (opțiuni)
weather.fetchData ()
weather.outputData ()

Creăm fișierul ~ / Conky / scripts / myweather.template

gedit ~ / Conky / scripts / myweather.template

lipim următoarele în interior:

{–Datatype = DW –startday = 1}: {–datatype = CC –startday = 1}
{–Datatype = HT –startday = 1} / {–datatype = LT –startday = 1} Vânt de la {–datatype = WD –startday = 1} la {–datatype = WS –startday = 1}
Umiditate: {–datatype = HM –startday = 1} Precipitații: {–datatype = PC –startday = 1}
Răsărit: {–datatype = SR –startday = 1} Apus: {–datatype = SS –startday = 1}
----------------
{–Datatype = DW –startday = 2}: {–datatype = CC –startday = 2}
{–Datatype = HT –startday = 2} / {–datatype = LT –startday = 2} Vânt de la {–datatype = WD –startday = 2} la {–datatype = WS –startday = 2}
Umiditate: {–datatype = HM –startday = 2} Precipitații: {–datatype = PC –startday = 2}
Răsărit: {–datatype = SR –startday = 2} Apus: {–datatype = SS –startday = 2}
----------------
{–Datatype = DW –startday = 3}: {–datatype = CC –startday = 3}
{–Datatype = HT –startday = 3} / {–datatype = LT –startday = 3} Vânt de la {–datatype = WD –startday = 3} la {–datatype = WS –startday = 3}
Umiditate: {–datatype = HM –startday = 3} Precipitații: {–datatype = PC –startday = 3}
Răsărit: {–datatype = SR –startday = 3} Apus: {–datatype = SS –startday = 3}
----------------
{–Datatype = DW –startday = 4}: {–datatype = CC –startday = 4}
{–Datatype = HT –startday = 4} / {–datatype = LT –startday = 4} Vânt de la {–datatype = WD –startday = 4} la {–datatype = WS –startday = 4}
Umiditate: {–datatype = HM –startday = 4} Precipitații: {–datatype = PC –startday = 4}
Răsărit: {–datatype = SR –startday = 4} Apus: {–datatype = SS –startday = 4}

Creăm fișierul ~ / Conky / scripts / mail / conkyEmail.py (trebuie să creăm folderul de e-mail)

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

și lipim următoarele în interior:

te import
șir de import

#Introduceți numele de utilizator și parola mai jos în ghilimele duble
# de exemplu. nume de utilizator = »nume de utilizator» și parolă = »parolă»
nume de utilizator = »YOUR_USUARIO_SINARROBA«
parola = »CHEIA TA«

com = »wget -O - https: //» + nume de utilizator + »:» + parolă + »@ mail.google.com / mail / feed / atom –no-check-certificate»

temp = os.popen (com)
msg = temp.read ()
index = string.find (msg, » »)
index2 = string.find (msg, » »)
fc = int (msg [index + 11: index2])

dacă fc == 0:
tipărește „0 nou”
altceva:
print str (fc) + »nou»

Deci, acum aveți 7 fișiere:

În dosar: ~
-> .startconky << - face executabil

În folderul: ~ / Conky
-> conkymain
-> conkyforecast
-> conkymail

și în folderul: ~ / Conky / scripts
-> conkyForecast.py << - face executabil
-> myweather.template

și în folderul: ~ / Conky / scripts / mail
conkyEmail.py << - face executabil

Și atât, clarificări, unde scrie / home / user / ... numele tău de utilizator merge și în partea în care merg datele Gmail, am evidențiat în culori unde trebuie să îți pui datele.

pentru a ucide procesul conky scrieți pe o consolă

ucide Conky

pentru a rula conky write pe o consolă

./.startconky

odată ce ai reglat totul, dacă vrei ca conky să înceapă fiecare sesiune

Sistem -> Preferințe -> Sesiuni și în programele de pornire îl adăugăm

În Nume putem scrie Conky, în Order ./.startconky cu asta va începe de fiecare dată când porniți computerul.

Gata, sper să te ajute.


Lasă comentariul tău

Adresa ta de email nu va fi publicată. Câmpurile obligatorii sunt marcate cu *

*

*

  1. Responsabil pentru date: Miguel Ángel Gatón
  2. Scopul datelor: Control SPAM, gestionarea comentariilor.
  3. Legitimare: consimțământul dvs.
  4. Comunicarea datelor: datele nu vor fi comunicate terților decât prin obligație legală.
  5. Stocarea datelor: bază de date găzduită de Occentus Networks (UE)
  6. Drepturi: în orice moment vă puteți limita, recupera și șterge informațiile.