Conky, min inställning

Ubunlog

37 minuter

Fecfactor bad mig igår att publicera konfigurationen för conky som jag visar i skärmdumpen nedan

Som du kan se finns det 3 conkys som körs med hjälp av ett skript, dess konfiguration baseras på det här inlägget publicerad av användaren Bruce M. i forumet för Ubuntu-Ar med vissa modifieringar i mail conky, vilket i mitt fall är för Gmail.

I referensinlägget förklaras det väldigt bra av Bruce, men också som ett minneshjälpmedel för mig, jag kommer att kopiera stegen som ska följas och koden för mina tankar för den som har det.

Naturligtvis måste vi ha conky, curl och python installerat så vi skriver in en konsol:

sudo apt-get installera conky curl python

Källan till väder.ttf och pilar.ttf är här. Månens källa .ttf är här när du har laddat ner dem måste du kopiera dem till / usr / share / fonts

Låt oss nu skapa vårt skript som heter ~. / Startconky

gksudo gedit ~ / .startconky

inuti den tomma filen klistrar vi in ​​följande

#! / Bin / bash
sova 0 & # 0 bra för Xfce - använd 20 till 30 för Gnome
conky -c ~ / Conky / conkymain &
#sleep 0 & # 0 bra för Xfce - använd 1 för Gnome
conky -c ~ / Conky / conkyforecast &
#sleep 0 & # 0 bra för Xfce - använd 1 för Gnome
conky -c ~ / Conky / conkymail &

Nu skapar vi conkymain-filen i ~ / Conky-mappen, annars har vi Conky-mappen, vi måste skapa den.

gedit ~ / Conky / conkymain

Jag använder teckensnittet Calibri, om du inte har det, byt ut det mot vad du vill.

Vi håller fast vid det som följer

bakgrund nr
own_window ja
own_window_transparent ja
own_window_hints undecorated, below, sticky, skip_taskbar, skip_pager
egna_fönster_färg svart
double_buffer ja
use_spacer kvar
use_xft ja
font calibri: storlek = 9
xftfont calibri: storlek = 9
xftalpha 0.5
update_interval 5.0
versal nej # ställ in på ja om du vill att all text ska vara versal
stippled_border 3
gräns_marginal 9
gränsvidd 10
standard_färg vit
default_outline_color svart
default_shade_color svart
färg0 cyan
färg1 ljusblå
färg2 orange
färg3 gul
färg4 vete
färg5 vit
färg6 vit
färg7 vit
färg8 vit
färg9 vit
inriktning topp_höger # eller övre vänster, nedre vänster, nedre höger
gap_x 10
35
text_buffer_size 128 # använd 1024 för prognosen
no_buffers ja # Subtrahera filsystembuffertar från använt minne?
draw_borders nr
draw_outline ja # förstärker text om ja
draw_shades ja # skuggfärg svart

TEXT
$ {font calibri: size = 12} $ {alignc} $ {color1} $ sysname $ kernel på $ machine} $ color $ font
$ {font calibri: size = 12} $ {alignc} $ {color2} $ {exec whoami} @ $ nodename $ color $ font
$ {color0} $ {hr 1} $ färg
$ {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 $ color
$ {color0} $ {hr 1} $ färg
$ {voffset 5} $ {color2} CPU: $ {alignc} $ color $ running_processes $ {color1} / $ color $ processer $ {alignr 2} $ {color2} $ {cpubar cpu0 14,80} $ color
$ {color1} $ {voffset -16} $ {alignr 5} $ cpu% $ färg
$ {voffset 2} $ {color1} Last Genomsnitt ($ {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} $ färg
$ {color1} $ {voffset -16} $ {alignr 5} $ memperc% $ färg
$ {voffset 2} $ {color1} Buffrad: $ color $ {buffers} $ {alignr 2} $ {color1} Cachad: $ 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} $ färg
$ {voffset 5} $ {color2} HD-information $ {color1} - $ color Gratis $ {color1} - Används - $ {color2} Totalt
$ {voffset 5} $ {color1} Rot: $ color $ {fs_free_perc /}% $ {alignr 2} $ {fs_free /} $ {color2} / $ {color1} $ {fs_used /} $ color / $ {color2} $ {fs_size /} $ färg
$ {color1} Hem: $ color $ {fs_free_perc / home / user}% $ {alignr 2} $ {fs_free / home / user} $ {color2} / $ {color1} $ {fs_used / home / user} $ color / $ {color2} $ {fs_size / home / user} $ färg
$ {color0} $ {hr 1} $ färg
$ {color1} Från: $ color Buenos Aires, Argentina
$ {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} idag: $ font $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = CC} $ färg $ {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 Pilar: storlek = 20} $ {color4} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = BF} $ color $ font
$ {alignc 10} $ {voffset 5} $ {color4} Vind: $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = WS} $ färg
$ {color1} Luftfuktighet: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = HM} $ {alignr 2} $ {color1} Nederbörd: $ {color3} $ { execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = PC} $ färg
$ {alignc} $ {color1} Tryck: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = BR} - $ {color3} $ {execi 3600 python ~ / Conky /scripts/conkyForecast.py –location = ARBA0009 –datatype = BD} $ färg
$ {color4} $ {hr} $ färg
$ {color1} Soluppgång: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = SR} $ {alignr 2} $ {color1} Solnedgång: $ {color3} $ { execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = SS} $ färg
$ {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 $ färg
$ {color0} $ {hr} $ färg
$ {voffset 5} $ {color2} IP: $ {alignc} $ color $ {addr eth0}
$ {color1} Ner: $ color $ {downspeed eth0} k / s $ {alignr 2} $ {color1} Upp: $ color $ {upspeed eth0} k / s
$ {color1} Totalt: $ color $ {totaldown eth0} $ {alignr 2} $ {color1} Totalt: $ color $ {totalup eth0}
$ {color1} Inkommande: $ color $ {tcp_portmon 1 32767 count} $ {color1} Utgående: $ color $ {tcp_portmon 32768 61000 count} $ {alignr 2} $ {color1} Totalt: $ color $ {tcp_portmon 1 65535 count}
$ {voffset 5} $ {color2} Anslutningar: $ 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} $ färg

vi skapar filen ~ / Conky / conkyforecast

gedit ~ / Conky / conkyforecast

och vi klistrar in följande

bakgrund nr
own_window ja
own_window_transparent ja
own_window_hints undecorated, below, sticky, skip_taskbar, skip_pager
egna_fönster_färg svart
double_buffer ja
use_spacer kvar
use_xft ja
font calibri: storlek = 8
xftfont calibri: storlek = 8
xftalpha 0.5
update_interval 5.0
versal nej # ställ in på ja om du vill att all text ska vara versal
stippled_border 3
gräns_marginal 9
gränsvidd 10
standard_färg vit
default_outline_color svart
default_shade_color svart
färg0 cyan
färg1 ljusblå
färg2 orange
färg3 gul
färg4 vete
färg5 vit
färg6 vit
färg7 vit
färg8 vit
färg9 vit
inriktning bottom_left # eller top_left, bottom_left, bottom_right
gap_x 10
35
text_buffer_size 1024 # använd 1024 för prognosen
no_buffers ja # Subtrahera filsystembuffertar från använt minne?
draw_borders nr
draw_outline ja # förstärker text om ja
draw_shades ja # skuggfärg svart

TEXT
$ {color4} $ {font calibri: size = 11} Utökad prognos $ font $ color
$ {color0} $ {hr} $ färg
$ {color4} $ {font calibri: size = 9} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –template = / home / user / Conky / scripts / myweather.template} $ font $ Färg

vi skapar filen ~ / Conky / conkymail

gedit ~ / Conky / conkymail

vi klistrar in följande i filen

bakgrund nr
own_window ja
own_window_transparent ja
own_window_hints undecorated, below, sticky, skip_taskbar, skip_pager
egna_fönster_färg svart
double_buffer ja
use_spacer kvar
use_xft ja
font calibri: storlek = 8
xftfont calibri: storlek = 8
xftalpha 0.5
update_interval 5.0
versal nej # ställ in på ja om du vill att all text ska vara versal
stippled_border 3
gräns_marginal 9
gränsvidd 10
standard_färg vit
default_outline_color svart
default_shade_color svart
färg0 cyan
färg1 ljusblå
färg2 orange
färg3 gul
färg4 vete
färg5 vit
färg6 vit
färg7 vit
färg8 vit
färg9 vit
inriktning bottom_left # eller top_left, bottom_left, bottom_right
gap_x 565
35
text_buffer_size 128 # använd 1024 för prognosen
no_buffers ja # Subtrahera filsystembuffertar från använt minne?
draw_borders nr
draw_outline ja # förstärker text om ja
draw_shades ja # skuggfärg svart

TEXT
$ {font calibri: size = 11} $ {alignc} $ {color4} Gmail
$ {color0} $ {hr} $ färg
$ {font calibri: size = 11} $ {color4} Vi har $ {color3} $ {execi 300 python ~ / Conky / scripts / mail / conkyEmail.py} $ {color4} email (s) $ font

Vi skapar en fil i ~ / Conky / scripts / conkyForecast.py (vi måste skapa skriptmappen)

gedit ~ / Conky / scripts / conkyForecast.py

#! / usr / bin / python
# - * - kodning: utf-8 - * -
################################################################# ####################################
# conkyForecast.py är ett (inte så) enkelt (längre) pythonscript att samla
# information om det aktuella vädret för användning i conky.
#
# Författare: Kaivalagi
# Skapad: 13-04-2008
# Ändringar:
# 14/04/2008 Tillåt dagintervall för prognosdata
# 14/04/2008 Sök efter anslutning till xoap-tjänsten
# 18/04/2008 Tillåt inställning av mellanslag för utdata i intervall
# 18/04/2008 Tillåt natt- och dagsprognos
# 18/04/2008 Stödläge för villkorskodtext «CC» -alternativ, i väntan på spanska översättning
# 18/04/2008 Använd betning för klassdata istället för att öppna xml, detta kringgår behovet av att förhöra cachadata
# 19/04/2008 Tillagd spansk villkorstext - Tack Bruce M
# 19/04/2008 Tillagd isnumerisk kontroll av alla numeriska utdata med enhetssuffix
# 19/04/2008 Ändrad betongfilnamn för att inkludera platskod
# 19/04/2008 Tillagd spansk veckodagskonvertering via lokal
# 20/04/2008 Lade anständigt kommandot argument parser
# 20/04/2008 Lagt till - alternativet kort veckodag, om det ges veckodag förkortas datatypen till 3 tecken
# 21/04/2008 Fasta språkalternativ för prognosutdata
# 21/04/2008 Lagt till –mallalternativ för att tillåta anpassad utdata med ett enda exec-samtal 🙂
# 21/04/2008 Lagt till –alternativ för dolda enheter för att ta bort till exempel mph och C från utdata
# 23/04/2008 Borttagen –periodiskt alternativ från mallen, detta MÅSTE ställas in som ett standardalternativ på skriptsamtalet och inte användas i mallfilen.
# 23/04/2008 Readded –periodiskt alternativ till mall, vilket möjliggör metriska eller imperiala värden per datatyp. Obs! När du använder mallar fungerar inte kommandoradsalternativet.
# 23/04/2008 Lagt till utdata som meddelar användaren om den angivna platsen är dålig
# 24/04/2008 Tillagd hantering för ingen anslutning, återgår till cachad data nu (fel om det inte finns någon cache). Tester genom att försöka öppna xoap.weather.com
# 24/04/2008 Fixade Celsius till Fahrenheit-konvertering
# 06/05/2008 Uppdaterad webbadress som används efter att webbtjänsten har uppdaterats
# 09/05/2008 Konsoliderat nuvarande tillstånd och prognosdata hämtas till ett samtal
# 09/05/2008 Tillagt soluppgång och solnedgång till datatyper, dessa är specifika för både nuvarande förhållanden och prognosdata
# 09/05/2008 Tillagd månfas, barometeravläsning och barometerbeskrivning till datatyper, dessa är bara specifika för nuvarande förhållanden och så är N / A i prognostiserad produktion
# 09/05/2008 Lade till enhetsomvandlingar för barometer från mb till tum (imperial)
# 09/05/2008 Uppdaterad spansk villkorstext - Tack Bruce M
# 10/05/2008 Lade till franska språkdata - Tack benpaka
# 12/05/2008 Tillagd ny BF (bärande teckensnitt) datatyp för att ge ett piltecken (användas med teckensnitt Arrow.ttf) istället för NSEW-utdata från WD (vindriktning)
# 12/05/2008 Uppdaterad WD-utdata för att vara lokalspecifik, stöder för närvarande standard engelska och spanska - Tack Bruce M
# 18/05/2008 Tillagd ny MF (månteckensnitt) datatyp för att ge ett månteckensnittstecken (felaktiga tecken och inget dedikerat teckensnitt ännu).
# 21/05/2008 För nuvarande förhållanden visar alternativet –datatype = LT nu "känns som" temperatur snarare än den aktuella temperaturen
#
# ALLT:
# Konsolidera pkl-filer till en fil / klass
# Lägg till ett väderteckensnitt baserat på månfasutdata baserat på månikonsdata
# ??? Några fler krav där ute?

importera sys, os, socket, urllib2, datetime, tid
från xml.dom importminidom
från statlig import *
från optparse import OptionParser
importera språk
importera gettext
importera knipa
från matematikimport *

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

klass CommandLineParser:

parser = Ingen

def __init __ (själv):

self.parser = OptionParser ()
self.parser.add_option («- l», »- plats», dest = »plats», standard = »UKXX0103 ″, typ =» sträng », metavar =» KOD », hjälp = u» platskod för väderdata [ standard:% standard], Använd följande webbadress för att bestämma din positionskod efter stadsnamn: http://xoap.weather.com/search/search?where=Norwich »)
self.parser.add_option ("- d", "- datatype", dest = "datatype", default = "HT", type = "string", metavar = "DATATYPE", help = u "[standard:% default] Alternativen för datatyp är: DW (Veckodag), WF (Weather Font Output), LT (Prognos: Låg Temp, Ström: Känns som Temp), HT (Prognos: Hög Temp, Ström: Ström Temp), CC (Ström Villkor), CT (villkorstext), PC (nederbördsmöjlighet), HM (luftfuktighet), WD (vindriktning), WS (vindhastighet), WG (vindbyar), CN (stadens namn), SR (soluppgång), SS (solnedgång), MP (månfas), MF (månteckensnitt), BR (barometeravläsning), BD (barometerbeskrivning). Gäller inte vid kommandoraden när du använder mallar. »)
self.parser.add_option («- s», »- startdag», dest = »startdag», typ = »int», metavar = »NUMMER», hjälp = u »definiera startdagens nummer, om utelämnade nuvarande förhållanden matas ut Gäller inte på kommandoraden när du använder mallar. »)
self.parser.add_option ("- e", "- endday", dest = "endday", type = "int", metavar = "NUMBER", help = u "definiera slutdagens nummer, om endast utgångsdagsdata utelämnas matas ut. Gäller inte vid kommandoraden när du använder mallar. »)
self.parser.add_option («- S», »- mellanslag», dest = »mellanslag», typ = »int», standard = 1, metavar = »NUMMER», hjälp = u »[standard:% standard] Definierar antal mellanslag mellan utdata. Inte tillämpligt på kommandoraden när mallar används. »)
self.parser.add_option («- t», »- mall», dest = »mall», typ = »sträng», metavar = »FIL», hjälp = u »definierar en mallfil för att generera utdata i ett samtal. visningsobjekt i filen har formen {–datatyp = HT –startdag = 1}. Följande är möjliga alternativ inom varje objekt: –datatyp, –startdag, –ändag, –natt, –kortveckodag, –period, –skärmenheter, –Platser. Observera att de korta formerna för alternativen för närvarande inte stöds! Inget av dessa alternativ är tillämpligt på kommandoraden när du använder mallar. »)
self.parser.add_option («- L», »- locale», dest = »locale», typ = »sträng», hjälp = u »åsidosätter systemets språk för språkutdata (en = engelska, es = spanska, fr = franska, mer kommer)))
self.parser.add_option ("- i", "- imperial", dest = "imperial", default = False, action = "store_true", help = u "begär imperialenheter, om utelämnad utelämnad är i metrisk. Gäller inte vid kommandoraden när du använder mallar. »)
self.parser.add_option («- n», »- night», dest = »night», default = False, action = »store_true», help = u »växla utdata till nattdata, om utelämnad dag utmatning kommer att matas ut. Ej tillämpligt på kommandoraden när du använder mallar. »)
self.parser.add_option («- w», »- shortweekday», dest = »shortweekday», default = False, action = »store_true», help = u »Förkorta veckodagens datatyp till 3 tecken. Gäller inte vid kommandoraden när du använder mallar. »)
self.parser.add_option («- u», »- hideunits», dest = »hideenits», default = False, action = »store_true», help = u »Dölj enheter som mph eller C, gradssymboler (°) är visas fortfarande. Gäller inte vid kommandoraden när du använder mallar. »)
self.parser.add_option ("- v", "- verbose", dest = "verbose", default = False, action = "store_true", help = u "begär detaljerad produktion, ingen bra idé när du kör genom conky!" )
self.parser.add_option ("- r", "- refetch", dest = "refetch", default = False, action = "store_true", help = u "hämta data oavsett utgångsdatum")

def parse_args (själv):
(alternativ, args) = self.parser.parse_args ()
retur (alternativ, args)

def print_help (själv):
returnera self.parser.print_help ()

klass WeatherData:
def __init __ (själv, dag_vecka, låg, hög, villkor_kod, tillstånd_text, nederbörd, luftfuktighet, vind_dir, vind_hastighet, vind_stormar, stad, soluppgång, solnedgång, månfas, mån_ikon, bar_read, bar_desc):
self.day_of_week = u »» + day_of_week
self.low = u »» + låg
självhög = u »» + hög
self.condition_code = u »» + villkor_kod
self.condition_text = u »» + villkor_text
self.precip = u »» + nederbörd
självfuktighet = u »» + luftfuktighet
self.wind_dir = u »» + wind_dir
self.wind_speed = u »» + vindhastighet
self.wind_gusts = u »» + vindstöt
self.city = u »» + stad
self.sunrise = u »» + soluppgång
self.sunset = u »» + solnedgång
self.moon_phase = u »» + månfas
self.moon_icon = u »» + moon_icon
self.bar_read = u »» + bar_read
self.bar_desc = u »» + bar_desc

klass WeatherText:

villkor_text = {
«0»: _ (u »Tornado»),
«1»: _ (u »Tropisk storm»),
«2»: _ (u »Hurricane»),
«3»: _ (u »Svåra åskväder»),
«4»: _ (u »Thunderstorms»),
«5»: _ (u »Blandat regn och snö»),
«6»: _ (u »Mixed Rain and Sleet»),
«7»: _ (u »Blandad nederbörd»),
«8»: _ (u »Freezing Drizzle»),
«9»: _ (u »Drizzle»),
«10»: _ (u »Frystregn»),
«11»: _ (u »Duschar»),
«12»: _ (u »Duschar»),
«13»: _ (u »Snow Flurries»),
«14»: _ (u »Lätt snöduschar»),
«15»: _ (u »Blowing Snow»),
«16»: _ (u »Snow»),
«17»: _ (u »Hail»),
«18»: _ (u »Sleet»),
«19»: _ (u »Damm»),
«20»: _ (u »Dimma»),
«21»: _ (u »Haze»),
«22»: _ (u »Smoke»),
«23»: _ (u »Blustery»),
«24»: _ (u »Blåsig»),
«25»: _ (u »Kall»),
«26»: _ (u »Molnigt»),
«27»: _ (u »Mest molnigt»),
«28»: _ (u »Mest molnigt»),
«29»: _ (u »Delvis molnigt»),
«30»: _ (u »Delvis molnigt»),
«31»: _ (u »Rensa»),
«32»: _ (u »Rensa»),
«33»: _ (u »Rättvis»),
«34»: _ (u »Rättvis»),
«35»: _ (u »Mixed Rain and Hail»),
«36»: _ (u »Het»),
«37»: _ (u »Isolerade åskväder»),
«38»: _ (u »Spridda åskväder»),
«39»: _ (u »Spridda åskväder»),
«40»: _ (u »Spridda duschar»),
«41»: _ (u »Heavy Snow»),
«42»: _ (u »Spridda snöbyar»),
«43»: _ (u »Heavy Snow»),
«44»: _ (u »Delvis molnigt»),
«45»: _ (u »Thunder Showers»),
«46»: _ (u »Snöbyar»),
«47»: _ (u »Isolerade åskväder»),
«Na»: _ (u »N / A»),
"-": _ (a ")
}

villkor_text_es = {
«0»: _ (u »Tornado»),
«1»: _ (u »Tropisk storm»),
«2»: _ (u »Huracá¡n»),
«3»: _ (u »Starka stormar»),
«4»: _ (u »Stormar»),
«5»: _ (u »Blandat regn och snö»),
«6»: _ (u »Mixed Rain and Sleet»),
«7»: _ (u »Sleet»),
«8»: _ (u »Freezing Drizzle»),
«9»: _ (u »Drizzle»),
«10»: _ (u »Frystregn»), # eller frysregn
«11»: _ (u »Duschar»),
«12»: _ (u »Duschar»),
«13»: _ (u »Lätt snö»),
«14»: _ (u »Lätt snö»),
«15»: _ (u »Snow Blizzard»),
«16»: _ (u »Snow»),
«17»: _ (u »Hail»),
«18»: _ (u »Sleet»),
«19»: _ (u »Pulver»),
«20»: _ (u »Dimma»),
«21»: _ (u »Haze»),
«22»: _ (u »Smoke»),
«23»: _ (u »Tempest»),
«24»: _ (u »Blåsig»),
«25»: _ (u »Fráo»),
«26»: _ (u »Mycket molnigt»),
«27»: _ (u »Mest molnigt»),
«28»: _ (u »Mest molnigt»),
«29»: _ (u »Delvis molnigt»),
«30»: _ (u »Delvis molnigt»),
«31»: _ (u »Rensa»),
«32»: _ (u »Rensa»),
«33»: _ (u »Något molnigt»),
«34»: _ (u »Något molnigt»),
«35»: _ (u »Regn med hagel»),
«36»: _ (u »Värme»),
«37»: _ (u »Isolerade stormar»),
«38»: _ (u »Spridda stormar»),
«39»: _ (u »Spridda stormar»),
«40»: _ (u »Spridda duschar»),
«41»: _ (u »Heavy Snow»),
«42»: _ (u »Svaga och spridda snöfall»),
«43»: _ (u »Intense Nevada»),
«44»: _ (u »Spridda moln»),
«45»: _ (u »Stormar»),
«46»: _ (u »Spridda snöfall»),
«47»: _ (u »Isolerade stormar»),
«Na»: _ (u »N / A»),
"-": _ (a ")
}

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

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

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

dag_av_vecka = {
"Idag": _ (eller "Idag"),
«Måndag»: _ (u »måndag»),
«Tisdag»: _ (u »Tisdag»),
«Onsdag»: _ (u »onsdag»),
«Torsdag»: _ (u »Torsdag»),
"Fredag": _ (u "Fredag"),
"Saturday": _ (u "Saturday"),
"Söndag": _ (u "Söndag")
}

day_of_week_short = {
"Idag": _ (u "Nu"),
«Måndag»: _ (u »må»),
«Tisdag»: _ (u »Tis»),
«Onsdag»: _ (u »ons»),
«Torsdag»: _ (u »Tor»),
«Fredag»: _ (u »fre»),
"Saturday": _ (u "Sat"),
"Söndag": _ (u "Sön")
}

day_of_week_en = {
"Idag": _ (u "idag"),
«Måndag»: _ (u »måndag»),
«Tisdag»: _ (eller »tisdag»),
«Onsdag»: _ (u »onsdag»),
«Torsdag»: _ (u »Torsdag»),
«Fredag»: _ (u »fredag»),
"Saturday": _ (u "Saturday"),
"Söndag": _ (u "Söndag")
}

day_of_week_short_en = {
"Idag": _ (u "idag"),
"Måndag": _ (u "mon"),
«Tisdag»: _ (u »hav»),
«Onsdag»: _ (u »ons»),
«Torsdag»: _ (u »tors»),
«Fredag»: _ (u »fre»),
"Saturday": _ (u "sat"),
"Söndag": _ (u "dom")
}

day_of_week_fr = {
«Idag»: _ (u »Aujourd'hui»),
«Måndag»: _ (u »Lundi»),
«Tisdag»: _ (u »Mardi»),
«Onsdag»: _ (u »Mercredi»),
«Torsdag»: _ (u »Jeudi»),
«Fredag»: _ (u »Vendredi»),
"Saturday": _ (u "Samedi"),
"Söndag": _ (u "Dimanche")
}

day_of_week_short_fr = {
«Idag»: _ (u »Auj»),
"Måndag": _ (u "Mån"),
«Tisdag»: _ (u »Mar»),
"Onsdag": _ (u "Mer"),
«Torsdag»: _ (u »Jeu»),
«Fredag»: _ (u »Kom»),
"Saturday": _ (u "Sam"),
"Söndag": _ (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»),
«Ej tillämpligt»: _ (u »«)
}

bärande_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"),
"Deras"),
"SSW": _ (u "SSO"),
«SW»: _ (u »SO»),
"WSW": _ (u "WOW"),
«W»: _ (u »O»),
«WNW»: _ (u »ONO»),
«NW»: _ (u »NO»),
«NNW»: _ (u »NNO»),
«Ej tillämpligt»: _ (u »Ej tillämpligt»)
}

bärande_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"),
"Deras"),
"SSW": _ (u "SSO"),
«SW»: _ (u »SO»),
"WSW": _ (u "WOW"),
«W»: _ (u »O»),
«WNW»: _ (u »ONO»),
«NW»: _ (u »NO»),
«NNW»: _ (u »NNO»),
«Ej tillämpligt»: _ (u »Ej tillämpligt»)
}

klass GlobalWeather:

nuvarande_villkor = []
dagsprognos [[]
nattprognos = []

locale = "in"

alternativ = Ingen
väderxmldoc = «»

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 __ (själv, alternativ):

self.options = alternativ

om self.options.locale == Ingen:
prova:
# self.locale = locale.getdefaultlocale () [0] [0: 2]
self.locale = «es» #kommentera denna linje för att tvinga spanska språk
# self.locale = "fr" # kommentera denna linje för att tvinga franska språk
bortsett från:
skriva ut "språk inte inställt"
annan:
# self.locale = self.options.locale
self.locale = «es» #kommentera denna linje för att tvinga spanska språk
# self.locale = "fr" # kommentera denna linje för att tvinga franska språk

om self.options.verbose == True:
skriv ut >> sys.stdout, "locale set to", self.locale

def getText (själv, nodlista):
rc = ""
för nod i nodlista:
om node.nodeType == node.TEXT_NODE:
rc = rc + nod.data
returnera rc

def getSpaces (själv, mellanslag):
sträng = u »»
om mellanslag == Ingen:
sträng = själv.DEFAULT_SPACING
annan:
för i inom intervallet (0, mellanslag + 1):
sträng = sträng + u »«
retursträng

def isNumeric (själv, sträng):
prova:
dummy = float (sträng)
återvänd True
bortsett från:
återvänd Falskt

def isConnectionAvailable (själv):
# se till att vi kan komma åt weather.coms server genom att öppna webbadressen
prova:
Usock = urllib2.urlopen ('http://xoap.weather.com')
Usock.close ()
återvänd True
bortsett från:
återvänd Falskt

def getBearingText (själv, bärande):
lager = flottör (lager)
om lager <11.25:
returnera u »N»
elif-lager <33.75:
returnera dig »NNE»
elif-lager <56.25:
returnera u »NE»
elif-lager <78.75:
returnera dig »JAN»
elif-lager <101.25:
returnera u »E»
elif-lager <123.75:
returnera u »ESE»
elif-lager <146.25:
returnera u »SE»
elif-lager <168.75:
returnera u »SSE»
elif-lager <191.25:
returnera u »S»
elif-lager <213.75:
returnera u »SSW»
elif-lager <236.25:
returnera u »SW»
elif-lager <258.75:
returnera u »WSW»
elif-lager <281.25:
returnera u »W»
elif-lager <303.75:
returnera dig »WNW»
elif-lager <326.25:
returnera u »NW»
elif-lager <348.75:
returnera u »NNW»
annan:
returnera «Ej tillämpligt»

def convertCelsiusToFahrenheit (själv, temp):
returstr (int (golv (((float (temp) * 9.0) /5.0) +32)))

def convertKilometresToMiles (själv, dist):
returstr (int (golv (float (dist) * 0.621371192)))

def convertMillibarsToInches (själv, mb):
returstr (int (golv (float (mb) /33.8582)))

def getTemplateList (själv, mall):

mallista = []

för template_part i template.split («{«):
if template_part! = «»:
för template_part i template_part.split ("}"):
if template_part! = «»:
mallatelist.append (u »» + mall_del)

retur malllista

def getOutputText (self, datatype, startday, endday, night, shortweekday, imperial, hideunits, mellanslag):
#Prova:
output = u »»

# definiera nuvarande enheter för utdata
om hideunits == Falskt:
om imperial == Falskt:
tempunit = u »° C»
speedunit = u »km / h»
tryckenhet = u »mb»
annan:
tempunit = u »° F»
speedunit = u »mph»
tryckenhet = u »i»
annan:
tempunit = u »°»
speedunit = u »»
tryckenhet = u »»

om startdag == Ingen: # nuvarande förhållanden

om datatyp == "DW":
om self.locale == "är":
om kort vardag == Sant:
output = WeatherText.day_of_week_short_es [self.current_conditions [0] .day_of_week]
annan:
output = WeatherText.day_of_week_es [self.current_conditions [0] .day_of_week]
elif self.locale == "fr":
om kort vardag == Sant:
output = WeatherText.day_of_week_short_fr [self.current_conditions [0] .day_of_week]
annan:
output = WeatherText.day_of_week_fr [self.current_conditions [0] .day_of_week]
annan:
om kort vardag == Sant:
output = WeatherText.day_of_week_short [self.current_conditions [0] .day_of_week]
annan:
output = WeatherText.day_of_week [self.current_conditions [0] .day_of_week]
elif datatype == "WF": # väder typsnitt
output = WeatherText.conditions_weather_font [self.current_conditions [0] .condition_code]
elif datatype == "LT":
string = self.current_conditions [0] .low
if self.isNumeric (string) == True:
om imperial == True:
string = self.convertCelsiusToFahrenheit (string)
sträng = sträng + tempunit
output = sträng
elif datatype == "HT":
string = self.current_conditions [0] .high
if self.isNumeric (string) == True:
om imperial == True:
string = self.convertCelsiusToFahrenheit (string)
sträng = sträng + tempunit
output = sträng
elif datatype == "CC":
om self.locale == "är":
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]
annan:
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
if self.isNumeric (string) == True:
string = string + u »%»
output = sträng
elif datatype == "HM":
string = self.current_conditions [0]. luftfuktighet
if self.isNumeric (string) == True:
string = string + u »%»
output = sträng
elif datatype == "WD":
string = self.current_conditions [0] .wind_dir
if self.isNumeric (string) == True:
string = self.getBearingText (string)

om self.locale == "är":
output = WeatherText.bearing_text_es [string]
elif self.locale == "fr":
output = WeatherText.bearing_text_fr [string]
annan:
output = sträng

elif datatype == "BF":
string = self.current_conditions [0] .wind_dir
if self.isNumeric (string) == True:
string = WeatherText.bearing_arrow_font [self.getBearingText (string)]
output = sträng
elif datatype == "WS":
string = self.current_conditions [0] .wind_speed
if self.isNumeric (string) == True:
om imperial == True:
string = self.convertKilometresToMiles (string)
sträng = sträng + hastighetsenhet
output = sträng
elif datatype == "WG":
string = self.current_conditions [0] .wind_gusts
if self.isNumeric (string) == True:
om imperial == True:
string = self.convertKilometresToMiles (string)
sträng = sträng + hastighetsenhet
output = sträng
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
elif datatype == "MP":
output = self.current_conditions [0] .moon_phase
elif datatype == "MF":
output = WeatherText.conditions_moon_font [self.current_conditions [0] .moon_icon]
elif datatype == "BR":
string = self.current_conditions [0] .bar_read
if self.isNumeric (string) == True:
om imperial == True:
string = self.convertMillibarsToInches (string)
sträng = sträng + tryckenhet
output = sträng
elif datatype == "BD":
output = self.current_conditions [0] .bar_desc
annan:
output = "\ nFEL: Okänd datatyp begärs"

annat: # prognosdata

om slutdag == Ingen: # om ingen slutdag har ställts in, använd startdag
slutdag = startdag

if night == True: # nattprognos krävs

för dagnummer inom intervallet (startdag, slutdag + 1):

om datatyp == "DW":
om self.locale == "är":
om kort vardag == Sant:
output = output + self.getSpaces (mellanslag) + WeatherText.day_of_week_short_es [self.night_forecast [day_number] .day_of_week]
annan:
output = output + self.getSpaces (mellanslag) + WeatherText.day_of_week_es [self.night_forecast [day_number] .day_of_week]
elif self.locale == "fr":
om kort vardag == Sant:
output = output + self.getSpaces (mellanslag) + WeatherText.day_of_week_short_fr [self.night_forecast [day_number] .day_of_week]
annan:
output = output + self.getSpaces (mellanslag) + WeatherText.day_of_week_fr [self.night_forecast [day_number] .day_of_week]
annan:
om kort vardag == Sant:
output = output + self.getSpaces (mellanslag) + WeatherText.day_of_week_short [self.night_forecast [day_number] .day_of_week]
annan:
output = output + self.getSpaces (mellanslag) + WeatherText.day_of_week [self.night_forecast [day_number] .day_of_week]
elif datatype == "WF": # väder typsnitt
output = output + self.getSpaces (mellanslag) + WeatherText.conditions_weather_font [self.night_forecast [day_number] .condition_code]
elif datatype == "LT":
string = self.night_forecast [day_number] .low
if self.isNumeric (string) == True:
om imperial == True:
string = self.convertCelsiusToFahrenheit (string)
sträng = sträng + tempunit
output = output + self.getSpaces (mellanslag) + sträng

elif datatype == "HT":
string = self.night_forecast [day_number] .high
if self.isNumeric (string) == True:
om imperial == True:
string = self.convertCelsiusToFahrenheit (string)
sträng = sträng + tempunit
output = output + self.getSpaces (mellanslag) + sträng
elif datatype == "CC":
om self.locale == "är":
output = output + self.getSpaces (mellanslag) + WeatherText.conditions_text_es [self.night_forecast [day_number] .condition_code]
elif self.locale == "fr":
output = output + self.getSpaces (mellanslag) + WeatherText.conditions_text_fr [self.night_forecast [day_number] .condition_code]
annan:
output = output + self.getSpaces (mellanslag) + WeatherText.conditions_text [self.night_forecast [day_number] .condition_code]
elif datatype == "CT":
output = output + self.getSpaces (mellanslag) + self.night_forecast [day_number] .condition_text
elif datatype == "PC":
string = self.night_forecast [day_number] .precip
if self.isNumeric (string) == True:
string = string + u »%»
output = output + self.getSpaces (mellanslag) + sträng
elif datatype == "HM":
string = self.night_forecast [day_number]. luftfuktighet
if self.isNumeric (string) == True:
string = string + u »%»
output = output + self.getSpaces (mellanslag) + sträng
elif datatype == "WD":
string = self.night_forecast [day_number] .wind_dir
om self.locale == "är":
output = output + self.getSpaces (mellanslag) + WeatherText.bearing_text_es [string]
elif self.locale == "fr":
output = output + self.getSpaces (mellanslag) + WeatherText.bearing_text_fr [string]
annan:
output = output + self.getSpaces (mellanslag) + sträng

elif datatype == "BF":
output = output + self.getSpaces (mellanslag) + WeatherText.bearing_arrow_font [self.night_forecast [day_number] .wind_dir]
elif datatype == "WS":
string = self.night_forecast [day_number] .wind_speed
if self.isNumeric (string) == True:
om imperial == True:
string = self.convertKilometresToMiles (string)
sträng = sträng + hastighetsenhet
output = output + self.getSpaces (mellanslag) + sträng
elif datatype == "WG":
string = self.night_forecast [day_number] .wind_gusts
if self.isNumeric (string) == True:
om imperial == True:
string = self.convertKilometresToMiles (string)
sträng = sträng + hastighetsenhet
output = output + self.getSpaces (mellanslag) + sträng
elif datatype == "CN":
output = output + self.getSpaces (mellanslag) + self.night_forecast [day_number] .city
elif datatype == "SR":
output = output + self.getSpaces (blanksteg) + self.night_forecast [day_number] .sunrise
elif datatype == "SS":
output = output + self.getSpaces (mellanslag) + self.night_forecast [day_number] .sunset
elif datatype == "MP":
output = output + self.getSpaces (mellanslag) + self.night_forecast [day_number] .moon_phase
elif datatype == "MF":
output = output + self.getSpaces (mellanslag) + WeatherText.conditions_moon_font [self.night_forecast [day_number] .moon_icon]
elif datatype == "BR":
output = output + self.getSpaces (mellanslag) + self.night_forecast [day_number] .bar_read
elif datatype == "BD":
output = output + self.getSpaces (mellanslag) + self.night_forecast [day_number] .bar_desc
annan:
output = "\ nFEL: Okänd datatyp begärs"
bryta

annat: # dagsprognos önskad

för dagnummer inom intervallet (startdag, slutdag + 1):

om datatyp == "DW":
om self.locale == "är":
om kort vardag == Sant:
output = output + self.getSpaces (mellanslag) + WeatherText.day_of_week_short_es [self.day_forecast [day_number] .day_of_week]
annan:
output = output + self.getSpaces (mellanslag) + WeatherText.day_of_week_es [self.day_forecast [day_number] .day_of_week]
elif self.locale == "fr":
om kort vardag == Sant:
output = output + self.getSpaces (mellanslag) + WeatherText.day_of_week_short_fr [self.day_forecast [day_number] .day_of_week]
annan:
output = output + self.getSpaces (mellanslag) + WeatherText.day_of_week_fr [self.day_forecast [day_number] .day_of_week]
annan:
om kort vardag == Sant:
output = output + self.getSpaces (mellanslag) + WeatherText.day_of_week_short [self.day_forecast [day_number] .day_of_week]
annan:
output = output + self.getSpaces (mellanslag) + WeatherText.day_of_week [self.day_forecast [day_number] .day_of_week]
elif datatype == "WF": # väder typsnitt
output = output + self.getSpaces (mellanslag) + WeatherText.conditions_weather_font [self.day_forecast [day_number] .condition_code]
elif datatype == "LT":
string = self.day_forecast [day_number] .low
if self.isNumeric (string) == True:
om imperial == True:
string = self.convertCelsiusToFahrenheit (string)
sträng = sträng + tempunit
output = output + self.getSpaces (mellanslag) + sträng
elif datatype == "HT":
string = self.day_forecast [day_number] .high
if self.isNumeric (string) == True:
om imperial == True:
string = self.convertCelsiusToFahrenheit (string)
sträng = sträng + tempunit
output = output + self.getSpaces (mellanslag) + sträng
elif datatype == "CC":
om self.locale == "är":
output = output + self.getSpaces (mellanslag) + WeatherText.conditions_text_es [self.day_forecast [day_number] .condition_code]
elif self.locale == "fr":
output = output + self.getSpaces (mellanslag) + WeatherText.conditions_text_fr [self.day_forecast [day_number] .condition_code]
annan:
output = output + self.getSpaces (mellanslag) + WeatherText.conditions_text [self.day_forecast [day_number] .condition_code]
elif datatype == "CT":
output = output + self.getSpaces (mellanslag) + self.day_forecast [day_number] .condition_text
elif datatype == "PC":
string = self.day_forecast [day_number] .precip
if self.isNumeric (string) == True:
string = string + u »%»
output = output + self.getSpaces (mellanslag) + sträng
elif datatype == "HM":
string = self.day_forecast [day_number]. luftfuktighet
if self.isNumeric (string) == True:
string = string + u »%»
output = output + self.getSpaces (mellanslag) + sträng
elif datatype == "WD":
string = self.day_forecast [day_number] .wind_dir

om self.locale == "är":
output = output + self.getSpaces (mellanslag) + WeatherText.bearing_text_es [string]
elif self.locale == "fr":
output = output + self.getSpaces (mellanslag) + WeatherText.bearing_text_fr [string]
annan:
output = output + self.getSpaces (mellanslag) + sträng

elif datatype == "BF":
output = output + self.getSpaces (mellanslag) + WeatherText.bearing_arrow_font [self.day_forecast [day_number] .wind_dir]
elif datatype == "WS":
string = self.day_forecast [day_number] .wind_speed
if self.isNumeric (string) == True:
om imperial == True:
string = self.convertKilometresToMiles (string)
sträng = sträng + hastighetsenhet
output = output + self.getSpaces (mellanslag) + sträng
elif datatype == "WG":
string = self.day_forecast [day_number] .wind_gusts
if self.isNumeric (string) == True:
om imperial == True:
string = self.convertKilometresToMiles (string)
sträng = sträng + hastighetsenhet
output = output + self.getSpaces (mellanslag) + sträng
elif datatype == "CN":
output = output + self.getSpaces (mellanslag) + self.day_forecast [day_number] .city
elif datatype == "SR":
output = output + self.getSpaces (mellanslag) + self.day_forecast [day_number] .sunrise
elif datatype == "SS":
output = output + self.getSpaces (mellanslag) + self.day_forecast [day_number] .sunset
elif datatype == "MP":
output = output + self.getSpaces (mellanslag) + self.day_forecast [day_number] .moon_phase
elif datatype == "MF":
output = output + self.getSpaces (mellanslag) + WeatherText.conditions_moon_font [self.day_forecast [day_number] .moon_icon]
elif datatype == "BR":
output = output + self.getSpaces (mellanslag) + self.day_forecast [day_number] .bar_read
elif datatype == "BD":
output = output + self.getSpaces (mellanslag) + self.day_forecast [day_number] .bar_desc
annan:
output = u »\ nFEL: Okänd datatyp begärs»
bryta

output = u »» + output.strip (u »«) # förlorar ledande / efterföljande mellanslag
returutgång

#bortsett från:
#print "getOutputText: Oväntat fel:", sys.exc_info () [0]

def getOutputTextFromTemplate (själv, mall):
#Prova:

# nycklar till malldata
DATATYPE_KEY = "–datatype ="
STARTDAY_KEY = "–startdag ="
ENDDAY_KEY = "–endday ="
NIGHT_KEY = "–natt"
SHORTWEEKDAY_KEY = "–kort veckodag"
IMPERIAL_KEY = "–period"
HIDEUNITS_KEY = "–hideenheter"
SPACES_KEY = "–spaces ="

output = u »»

optionfound = Falskt

# ladda in filen
prova:
fileinput = öppen (self.options.template)
mall = fileinput.read ()
fileinput.close ()
bortsett från:
output = u »Mallfilen hittades inte!»

templatelist = self.getTemplateList (mall)

# låter oss gå igenom mallistan och bestämma utdata för varje hittat objekt
för i inom intervallet (0, len (mallista) -1):

pos = mallista [i] .find (DATATYPE_KEY)
om pos! = -1:
optionfound = Sant
pos = pos + len (DATATYPE_KEY)
datatyp = mallista [i] [pos: pos + 4]. remsa («}»). remsa («{«). remsa («-«). remsa (»«)
annan:
datatyp = Ingen

pos = malllista [i] .find (STARTDAY_KEY)
om pos! = -1:
optionfound = Sant
pos = pos + len (STARTDAY_KEY)
startday = int (mallista [i] [pos: pos + 4]. strip ("}"). strip ("{"). strip ("-"). strip (""))
annan:
startdag = Ingen

pos = mallista [i] .find (ENDDAY_KEY)
om pos! = -1:
optionfound = Sant
pos = pos + len (ENDDAY_KEY)
slutdag = int (mallista [i] [pos: pos + 4]. strip ("}"). strip ("{"). strip ("-"). strip (""))
annan:
slutdag = Ingen

pos = mallista [i] .find (NIGHT_KEY)
om pos! = -1:
optionfound = Sant
natt = sant
annan:
natt = Falskt

pos = mallista [i] .find (SHORTWEEKDAY_KEY)
om pos! = -1:
optionfound = Sant
kort vardag = sant
annan:
kort vardag = Falskt

pos = mallista [i] .find (IMPERIAL_KEY)
om pos! = -1:
optionfound = Sant
imperial = sant
annan:
imperial = Falsk

pos = mallista [i] .find (HIDEUNITS_KEY)
om pos! = -1:
optionfound = Sant
hideunits = Sant
annan:
gömstycken = falskt

pos = mallista [i] .find (SPACES_KEY)
om pos! = -1:
optionfound = Sant
pos = pos + len (SPACES_KEY)
mellanslag = int (mallista [i] [pos: pos + 4]. remsa («}»). remsa («{«). remsa («-«). remsa (»«))
annan:
mellanslag = 1

om optionfound == Sant:
templatelist [i] = self.getOutputText (datatyp, startdag, slutdag, natt, kort veckodag, imperial, dolda enheter, mellanslag)
optionfound = Falskt

# gå igenom listan som sammanfogar produktionen nu när den har fyllts
för artikel i mallista:
output = output + artikel

returutgång

#bortsett från:
#print "getOutputTextFromTemplate: Oväntat fel:", sys.exc_info () [0]

def fetchData (själv):

# alltid hämta metriska data, använd konversationsfunktioner på denna data
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)

om self.isConnectionAvailable () == Falskt:
om os.path.exists (file_path_current):
RefetchData = Falskt
annat: # ingen anslutning, ingen cache, bang!
skriva ut "Ingen internetanslutning är tillgänglig och ingen cachad väderinformation finns."
elif self.options.refetch == Sant:
RefetchData = Sant
annan:
# behöver data hämtas igen?
om os.path.exists (file_path_current):
lastmodDate = time.localtime (os.stat (file_path_current) [ST_MTIME])
expiryDate = (datetime.datetime.today () - datetime.timedelta (minuter = self.EXPIRY_MINUTES)). schema ()

if expiryDate> lastmodDate:
RefetchData = Sant
annan:
RefetchData = Falskt
annan:
RefetchData = Sant

# hämta aktuella villkor, antingen från webbplatsen eller genom att "avmarkera"
om RefetchData == True:

# skaffa aktuella villkor från xoap-tjänsten
prova:

# 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 & enhet = m '
om self.options.verbose == True:
skriva ut >> sys.stdout, «hämta väderdata från«, url

Usock = urllib2.urlopen (url)
xml = usock.read ()
Usock.close ()
self.weatherxmldoc = minidom.parseString (xml)
bortsett från:
skriv ut "fetchData: Oväntat fel:", sys.exc_info () [0]
skriva ut "Det går inte att kontakta väderkällan för aktuella förhållanden"

# berätta för användaren om platsen är dålig ...
hittat = xml.find ("Ogiltig plats tillhandahålls")
om hittat! = -1:
skriv ut "Ogiltig plats tillhandahålls"

# utfråga väderdata, ladda in i klassstrukturen och beta den
prova:

# förbereda listor över väderdata
self.current_conditions = []
self.day_forecast = []
self.night_forecast = []

# samla in allmän information
väder_n = self.weatherxmldoc.documentElement
location_n = weather_n.getElementsByTagName ('loc') [0]
city_n = location_n.getElementsByTagName ('dnam') [0]
stad = self.getText (city_n.childNodes)

# samla in aktuella villkor
day_of_week = u »Idag»
nederbörd = u »Ej tillämpligt»
sunrise_n = location_n.getElementsByTagName ('sunr') [0]
sunrise = self.getText (sunrise_n.childNodes)
sunset_n = location_n.getElementsByTagName ('suns') [0]
solnedgång = 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 ('icon') [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 ('vind') [0]
wind_speed_n = wind_n.getElementsByTagName (s) [0]
wind_speed = self.getText (wind_speed_n.childNodes)
wind_gust_n = wind_n.getElementsByTagName ('gust') [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)
fuktighet_n = nuvarande_förhållande_n.getElementsByTagName ('hmid') [0]
fuktighet = self.getText (fuktighet_n.barnNoder)
moon_n = current_condition_n.getElementsByTagName ('moon') [0]
moon_icon_n = moon_n.getElementsByTagName ('ikon') [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, fukt, wind_rikting, wind_hastighet, wind_storm, city, sunrise, sunset, moon_phase, moon_icon, bar_read, bar_desc)
self.current_conditions.append (current_conditions_data)

# samla in prognosdata
bar_read = u »Ej tillämpligt»
bar_desc = u »Ej tillämpligt»
moon_phase = u »Ej tillämpligt»
moon_icon = u »na»
forecast_n = weather_n.getElementsByTagName ('dayf') [0]
day_nodes = forecast_n.getElementsByTagName ('dag')

för dag i dag_noder:
day_of_week = day.getAttribute ('t')
day_of_year = day.getAttribute ('dt')
high_temp_n = day.getElementsByTagName ('hej') [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]
sunrise = self.getText (sunrise_n.childNodes)
sunset_n = day.getElementsByTagName ('suns') [0]
solnedgång = self.getText (sunset_n.childNodes)

# dagars prognosspecifik data
daytime_n = day.getElementsByTagName ('del') [0] # dag
villkorskod_n = dagtid_n.getElementsByTagName ('ikon') [0]
villkorskod = själv.getText (villkorskod_n.barnNoder)
condition_n = daytime_n.getElementsByTagName ('t') [0]
villkor = själv.getText (villkor_n.barnNoder)
precip_n = daytime_n.getElementsByTagName ('ppcp') [0]
fällning = self.getText (fäll_n.barnNoder)
fuktighet_n = dagtid_n.getElementsByTagName ('hmid') [0]
fuktighet = self.getText (fuktighet_n.barnNoder)
wind_n = daytime_n.getElementsByTagName ('vind') [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 ('gust') [0]
wind_gusts = self.getText (wind_gusts_n.childNodes)
day_forecast_data = WeatherData (day_of_week, low_temp, high_temp, condition_code, skick, nederbörd, luftfuktighet, vindriktning, vindhastighet, vindstormar, stad, soluppgång, solnedgång, månfas, moon_icon, bar_read, bar_desc)
self.day_forecast.append (day_forecast_data)

# nattprognos specifik data
daytime_n = day.getElementsByTagName ('del') [1] # natt
villkorskod_n = dagtid_n.getElementsByTagName ('ikon') [0]
villkorskod = själv.getText (villkorskod_n.barnNoder)
condition_n = daytime_n.getElementsByTagName ('t') [0]
villkor = själv.getText (villkor_n.barnNoder)
precip_n = daytime_n.getElementsByTagName ('ppcp') [0]
fällning = self.getText (fäll_n.barnNoder)
fuktighet_n = dagtid_n.getElementsByTagName ('hmid') [0]
fuktighet = self.getText (fuktighet_n.barnNoder)
wind_n = daytime_n.getElementsByTagName ('vind') [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 ('gust') [0]
wind_gusts = self.getText (wind_gusts_n.childNodes)
night_forecast_data = WeatherData (dag_av_vecka, låg_temp, hög_temp, villkor_kod, tillstånd, nederbörd, luftfuktighet, vind_riktning, vind_hastighet, vindstormar, stad, soluppgång, solnedgång, månfas, moon_icon, bar_read, bar_desc)
self.night_forecast.append (night_forecast_data)

# pickle data för nästa gång!
fileoutput = öppen (file_path_current, 'w')
pickle.dump (self.current_conditions, fileoutput)
fileoutput.close ()

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

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

bortsett från:
skriv ut "fetchData: Oväntat fel:", sys.exc_info () [0]
skriva ut "Det går inte att förhöra väderdata"

annat: # hämta väderdata från inlagda klassfiler
om self.options.verbose == True:
skriva ut >> sys.stdout, «hämta väderdata från filen:«, file_path_current

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

om self.options.verbose == True:
skriv ut >> sys.stdout, "hämta dagsprognosdata från filer:", file_path_dayforecast, file_path_nightforecast

fileinput = öppen (file_path_dayforecast, 'r')
self.day_forecast = pickle.load (fileinput)
fileinput.close ()

om self.options.verbose == True:
skriva ut >> sys.stdout, «hämta dagsprognosdata från filer:«, file_path_nightforecast, file_path_nightforecast

fileinput = öppen (file_path_nightforecast, 'r')
self.night_forecast = pickle.load (fileinput)
fileinput.close ()

def outputData (själv):
#Prova:

om self.options.template! = Ingen:

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

annan:

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)

utskrift.encode ("utf-8")

#bortsett från:
#print «outputData: Oväntat fel:«, sys.exc_info () [0]

om __name__ == "__main__":

parser = CommandLineParser ()
(alternativ, args) = parser.parse_args ()

om options.verbose == Sant:
skriv ut >> sys.stdout, "location:", options.location
skriv ut >> sys.stdout, "imperial:", options.imperial
skriv ut >> sys.stdout, "datatype:", options.datatype
skriv ut >> sys.stdout, "natt:", alternativ. natt
skriv ut >> sys.stdout, "startdag:", options.startday
skriv ut >> sys.stdout, "end day:", options.endday
skriv ut >> sys.stdout, "mellanslag:", alternativ. mellanslag
skriv ut >> sys.stdout, "verbose:", options.verbose
skriv ut >> sys.stdout, "refetch:", options.refetch

# skapa nytt globalt väderobjekt
väder = GlobalWeather (alternativ)
weather.fetchData ()
weather.outputData ()

Vi skapar filen ~ / Conky / scripts / myweather.template

gedit ~ / Conky / scripts / myweather.template

vi klistrar in följande:

{–Datatyp = DW –startdag = 1}: {–datatyp = CC –startdag = 1}
{–Datatype = HT –startday = 1} / {–datatype = LT – startday = 1} Vind från {–datatype = WD – startday = 1} till {–datatype = WS – startday = 1}
Luftfuktighet: {–datatyp = HM –startdag = 1} Nederbörd: {–datatype = PC –startdag = 1}
Soluppgång: {–datatype = SR –startday = 1} Solnedgång: {–datatype = SS –startday = 1}
----------------
{–Datatyp = DW –startdag = 2}: {–datatyp = CC –startdag = 2}
{–Datatype = HT –startday = 2} / {–datatype = LT – startday = 2} Vind från {–datatype = WD – startday = 2} till {–datatype = WS – startday = 2}
Luftfuktighet: {–datatyp = HM –startdag = 2} Nederbörd: {–datatype = PC –startdag = 2}
Soluppgång: {–datatype = SR –startday = 2} Solnedgång: {–datatype = SS –startday = 2}
----------------
{–Datatyp = DW –startdag = 3}: {–datatyp = CC –startdag = 3}
{–Datatype = HT –startday = 3} / {–datatype = LT – startday = 3} Vind från {–datatype = WD – startday = 3} till {–datatype = WS – startday = 3}
Luftfuktighet: {–datatyp = HM –startdag = 3} Nederbörd: {–datatype = PC –startdag = 3}
Soluppgång: {–datatype = SR –startday = 3} Solnedgång: {–datatype = SS –startday = 3}
----------------
{–Datatyp = DW –startdag = 4}: {–datatyp = CC –startdag = 4}
{–Datatype = HT –startday = 4} / {–datatype = LT – startday = 4} Vind från {–datatype = WD – startday = 4} till {–datatype = WS – startday = 4}
Luftfuktighet: {–datatyp = HM –startdag = 4} Nederbörd: {–datatype = PC –startdag = 4}
Soluppgång: {–datatype = SR –startday = 4} Solnedgång: {–datatype = SS –startday = 4}

Vi skapar filen ~ / Conky / scripts / mail / conkyEmail.py (vi måste skapa e-postmappen)

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

och klistra in följande inuti:

import os
importera sträng

# Ange ditt användarnamn och lösenord nedan med dubbla citat
# t.ex. användarnamn = »användarnamn» och lösenord = »lösenord»
användarnamn = »DIN_USUARIO_SINARROBA«
lösenord = »DIN NYCKEL«

com = »wget -O - https: //» + användarnamn + »:» + lösenord + »@ mail.google.com / mail / feed / atom –incheck-certifikat»

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

om fc == 0:
skriva ut "0 nya"
annan:
skriv str (fc) + »ny»

Så nu har du 7 filer:

I mappen: ~
-> .startconky << - gör körbar

I mappen: ~ / Conky
-> conkymain
-> conkyforecast
-> conkymail

och i mappen: ~ / Conky / scripts
-> conkyForecast.py << - gör körbar
-> myweather.template

och i mappen: ~ / Conky / scripts / mail
conkyEmail.py << - gör körbar

Och det är det, förtydliganden, där det står / hem / användare / ... ditt användarnamn går och i den del där Gmail-data går markerade jag i färger där du måste lägga dina data.

för att döda conky-processen, skriv till en konsol

killall conky

att köra conky skriv till en konsol

./.startconky

när du har justerat allt, om du vill att conky ska börja varje session

System—> Inställningar—> Sessioner och i startprogram lägger vi till det

I Namn kan vi skriva Conky, i ordning ./.startconky med att det börjar varje gång du slår på datorn.

Det är det, jag hoppas att det hjälper dig.


Lämna din kommentar

Din e-postadress kommer inte att publiceras. Obligatoriska fält är markerade med *

*

*

  1. Ansvarig för uppgifterna: Miguel Ángel Gatón
  2. Syftet med uppgifterna: Kontrollera skräppost, kommentarhantering.
  3. Legitimering: Ditt samtycke
  4. Kommunikation av uppgifterna: Uppgifterna kommer inte att kommuniceras till tredje part förutom enligt laglig skyldighet.
  5. Datalagring: databas värd för Occentus Networks (EU)
  6. Rättigheter: När som helst kan du begränsa, återställa och radera din information.