Conky, Saját beállítás

A Fecfactor tegnap arra kért, hogy tegyem közzé a conky konfigurációját, amelyet az alábbi képernyőképen mutatok

Mint láthatja, körülbelül 3 konkorról van szó, amelyeket egy szkript segítségével hajtanak végre, konfigurációja ezen alapul tetszik közzétette Bruce M. felhasználó a fórumokon Ubuntu-Ar némi módosítással a mail conky-ban, ami esetemben a Gmail-hez készült.

A referencia-bejegyzésben Bruce nagyon jól megmagyarázza, de számomra memória-segédeszközként átmásolom a követendő lépéseket és a kódjaimat annak, akinek van.

Nos, természetesen telepítenünk kell a conkit, a curl-t és a python-t, így beírjuk a konzolt:

sudo apt-get install conky curl python

A weather.ttf és a nyilak forrása.ttf itt. A hold forrása.ttf itt Miután letöltötte, át kell másolnia őket a / usr / share / fonts fájlba

Most hozzuk létre a ~. / Startconky nevű szkriptünket

gksudo gedit ~ / .startconky

az üres fájl belsejébe a következőket illesztjük be

#! / bin / bash
alvás 0 és # 0 jó az Xfce számára - használjon 20-30-at a Gnome-hoz
conky -c ~ / Conky / conkymain &
#sleep 0 & # 0 jó az Xfce számára - használja az 1-et a Gnome-hoz
conky -c ~ / Conky / conkyforecast &
#sleep 0 & # 0 jó az Xfce számára - használja az 1-et a Gnome-hoz
conky -c ~ / Conky / conkymail &

Most létrehozzuk a conkymain fájlt a ~ / Conky mappában, különben megvan a Conky mappa, létre kell hoznunk.

gedit ~ / Conky / conkymain

A Calibri betűtípust használom, ha nincs, cserélje le bármi másra.

Bennmaradunk a következőkben

háttér sz
saját_ablak igen
saját_ablak_átlátszó igen
own_window_hints díszítetlen, lent, ragadós, skip_taskbar, skip_pager
saját_ablak_szín fekete
double_buffer igen
use_spacer balra
use_xft igen
font calibri: size = 9
xftfont calibri: méret = 9
xftalpha 0.5
update_interval 5.0
A nagybetűs no # értéke igen, ha azt szeretné, hogy az egész szöveg nagybetűvel legyen
határozott_határok 3
határ_jelölés 9
határ_szélesség 10
alapértelmezett_szín fehér
default_outline_color fekete
alapértelmezett_árnyék_szín fekete
szín0 cián
color1 világoskék
szín2 narancssárga
szín3 sárga
szín4 búza
color5 fehér
color6 fehér
color7 fehér
color8 fehér
color9 fehér
igazítás felső_jobb # vagy felső_bal, alsó_bal, alsó_jobb
rés_x 10
35. rés
text_buffer_size 128 # az 1024-et használja az előrejelzéshez
no_buffers yes # Kivonja a fájlrendszer puffereit a használt memóriából?
húzó_határok nem
draw_outline yes # erősíti a szöveget, ha igen
draw_shades igen # shadecolor fekete

TEXT
$ {font calibri: size = 12} $ {alignc} $ {color1} $ sysname $ kernel a $ machine} $ color $ font
$ {font calibri: size = 12} $ {alignc} $ {color2} $ {exec whoami} @ $ nodename $ color $ font
$ {color0} $ {hr 1} $ szín
$ {font calibri: size = 20} $ {alignc} $ {time% H:% M} $ font
$ {font calibri: size = 12} $ {color1} $ {alignc} $ {time% A,% d% b. % Y} $ color $ betűtípus
$ {color3} UpTime: $ {alignr 2} $ uptime $ color
$ {color0} $ {hr 1} $ szín
$ {voffset 5} $ {color2} CPU: $ {alignc} $ color $ running_processes $ {color1} / $ color $ feldolgozza $ {alignr 2} $ {color2} $ {cpubar cpu0 14,80} $ color
$ {color1} $ {voffset -16} $ {alignr 5} $ cpu% $ color
$ {voffset 2} $ {color1} Átlagos terhelés ($ {color3} Min $ {color1}): $ {alignr 2} $ {color3} 1: $ color $ {loadavg 1} $ {color3} 5: $ color $ {loadavg 2} $ {color3} 15: $ color $ {loadavg 3}
$ {voffset 5} $ {color2} RAM: $ color $ mem $ {color2} / $ color $ memmax $ {alignr 2} $ {color2} $ {membar 14,80} $ color
$ {color1} $ {voffset -16} $ {alignr 5} $ memperc% $ color
$ {voffset 2} $ {color1} pufferelve: $ color $ {buffers} $ {alignr 2} $ {color1} Tárolt: $ 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} $ szín
$ {voffset 5} $ {color2} HD információ $ {color1} - $ color Free $ {color1} - Használt - $ {color2} Összesen
$ {voffset 5} $ {color1} Gyökér: $ color $ {fs_free_perc /}% $ {alignr 2} $ {fs_free /} $ {color2} / $ {color1} $ {fs_used /} $ color / $ {color2} $ {fs_size /} $ szín
$ {color1} Főoldal: $ color $ {fs_free_perc / home / user}% $ {alignr 2} $ {fs_free / home / user} $ {color2} / $ {color1} $ {fs_used / home / user} $ color / $ {color2} $ {fs_size / home / user} $ color
$ {color0} $ {hr 1} $ szín
$ {color1} Feladó: $ color Buenos Aires, Argentína
$ {color1} Szél: $ {color2} 34 ° 35'S $ {color1} Hosszú: $ {color2} 58 ° 21'W $ {color1} Alt: $ {color2} 25 m $ szín
$ {voffset 5} $ {color2} $ {font calibri: size = 12} ma: $ font $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = CC} $ szín $ {alignr 2} $ {color1} ST: $ {color2} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = LT}
$ {color3} $ {font Időjárás: 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 nyilak: size = 20} $ {color4} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = BF} $ color $ betűtípus
$ {alignc 10} $ {voffset 5} $ {color4} Szél: $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = WS} $ color
$ {color1} Páratartalom: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = HM} $ {alignr 2} $ {color1} Csapadék: $ {color3} $ { execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = PC} $ color
$ {alignc} $ {color1} Nyomás: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = BR} - $ {color3} $ {execi 3600 python ~ / Conky /scripts/conkyForecast.py –location = ARBA0009 –datatype = BD} $ color
$ {color4} $ {hr} $ szín
$ {color1} Napkelte: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = SR} $ {alignr 2} $ {color1} Naplemente: $ {color3} $ { execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = SS} $ color
$ {voffset 15} $ {color1} Hold: $ {color4} $ {alignr 2} $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = MP} $ color
$ {voffset -20} $ {offset 80} $ {color4} $ {font holdfázisok: size = 20} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = MF} $ font $ szín
$ {color0} $ {hr} $ szín
$ {voffset 5} $ {color2} IP: $ {alignc} $ color $ {addr eth0}
$ {color1} Le: $ color $ {downspeed eth0} k / s $ {alignr 2} $ {color1} Fel: $ color $ {upspeed eth0} k / s
$ {color1} Összesen: $ color $ {totaldown eth0} $ {alignr 2} $ {color1} Összesen: $ color $ {totalup eth0}
$ {color1} Bejövő: $ color $ {tcp_portmon 1 32767 count} $ {color1} Kimenő: $ color $ {tcp_portmon 32768 61000 count} $ {alignr 2} $ {color1} Összesen: $ color $ {tcp_portmon 1 65535 count}
$ {voffset 5} $ {color2} Kapcsolatok: $ color $ {tcp_portmon 32768 61000 count} $ {alignr 2} $ {color2} Szolgáltatás / 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} $ color

létrehozzuk a ~ / Conky / conkyforecast fájlt

gedit ~ / Conky / conkyforecast

és beillesztjük a következőket

háttér sz
saját_ablak igen
saját_ablak_átlátszó igen
own_window_hints díszítetlen, lent, ragadós, skip_taskbar, skip_pager
saját_ablak_szín fekete
double_buffer igen
use_spacer balra
use_xft igen
font calibri: size = 8
xftfont calibri: méret = 8
xftalpha 0.5
update_interval 5.0
A nagybetűs no # értéke igen, ha azt szeretné, hogy az egész szöveg nagybetűvel legyen
határozott_határok 3
határ_jelölés 9
határ_szélesség 10
alapértelmezett_szín fehér
default_outline_color fekete
alapértelmezett_árnyék_szín fekete
szín0 cián
color1 világoskék
szín2 narancssárga
szín3 sárga
szín4 búza
color5 fehér
color6 fehér
color7 fehér
color8 fehér
color9 fehér
igazítás alsó_balra # vagy felső_balra, alsó_balra, lentre_jobbra
rés_x 10
35. rés
text_buffer_size 1024 # az 1024-et használja az előrejelzéshez
no_buffers yes # Kivonja a fájlrendszer puffereit a használt memóriából?
húzó_határok nem
draw_outline yes # erősíti a szöveget, ha igen
draw_shades igen # shadecolor fekete

TEXT
$ {color4} $ {font calibri: size = 11} Kiterjesztett előrejelzés $ font $ color
$ {color0} $ {hr} $ szín
$ {color4} $ {font calibri: size = 9} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –template = / home / user / Conky / scripts / myweather.template} $ font $ szín

létrehozzuk a ~ / Conky / conkymail fájlt

gedit ~ / Conky / conkymail

a következőket illesztjük be a fájlba

háttér sz
saját_ablak igen
saját_ablak_átlátszó igen
own_window_hints díszítetlen, lent, ragadós, skip_taskbar, skip_pager
saját_ablak_szín fekete
double_buffer igen
use_spacer balra
use_xft igen
font calibri: size = 8
xftfont calibri: méret = 8
xftalpha 0.5
update_interval 5.0
A nagybetűs no # értéke igen, ha azt szeretné, hogy az egész szöveg nagybetűvel legyen
határozott_határok 3
határ_jelölés 9
határ_szélesség 10
alapértelmezett_szín fehér
default_outline_color fekete
alapértelmezett_árnyék_szín fekete
szín0 cián
color1 világoskék
szín2 narancssárga
szín3 sárga
szín4 búza
color5 fehér
color6 fehér
color7 fehér
color8 fehér
color9 fehér
igazítás alsó_balra # vagy felső_balra, alsó_balra, lentre_jobbra
rés_x 565
35. rés
text_buffer_size 128 # az 1024-et használja az előrejelzéshez
no_buffers yes # Kivonja a fájlrendszer puffereit a használt memóriából?
húzó_határok nem
draw_outline yes # erősíti a szöveget, ha igen
draw_shades igen # shadecolor fekete

TEXT
$ {font calibri: size = 11} $ {alignc} $ {color4} Gmail
$ {color0} $ {hr} $ szín
$ {font calibri: size = 11} $ {color4} $ {color3} $ {execi 300 python ~ / Conky / scripts / mail / conkyEmail.py} $ {color4} e-mail (ek) $ font van

Hozunk létre egy fájlt a ~ / Conky / scripts / conkyForecast.py fájlban (létre kell hoznunk a szkriptek mappát)

gedit ~ / Conky / scripts / conkyForecast.py

#! / usr / bin / python
# - * - kódolás: utf-8 - * -
########################################################## #################################
A # conkyForecast.py egy (már nem is olyan) egyszerű (már) python parancsfájl összegyűjtése
# az aktuális időjárás részletei a conky használatához.
#
# Szerző: Kaivalagi
# Létrehozva: 13
# Módosítások:
# 14/04/2008 Engedje meg az előrejelzési adatok napi tartományait
# 14/04/2008 Ellenőrizze a kapcsolatot az xoap szolgáltatással
# 18/04/2008 Engedélyezze a tartományok beállítását a távolsági kimenetnél
# 18/04/2008 Engedje meg az éjszakai és nappali előrejelzés kimenetét
# 18/04/2008 Támogassa a feltételkód szöveg "CC" opciójának területi beállításait, várva a spanyol nyelv fordítását
# 18/04/2008 Használja a pácolást az osztályadatokhoz az xml megnyitása helyett, ez megkerüli a tárolt adatok kikérdezésének szükségességét
# 19/04/2008 Spanyol feltétel szöveg hozzáadása - Köszönet Bruce M
# 19/04/2008 Isnumerikus ellenőrzés hozzáadva az összes számkimenetet egység utótaggal
# 19/04/2008 Megváltozott a savanyú fájlok elnevezése a helykóddal együtt
# 19/04/2008 Hozzáadta a spanyol hét napjainak átszámítását területi beállításon keresztül
# 20/04/2008 Hozzáadott egy tisztességes parancs argumentum elemzőt
# 20/04/2008 Hozzáadott –rövid hét napja opció, ha megadja a hét napját, az adattípus 3 karakterre rövidül
# 21/04/2008 Javítva az előrejelzés kimenetének területi beállításai
# 21/04/2008 Hozzáadott –sablon opció az egyedi kimenet engedélyezéséhez egyetlen exec hívással 🙂
# 21/04/2008 - Hideunits opció hozzáadva például az mph és a C eltávolításához a kimenetből
# 23/04/2008 Eltávolítva - imperial opció a sablonból, ezt KELL beállítani a szkripthívás alapértelmezett beállításaként, és nem használható a sablonfájlban.
# 23/04/2008 Elolvasva - a sablonra vonatkozó opció, amely metrikus vagy birodalmi értékeket engedélyez adattípusonként. Megjegyzés: a sablonok használatakor a parancssori opció nem fog működni.
# 23/04/2008 Hozzáadott kimenet, amely értesíti a felhasználót, ha a megadott hely rossz
# 24/04/2008 Hozzáadva a kezelés nélküli kapcsolatot, a gyorsítótárazott adatok visszaállnak (hibaüzenet jelenik meg, ha nincs gyorsítótár). Tesztek az xoap.weather.com megnyitásával
# 24/04/2008 Javítva a Celsius-fahrenheit konverziót
# 06/05/2008 A webszolgáltatás frissítése után használt frissített URL
# 09/05/2008 Összevont aktuális állapot és előrejelzési adatok egyetlen hívásba kerülnek
# 09/05/2008 A napfelkelte és a napnyugta hozzáadódott az adattípusokhoz, ezek mind az aktuális viszonyokra, mind az előrejelzési adatokra jellemzőek
# 09/05/2008 Hozzáadta a holdfázist, a barométer leolvasását és a barométer leírását az adattípusokhoz, ezek csak az aktuális körülményekre vonatkoznak, és így az előrejelzett kimeneten nincsenek
# 09/05/2008 Hozzáadta a barométer egység konverzióit MB-ból hüvelykbe (angol)
# 09/05/2008 Frissített spanyol állapot szöveg - köszönöm Bruce M
# 10/05/2008 Francia nyelvű adatok hozzáadása - köszönöm benpaka
# 12/05/2008 Új BF (fontos betűtípussal) adattípust kapott, hogy nyíl karaktert adjon (használja az Arrow.ttf betűtípussal) a WD (szélirány) NSEW kimenete helyett.
# 12/05/2008 A WD kimenetének frissítése a területi beállítások szerint, jelenleg támogatja az alapértelmezett angol és spanyol nyelvet - köszönet Bruce M-nek
# 18/05/2008 Új MF (hold font) adattípust adott hozzá a moon font karakterhez (helytelen karakterek és még nincs külön betűtípus).
# 21/05/2008 Az aktuális körülményekhez az –datatype = LT opció az aktuális hőmérséklet helyett „érzem magam” hőmérsékletet jelenít meg
#
# MINDEN:
# Konszolidálja a pkl fájlokat egyetlen fájlba / osztályba
# Időjárás-betűtípust adhat a holdfázis kimenete alapján, a Hold ikon adatai alapján
# ??? Van még valami követelmény odakinn?

importálja a sys, os, socket, urllib2, datetime, time értékeket
az xml.dom fájlból importáljon minidomot
stat importból *
az optparse importálásából OptionParser
importálja a területi beállításokat
importálja a gettext-et
import savanyúság
matematikai importból *

APP = »conkyForecast.py»
DIR = os.path.dirname (__fájl__) + '/ területi beállítás'
gettext.bindtextdomain (APP, DIR)
gettext.textdomain (APP)
_ = gettext.gettext

osztály CommandLineParser:

értelmező = Nincs

def __init __ (én):

self.parser = OptionParser ()
self.parser.add_option («- l», »- hely», dest = »hely», alapértelmezett = »UKXX0103 ″, type =» string », metavar =» CODE », help = u» helykód az időjárási adatokhoz [ alapértelmezett:% default], A következő URL segítségével határozza meg a helykódot városnév szerint: http://xoap.weather.com/search/search?where=Norwich »)
self.parser.add_option ("- d", "- adattípus", dest = "adattípus", alapértelmezett = "HT", típus = "karakterlánc", metavar = "DATATÍPUS", help = u "[alapértelmezett:% alapértelmezett] Az adattípus beállításai a következők: DW (hét napja), WF (időjárás betűkészlet kimenet), LT (előrejelzés: alacsony hőmérséklet, jelenlegi: olyan, mint a hőmérséklet), HT (előrejelzés: magas hőmérséklet, aktuális: aktuális hőmérséklet), CC (aktuális) Körülmények), CT (feltételek szövege), PC (csapadék esélye), HM (páratartalom), WD (szélirány), WS (szélsebesség), WG (széllökések), CN (városnév), SR (napkelte), SS (napnyugta), MP (holdfázis), MF (holdfont), BR (barométer leolvasása), BD (barométer leírás). Sablonok használata esetén a parancssorban nem alkalmazható. »)
self.parser.add_option («- s», »- startday», dest = »startday», type = »int», metavar = »NUMBER», help = u »meghatározza a kezdő nap számát, ha kihagyják az aktuális feltételeket . Sablonok használata esetén a parancssorban nem alkalmazható. »)
self.parser.add_option ("- e", "- endday", dest = "endday", type = "int", metavar = "NUMBER", help = u "határozza meg a befejező nap számát, ha csak a kezdő nap adatait hagyja ki kimenet. Sablonok használatakor nem használható a parancssorban. »)
self.parser.add_option («- S», »- szóközök», dest = »szóközök», type = »int», alapértelmezett = 1, metavar = »SZÁM», help = u »[alapértelmezett:% alapértelmezett] Meghatározza a a tartományok közötti kimenet közötti helyek száma. Sablonok használata esetén a parancssorban nem alkalmazható. »)
self.parser.add_option («- t», »- sablon», dest = »sablon», type = »karakterlánc», metavar = »FÁJL», help = u »sablonfájl meghatározása egy kimenet generálásához egy hívás során. a fájlban megjeleníthető elem a következő formátumú: {–datatype = HT –startday = 1}. Az egyes elemeken belül a következő lehetőségek lehetségesek: –datatípus, –startday, –endday, –night, –shortweekday, –perperial, –hideunits, –Spaces. Ne feledje, hogy az opciók rövid formái jelenleg nem támogatottak! Sablonok használata esetén ezek az opciók nem használhatók a parancssorban. »)
self.parser.add_option («- L», »- locale», dest = »locale», type = »string», help = u »felülírja a nyelv kimenetén a rendszer területi beállításait (en = magyar, es = spanyol, fr = francia, még sok más következik) »)
self.parser.add_option ("- i", "- imperial", dest = "imperial", alapértelmezett = Hamis, action = "store_true", help = u "birodalmi egységek kérése, ha a kihagyott kimenet metrikus. Nem alkalmazható itt: parancssablon sablonok használatakor. »)
self.parser.add_option («- n», »- éjszaka», dest = »éjszaka», alapértelmezett = Hamis, action = »store_true», help = u »kapcsolja a kimenetet éjszakai adatokra, ha kihagyja a nappali kimenetet. Sablonok használatakor a parancssorban nem alkalmazható. »)
self.parser.add_option («- w», »- shortweekday», dest = »shortweekday», default = Hamis, action = »store_true», help = u »Rövidítse le a hét napjának adattípusát 3 karakterre. Nem alkalmazható itt: parancssablon sablonok használatakor. »)
self.parser.add_option («- u», »- hideunits», dest = »hideunits», default = False, action = »store_true», help = u »Olyan egységek elrejtése, mint mph vagy C, fok szimbólumok (°) továbbra is látható. Sablonok használata esetén a parancssorban nem alkalmazható. »)
self.parser.add_option ("- v", "- verbose", dest = "verbose", default = False, action = "store_true", help = u "részletes kimenetet kér, nem jó ötlet, amikor a conky-n fut!" )
self.parser.add_option ("- r", "- refetch", dest = "refetch", alapértelmezett = False, action = "store_true", help = u "adatok lekérése az adatok lejártától függetlenül")

def parse_args (self):
(opciók, args) = self.parser.parse_args ()
return (opciók, érvek)

def print_help (self):
return self.parser.print_help ()

osztály WeatherData:
def __init __ (saját, napi_hét, alacsony, magas, feltétel_kód, feltétel_szöveg, csapadék, páratartalom, szélirány, szélsebesség, szél_ undorok, város, napkelte, napnyugta, holdfázis, holdikon, bar_read, bar_desc):
self.day_of_week = u »» + Day_of_week
ön.low = u »» + alacsony
önmagas.magas = u »» + magas
ön.feltétel_kód = u »» + feltétel_kód
ön.feltétel_szöveg = u »» + feltétel_szöveg
ön.precip = u »» + csapadék
ön.nedvesség = u »» + páratartalom
self.wind_dir = u »» + wind_dir
ön.szél_sebesség = u »» + szélsebesség
self.wind_gusts = u »» + wind_gusts
ön.város = u »» + város
én.napfelkelte = u »» + napfelkelte
én.napnyugta = u »» + naplemente
self.moon_phase = u »» + holdfázis
self.moon_icon = u »» + hold_ikon
self.bar_read = u »» + bar_read
self.bar_desc = u »» + bar_desc

osztály WeatherText:

feltételek_szöveg = {
«0»: _ (u »Tornado»),
«1»: _ (u »Trópusi vihar»),
«2»: _ (u »hurrikán»),
«3»: _ (u »Heves zivatarok»),
«4»: _ (u »Zivatarok»),
«5»: _ (u »Vegyes eső és hó»),
«6»: _ (u »Vegyes eső és csapadék»),
«7»: _ (u »Vegyes csapadék»),
«8»: _ (u »Fagyos szitálás»),
«9»: _ (u »Csepegtető»),
«10»: _ (u »Fagyos eső»),
«11»: _ (u »Záporok»),
«12»: _ (u »Záporok»),
«13»: _ (u »Hóporok»),
«14»: _ (u »Enyhén havas eső»),
«15»: _ (u »Fújó hó»),
«16»: _ (u »Hó»),
«17»: _ (u »Üdvözlet»),
«18»: _ (u »Sleet»),
«19»: _ (u »Por»),
«20»: _ (u »Köd»),
«21»: _ (u »Haze»),
«22»: _ (u »Füst»),
«23»: _ (u »Blustery»),
«24»: _ (u »Szeles»),
«25»: _ (u »Hideg»),
«26»: _ (u »Felhős»),
«27»: _ (u »Többnyire felhős»),
«28»: _ (u »Többnyire felhős»),
«29»: _ (u »Részben felhős»),
«30»: _ (u »Részben felhős»),
«31»: _ (u »Töröl»),
«32»: _ (u »Töröl»),
«33»: _ (u »Vásár»),
«34»: _ (u »Vásár»),
«35»: _ (u »Vegyes eső és jégeső»),
«36»: _ (u »Forró»),
«37»: _ (u »Elszigetelt zivatarok»),
«38»: _ (u »Elszórtan zivatarok»),
«39»: _ (u »Elszórtan zivatarok»),
«40»: _ (u »Elszórtan záporok»),
«41»: _ (u »Heves hó»),
«42»: _ (u »Elszórtan hózáporok»),
«43»: _ (u »Heves hó»),
«44»: _ (u »Részben felhős»),
«45»: _ (u »Mennydörgő záporok»),
«46»: _ (u »Hózáporok»),
«47»: _ (u »Elszigetelt zivatarok»),
«Na»: _ (u »N / A»),
"-": _ (a ")
}

feltételek_szöveg_es = {
«0»: _ (u »Tornado»),
«1»: _ (u »Trópusi vihar»),
«2»: _ (u »Huracá¡n»),
«3»: _ (u »Erős viharok»),
«4»: _ (u »Viharok»),
«5»: _ (u »Vegyes eső és hó»),
«6»: _ (u »Vegyes eső és csapadék»),
«7»: _ (u »Sleet»),
«8»: _ (u »Fagyos szitálás»),
«9»: _ (u »Csepegtető»),
«10»: _ (u »Fagyos eső»), # vagy fagyos eső
«11»: _ (u »Záporok»),
«12»: _ (u »Záporok»),
«13»: _ (u »Enyhe hó»),
«14»: _ (u »Enyhe hó»),
«15»: _ (u »Hóvihar»),
«16»: _ (u »Hó»),
«17»: _ (u »Üdvözlet»),
«18»: _ (u »Sleet»),
«19»: _ (u »Por»),
«20»: _ (u »Köd»),
«21»: _ (u »Haze»),
«22»: _ (u »Füst»),
«23»: _ (u »Tempest»),
«24»: _ (u »Szeles»),
«25»: _ (u »Fráo»),
«26»: _ (u »Nagyon felhős»),
«27»: _ (u »Többnyire felhős»),
«28»: _ (u »Többnyire felhős»),
«29»: _ (u »Részben felhős»),
«30»: _ (u »Részben felhős»),
«31»: _ (u »Töröl»),
«32»: _ (u »Töröl»),
«33»: _ (u »Valami felhős»),
«34»: _ (u »Valami felhős»),
«35»: _ (u »Eső jégesővel»),
«36»: _ (u »Hő»),
«37»: _ (u »Elszigetelt viharok»),
«38»: _ (u »Szórt viharok»),
«39»: _ (u »Szórt viharok»),
«40»: _ (u »Elszórtan záporok»),
«41»: _ (u »Heves hó»),
«42»: _ (u »Gyenge és elszórt havazások»),
«43»: _ (u »Intense Nevada»),
«44»: _ (u »Szórt felhők»),
«45»: _ (u »Viharok»),
«46»: _ (vagy »elszórt havazások»),
«47»: _ (u »Elszigetelt viharok»),
«Na»: _ (u »N / A»),
"-": _ (a ")
}

feltételek_szöveg_fr = {
«0»: _ (u »Tornade»),
«1»: _ (u »Tempête Tropicale»),
«2»: _ (vagy »Ouragan»),
«3»: _ (vagy »Erőszakot hirdet»),
«4»: _ (vagy »Orageux»),
«5»: _ (u »Pluie et Neige»),
«6»: _ (u »Pluie et Neige Mouillée»),
«7»: _ (u »Változó középértékek»),
«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»: _ (vagy »Orages Isolés»),
«38»: _ (vagy »Orages Localisés»),
«39»: _ (vagy »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»: _ (vagy »Orages»),
«46»: _ (u »Tempête de Neige»),
«47»: _ (vagy »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 »»),
"-": _ (vagy "")
}

feltételek_havi_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 »»),
"-": _ (vagy "")
}

heti_hét = {
"Ma": _ (vagy "Ma"),
«Hétfő»: _ (u »hétfő»),
«Kedd»: _ (u »kedd»),
«Szerda»: _ (u »szerda»),
«Csütörtök»: _ (u »csütörtök»),
"Péntek": _ (u "péntek"),
"Szombat": _ (u "szombat"),
"Vasárnap": _ (u "vasárnap")
}

hét_rövid napja = {
"Ma": _ (u "Most"),
«Hétfő»: _ (u »hétfő»),
«Kedd»: _ (u »kedd»),
«Szerda»: _ (u »szerda»),
«Csütörtök»: _ (u »cs»),
«Péntek»: _ (u »péntek),
"Szombat": _ (u "szombat"),
"Vasárnap": _ (u "nap")
}

hét_hónapja = {
"Ma": _ (u "ma"),
«Hétfő»: _ (u »hétfő»),
«Kedd»: _ (vagy »kedd»),
«Szerda»: _ (u »szerda»),
«Csütörtök»: _ (u »csütörtök»),
«Péntek»: _ (u »péntek»),
"Szombat": _ (u "szombat"),
"Vasárnap": _ (u "vasárnap")
}

day_of_week_short_hu = {
"Ma": _ (u "ma"),
"Hétfő": _ (u "mon"),
«Kedd»: _ (u »tenger»),
«Szerda»: _ (u »wed»),
«Csütörtök»: _ (u »csütörtök),
"Péntek": _ (u "fri"),
"Szombat": _ (u "sat"),
"Vasárnap": _ (u "dom")
}

hét_hónapja = {
«Ma»: _ (u »Aujourd'hui»),
«Hétfő»: _ (u »Lundi»),
«Kedd»: _ (u »Mardi»),
«Szerda»: _ (u »Mercredi»),
«Csütörtök»: _ (u »Jeudi»),
«Péntek»: _ (u »Vendredi»),
"Szombat": _ (u "Samedi"),
"Vasárnap": _ (u "Dimanche")
}

day_of_week_short_fr = {
«Ma»: _ (u »Auj»),
"Hétfő": _ (u "hétfő"),
«Kedd»: _ (u »márc»),
"Szerda": _ (u "Mer"),
«Csütörtök»: _ (u »Jeu»),
«Péntek»: _ (u »Gyere»),
"Szombat": _ (u "Sam"),
"Vasárnap": _ (u "Dim")
}

csapágy_nyíl_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"),
«ÉNy»: _ (u »g»),
«ÉNy»: _ (u »h»),
«N / A»: _ (u »«)
}

csapágy_szöveg_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"),
"Azok"),
"SSW": _ (u "SSO"),
«SW»: _ (u »SO»),
"WSW": _ (u "WOW"),
«W»: _ (u »O»),
«WNW»: _ (u »ONO»),
«ÉNy»: _ (u »NEM»),
«ÉNy»: _ (u »NNO»),
«N / A»: _ (u »N \ A»)
}

csapágy_szöveg_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"),
"Azok"),
"SSW": _ (u "SSO"),
«SW»: _ (u »SO»),
"WSW": _ (u "WOW"),
«W»: _ (u »O»),
«WNW»: _ (u »ONO»),
«ÉNy»: _ (u »NEM»),
«ÉNy»: _ (u »NNO»),
«N / A»: _ (u »N \ A»)
}

osztály GlobalWeather:

jelenlegi_feltételek = []
előrejelzés = []
éjszakai előrejelzés = []

locale = "in"

opciók = Nincs
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_PERC = 30
DEFAULT_SPACING = u »«

def __init __ (én, opciók):

self.options = opciók

ha self.options.locale == Nincs:
próbálja ki:
# self.locale = locale.getdefaultlocale () [0] [0: 2]
self.locale = «es» # kommentáld ezt a sort a spanyol területi beállítás kényszerítésére
# self.locale = "fr" # jelölje ki ezt a sort a francia területi beállítás kényszerítésére
kivéve:
print "locale not set" nyomtatás
más:
# self.locale = self.options.locale
self.locale = «es» # kommentáld ezt a sort a spanyol területi beállítás kényszerítésére
# self.locale = "fr" # jelölje ki ezt a sort a francia területi beállítás kényszerítésére

ha self.options.verbose == Igaz:
print >> sys.stdout, "locale set", self.locale

def getText (self, nodelist):
rc = ""
csomópont a csomópontlistában:
ha node.nodeType == csomópont.TEXT_NODE:
rc = rc + csomópont.adatok
visszatérés rc

def getSpaces (én, szóköz):
string = u »»
ha szóköz == Nincs:
string = self.DEFAULT_SPACING
más:
i tartományban (0, szóköz + 1):
string = string + u »«
visszatérési karakterlánc

def isNumeric (én, karakterlánc):
próbálja ki:
bábu = úszó (karakterlánc)
vissza True
kivéve:
return Hamis

def isConnectionAvailable (self):
# győződjön meg arról, hogy az URL megnyitásával hozzáférhetünk az weather.com szerveréhez
próbálja ki:
Usock = urllib2.urlopen ('http://xoap.weather.com')
Usock.close ()
vissza True
kivéve:
return Hamis

def getBearingText (önálló, csapágyas):
csapágy = úszó (csapágy)
ha 11.25 alatti csapágy van:
vissza u »N»
elif csapágy <33.75:
vissza u »NNE»
elif csapágy <56.25:
vissza u »ÉK»
elif csapágy <78.75:
vissza u »JAN»
elif csapágy <101.25:
vissza u »E»
elif csapágy <123.75:
vissza u »ESE»
elif csapágy <146.25:
vissza u »SE»
elif csapágy <168.75:
vissza u »SSE»
elif csapágy <191.25:
vissza u »S»
elif csapágy <213.75:
vissza u »SSW»
elif csapágy <236.25:
vissza u »SW»
elif csapágy <258.75:
vissza u »WSW»
elif csapágy <281.25:
vissza u »W»
elif csapágy <303.75:
vissza u »WNW»
elif csapágy <326.25:
vissza u »ÉNY»
elif csapágy <348.75:
vissza u »ÉNy»
más:
vissza «N / A»

def convertCelsiusToFahrenheit (saját, temp):
visszatérő str (int (emelet (((úszó (hőmérséklet) * 9.0) /5.0) +32)))

def convertKilometresToMiles (self, dist):
visszatérő str (int (emelet (float (dist) * 0.621371192)))

def convertMillibarsToInches (self, mb):
visszatérő str (int (emelet (úszó (MB) /33.8582)))

def getTemplateList (én, sablon):

sablonlista = []

for template_part in template.split («{«):
ha template_part! = «»:
sablonrészhez a sablonrészben.split ("}"):
ha template_part! = «»:
templatelist.append (u »» + template_part)

visszatér templatelist

def getOutputText (saját, adattípus, kezdőnap, végnap, éjszaka, rövid hét, birodalmi, rejtett egységek, szóközök):
#próbáld ki:
output = u »»

# határozza meg a kimenet aktuális egységeit
ha hideunits == Hamis:
ha birodalmi == hamis:
tempunit = u »° C»
sebességegység = u »kph»
nyomásegység = u »mb»
más:
tempunit = u »° F»
sebességegység = u »mph»
nyomásegység = u »be»
más:
tempunit = u »°»
speedunit = u »»
nyomásegység = u »»

ha kezdőnap == Nincs: # jelenlegi állapot

ha adattípus == "DW":
ha a self.locale == "van":
ha rövid hét == Igaz:
output = WeatherText.day_of_week_short_es [self.current_conditions [0] .day_of_week]
más:
output = WeatherText.day_of_week_es [self.current_conditions [0] .day_of_week]
elif self.locale == "fr":
ha rövid hét == Igaz:
output = WeatherText.day_of_week_short_fr [self.current_conditions [0] .day_of_week]
más:
output = WeatherText.day_of_week_fr [self.current_conditions [0] .day_of_week]
más:
ha rövid hét == Igaz:
output = WeatherText.day_of_week_short [self.current_conditions [0] .day_of_week]
más:
output = WeatherText.day_of_week [self.current_conditions [0] .day_of_week]
elif adattípus == "WF": # időjárás font
output = WeatherText.conditions_weather_font [self.current_conditions [0] .feltétel_kód]
elif adattípus == "LT":
string = self.current_conditions [0] .lassú
if self.isNumeric (string) == Igaz:
ha birodalmi == Igaz:
string = self.convertCelsiusToFahrenheit (karakterlánc)
string = karakterlánc + tempunit
output = karakterlánc
elif adattípus == "HT":
karakterlánc = saját.áram_feltételek [0] .magas
if self.isNumeric (string) == Igaz:
ha birodalmi == Igaz:
string = self.convertCelsiusToFahrenheit (karakterlánc)
string = karakterlánc + tempunit
output = karakterlánc
elif adattípus == "CC":
ha a self.locale == "van":
output = WeatherText.conditions_text_es [self.current_conditions [0]. feltétel_kód]
elif self.locale == "fr":
output = WeatherText.conditions_text_fr [self.current_conditions [0] .feltétel_kód]
más:
output = WeatherText.conditions_text [self.current_conditions [0] .feltétel_kód]
elif adattípus == "CT":
output = self.current_conditions [0] .feltétel_szöveg
elif adattípus == "PC":
string = self.current_conditions [0] .precip
if self.isNumeric (string) == Igaz:
string = string + u »%»
output = karakterlánc
elif adattípus == "HM":
karakterlánc = saját.áram_feltételek [0] .nedvesség
if self.isNumeric (string) == Igaz:
string = string + u »%»
output = karakterlánc
elif adattípus == "WD":
string = self.current_conditions [0] .szél_dir
if self.isNumeric (string) == Igaz:
string = self.getBearingText (karakterlánc)

ha a self.locale == "van":
output = WeatherText.bearing_text_es [karakterlánc]
elif self.locale == "fr":
output = WeatherText.bearing_text_fr [karakterlánc]
más:
output = karakterlánc

elif adattípus == "BF":
string = self.current_conditions [0] .szél_dir
if self.isNumeric (string) == Igaz:
karakterlánc = WeatherText.bearing_arrow_font [self.getBearingText (string)]
output = karakterlánc
elif adattípus == "WS":
string = self.current_conditions [0] .szél_sebesség
if self.isNumeric (string) == Igaz:
ha birodalmi == Igaz:
string = self.convertKilometresToMiles (karakterlánc)
string = karakterlánc + sebességegység
output = karakterlánc
elif adattípus == "WG":
karakterlánc = saját.áram_feltételek [0] .szél_ undor
if self.isNumeric (string) == Igaz:
ha birodalmi == Igaz:
string = self.convertKilometresToMiles (karakterlánc)
string = karakterlánc + sebességegység
output = karakterlánc
elif adattípus == "CN":
output = saját.áram_feltételek [0] .város
elif adattípus == "SR":
output = saját.áram_feltételek [0] .napfelkelte
elif adattípus == "SS":
output = saját.áram_feltételek [0] .nyugta
elif adattípus == "MP":
output = self.current_conditions [0] .hónap_fázis
elif adattípus == "MF":
output = WeatherText.conditions_moon_font [self.current_conditions [0] .moon_icon]
elif adattípus == "BR":
string = self.current_conditions [0] .bar_read
if self.isNumeric (string) == Igaz:
ha birodalmi == Igaz:
string = self.convertMillibarsToInches (karakterlánc)
húr = húr + nyomásegység
output = karakterlánc
elif adattípus == "BD":
output = self.current_conditions [0] .bar_desc
más:
output = "\ n HIBA: Ismeretlen adattípust kértek"

else: # előrejelzési adat

ha végnap == Nincs: # ha nincs beállítva végnap, használja a kezdőnapot
endday = kezdőnap

ha éjszaka == Igaz: # éjszakai előrejelzés szükséges

a day_number tartományhoz (kezdőnap, végnap + 1):

ha adattípus == "DW":
ha a self.locale == "van":
ha rövid hét == Igaz:
output = output + self.getSpaces (szóköz) + WeatherText.day_of_week_short_es [self.night_forecast [day_number] .day_of_week]
más:
output = output + self.getSpaces (szóköz) + WeatherText.day_of_week_es [self.night_forecast [day_number] .day_of_week]
elif self.locale == "fr":
ha rövid hét == Igaz:
output = output + self.getSpaces (szóköz) + WeatherText.day_of_week_short_fr [self.night_forecast [day_number] .day_of_week]
más:
output = output + self.getSpaces (szóköz) + WeatherText.day_of_week_fr [self.night_forecast [day_number] .day_of_week]
más:
ha rövid hét == Igaz:
output = output + self.getSpaces (szóköz) + WeatherText.day_of_week_short [self.night_forecast [day_number] .day_of_week]
más:
output = output + self.getSpaces (szóköz) + WeatherText.day_of_week [self.night_forecast [day_number] .day_of_week]
elif adattípus == "WF": # időjárás font
output = output + self.getSpaces (szóköz) + WeatherText.conditions_weather_font [self.night_forecast [day_number] .condition_code]
elif adattípus == "LT":
string = self.night_forecast [day_number] .lass
if self.isNumeric (string) == Igaz:
ha birodalmi == Igaz:
string = self.convertCelsiusToFahrenheit (karakterlánc)
string = karakterlánc + tempunit
output = output + self.getSpaces (szóköz) + karakterlánc

elif adattípus == "HT":
string = self.night_forecast [day_number] .magas
if self.isNumeric (string) == Igaz:
ha birodalmi == Igaz:
string = self.convertCelsiusToFahrenheit (karakterlánc)
string = karakterlánc + tempunit
output = output + self.getSpaces (szóköz) + karakterlánc
elif adattípus == "CC":
ha a self.locale == "van":
output = output + self.getSpaces (szóköz) + WeatherText.conditions_text_es [self.night_forecast [day_number] .feltétel_kód]
elif self.locale == "fr":
output = output + self.getSpaces (szóköz) + WeatherText.conditions_text_fr [self.night_forecast [day_number]. feltétel_kód]
más:
output = output + self.getSpaces (szóköz) + WeatherText.conditions_text [self.night_forecast [day_number] .feltétel_kód]
elif adattípus == "CT":
output = output + self.getSpaces (szóköz) + self.night_forecast [day_number]. feltétel_szöveg
elif adattípus == "PC":
string = self.night_forecast [day_number] .precip
if self.isNumeric (string) == Igaz:
string = string + u »%»
output = output + self.getSpaces (szóköz) + karakterlánc
elif adattípus == "HM":
string = self.night_forecast [day_number] .nedvesség
if self.isNumeric (string) == Igaz:
string = string + u »%»
output = output + self.getSpaces (szóköz) + karakterlánc
elif adattípus == "WD":
string = self.night_forecast [day_number] .szél_dir
ha a self.locale == "van":
output = output + self.getSpaces (szóköz) + WeatherText.bearing_text_es [string]
elif self.locale == "fr":
output = output + self.getSpaces (szóköz) + WeatherText.bearing_text_fr [string]
más:
output = output + self.getSpaces (szóköz) + karakterlánc

elif adattípus == "BF":
output = output + self.getSpaces (szóköz) + WeatherText.bearing_arrow_font [self.night_forecast [day_number] .wind_dir]
elif adattípus == "WS":
string = self.night_forecast [day_number] .szél_sebesség
if self.isNumeric (string) == Igaz:
ha birodalmi == Igaz:
string = self.convertKilometresToMiles (karakterlánc)
string = karakterlánc + sebességegység
output = output + self.getSpaces (szóköz) + karakterlánc
elif adattípus == "WG":
string = self.night_forecast [day_number] .szél_ undor
if self.isNumeric (string) == Igaz:
ha birodalmi == Igaz:
string = self.convertKilometresToMiles (karakterlánc)
string = karakterlánc + sebességegység
output = output + self.getSpaces (szóköz) + karakterlánc
elif adattípus == "CN":
output = output + self.getSpaces (szóköz) + self.night_forecast [day_number] .város
elif adattípus == "SR":
output = output + self.getSpaces (szóköz) + self.night_forecast [day_number] .sunrise
elif adattípus == "SS":
output = output + self.getSpaces (szóköz) + self.night_forecast [day_number] .sunset
elif adattípus == "MP":
output = output + self.getSpaces (szóköz) + self.night_forecast [day_number] .moon_phase
elif adattípus == "MF":
output = output + self.getSpaces (szóköz) + WeatherText.conditions_moon_font [self.night_forecast [day_number] .moon_icon]
elif adattípus == "BR":
output = output + self.getSpaces (szóköz) + self.night_forecast [day_number] .bar_read
elif adattípus == "BD":
output = output + self.getSpaces (szóközök) + self.night_forecast [day_number]. bar_desc
más:
output = "\ n HIBA: Ismeretlen adattípust kértek"
szünet

else: # napos előrejelzést akarunk

a day_number tartományhoz (kezdőnap, végnap + 1):

ha adattípus == "DW":
ha a self.locale == "van":
ha rövid hét == Igaz:
output = output + self.getSpaces (szóköz) + WeatherText.day_of_week_short_es [self.day_forecast [day_number] .day_of_week]
más:
output = output + self.getSpaces (szóközök) + WeatherText.day_of_week_es [self.day_forecast [day_number] .day_of_week]
elif self.locale == "fr":
ha rövid hét == Igaz:
output = output + self.getSpaces (szóköz) + WeatherText.day_of_week_short_fr [self.day_forecast [day_number] .day_of_week]
más:
output = output + self.getSpaces (szóköz) + WeatherText.day_of_week_fr [self.day_forecast [day_number] .day_of_week]
más:
ha rövid hét == Igaz:
output = output + self.getSpaces (szóköz) + WeatherText.day_of_week_short [self.day_forecast [day_number] .day_of_week]
más:
output = output + self.getSpaces (szóköz) + WeatherText.day_of_week [self.day_forecast [day_number] .day_of_week]
elif adattípus == "WF": # időjárás font
output = output + self.getSpaces (szóköz) + WeatherText.conditions_weather_font [self.day_forecast [day_number] .feltétel_kód]
elif adattípus == "LT":
string = self.day_forecast [day_number] .lass
if self.isNumeric (string) == Igaz:
ha birodalmi == Igaz:
string = self.convertCelsiusToFahrenheit (karakterlánc)
string = karakterlánc + tempunit
output = output + self.getSpaces (szóköz) + karakterlánc
elif adattípus == "HT":
string = self.day_forecast [day_number] .magas
if self.isNumeric (string) == Igaz:
ha birodalmi == Igaz:
string = self.convertCelsiusToFahrenheit (karakterlánc)
string = karakterlánc + tempunit
output = output + self.getSpaces (szóköz) + karakterlánc
elif adattípus == "CC":
ha a self.locale == "van":
output = output + self.getSpaces (szóköz) + WeatherText.conditions_text_es [self.day_forecast [day_number]. feltétel_kód]
elif self.locale == "fr":
output = output + self.getSpaces (szóközök) + WeatherText.conditions_text_fr [self.day_forecast [day_number]. feltétel_kód]
más:
output = output + self.getSpaces (szóköz) + WeatherText.conditions_text [self.day_forecast [day_number] .feltétel_kód]
elif adattípus == "CT":
output = output + self.getSpaces (szóköz) + self.day_forecast [day_number]. feltétel_text
elif adattípus == "PC":
string = self.day_forecast [day_number] .precip
if self.isNumeric (string) == Igaz:
string = string + u »%»
output = output + self.getSpaces (szóköz) + karakterlánc
elif adattípus == "HM":
string = self.day_forecast [day_number]. páratartalom
if self.isNumeric (string) == Igaz:
string = string + u »%»
output = output + self.getSpaces (szóköz) + karakterlánc
elif adattípus == "WD":
string = saját.nap_ előrejelzés [nap_szám] .szél_dir

ha a self.locale == "van":
output = output + self.getSpaces (szóköz) + WeatherText.bearing_text_es [string]
elif self.locale == "fr":
output = output + self.getSpaces (szóköz) + WeatherText.bearing_text_fr [string]
más:
output = output + self.getSpaces (szóköz) + karakterlánc

elif adattípus == "BF":
output = output + self.getSpaces (szóköz) + WeatherText.bearing_arrow_font [self.day_forecast [day_number] .wind_dir]
elif adattípus == "WS":
string = saját.nap_ előrejelzés [nap_szám] .szél_sebesség
if self.isNumeric (string) == Igaz:
ha birodalmi == Igaz:
string = self.convertKilometresToMiles (karakterlánc)
string = karakterlánc + sebességegység
output = output + self.getSpaces (szóköz) + karakterlánc
elif adattípus == "WG":
string = self.day_forecast [day_number] .szél_ undor
if self.isNumeric (string) == Igaz:
ha birodalmi == Igaz:
string = self.convertKilometresToMiles (karakterlánc)
string = karakterlánc + sebességegység
output = output + self.getSpaces (szóköz) + karakterlánc
elif adattípus == "CN":
output = output + self.getSpaces (szóközök) + self.day_forecast [day_number] .város
elif adattípus == "SR":
output = output + self.getSpaces (szóköz) + self.day_forecast [day_number] .sunrise
elif adattípus == "SS":
output = output + self.getSpaces (szóköz) + self.day_forecast [day_number] .sunset
elif adattípus == "MP":
output = output + self.getSpaces (szóköz) + self.day_forecast [day_number] .moon_phase
elif adattípus == "MF":
output = output + self.getSpaces (szóköz) + WeatherText.conditions_moon_font [self.day_forecast [day_number] .moon_icon]
elif adattípus == "BR":
output = output + self.getSpaces (szóközök) + self.day_forecast [day_number]. bar_read
elif adattípus == "BD":
output = output + self.getSpaces (szóköz) + self.day_forecast [nap_száma] .bar_desc
más:
output = u »\ n HIBA: Ismeretlen adattípust kértek»
szünet

output = u »» + output.strip (u »«) # elveszíti a vezető / záró szóközöket
visszatérő kimenet

#kivéve:
#print "getOutputText: Váratlan hiba:", sys.exc_info () [0]

def getOutputTextFromTemplate (saját, sablon):
#próbáld ki:

# kulcs a sablon adatokhoz
DATATYPE_KEY = "–datatype ="
STARTDAY_KEY = "–startday ="
ENDDAY_KEY = "–nap ="
NIGHT_KEY = "–éjszaka"
SHORTWEEKDAY_KEY = "–rövid hét"
IMPERIAL_KEY = "–perforális"
HIDEUNITS_KEY = "–hideunits"
SPACES_KEY = "–spaces ="

output = u »»

optionfound = Hamis

# töltse be a fájlt
próbálja ki:
fileinput = open (self.options.template)
template = fileinput.read ()
fileinput.close ()
kivéve:
output = u »A sablonfájl nem található!»

templatelist = self.getTemplateList (sablon)

# lehetővé teszi a sablonlista végigjárását és az egyes megtalált elemek kimenetének meghatározását
i tartományban (0, len (templatelist) -1):

pos = templatelist [i] .find (DATATYPE_KEY)
ha pos! = -1:
foundfound = Igaz
pos = pos + len (DATATYPE_KEY)
adattípus = templatelist [i] [pos: pos + 4] .strip ("}"). strip ("{"). strip ("-"). strip ("")
más:
adattípus = Nincs

pos = templatelist [i] .find (STARTDAY_KEY)
ha pos! = -1:
foundfound = Igaz
pos = pos + len (STARTDAY_KEY)
kezdőnap = int (templatelist [i] [pos: pos + 4] .strip ("}"). strip ("{"). strip ("-"). strip (""))
más:
kezdőnap = Nincs

pos = templatelist [i] .find (ENDDAY_KEY)
ha pos! = -1:
foundfound = Igaz
pos = pos + len (ENDDAY_KEY)
endday = int (templatelist [i] [pos: pos + 4] .strip ("}"). strip ("{"). strip ("-"). strip (""))
más:
endday = Nincs

pos = templatelist [i] .find (NIGHT_KEY)
ha pos! = -1:
foundfound = Igaz
éjszaka = Igaz
más:
éjszaka = Hamis

pos = templatelist [i] .find (SHORTWEEKDAY_KEY)
ha pos! = -1:
foundfound = Igaz
rövid hét = Igaz
más:
rövid hét = Hamis

pos = templatelist [i] .find (IMPERIAL_KEY)
ha pos! = -1:
foundfound = Igaz
birodalmi = Igaz
más:
birodalmi = hamis

pos = templatelist [i] .find (HIDEUNITS_KEY)
ha pos! = -1:
foundfound = Igaz
hideunits = Igaz
más:
hideunits = Hamis

pos = templatelist [i] .find (SPACES_KEY)
ha pos! = -1:
foundfound = Igaz
pos = pos + len (SPACES_KEY)
szóköz = int (templatelist [i] [pos: pos + 4] .strip («}»). strip («{«). strip («-«). strip (»«))
más:
szóköz = 1

ha az opció megtalálva == Igaz:
templatelist [i] = self.getOutputText (adattípus, kezdőnap, végnap, éjszaka, rövid hét, birodalmi, rejtett egységek, szóközök)
optionfound = Hamis

# végigmenni a kimenetet összefűző listán, miután feltöltötték
a templatelistában szereplő tételhez:
output = output + elem

visszatérő kimenet

#kivéve:
#print "getOutputTextFromTemplate: Váratlan hiba:", sys.exc_info () [0]

def fetchData (self):

# mindig beolvasni a metrikus adatokat, beszélgetési funkciókat kell használni ezeken az adatokon
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)

if self.isConnectionAvailable () == Hamis:
ha az os.path.exists létezik (file_path_current):
RefetchData = Hamis
else: # nincs kapcsolat, nincs gyorsítótár, bumm!
print "Nincs internetkapcsolat, és nincsenek gyorsítótárazott időjárási adatok."
elif self.options.refetch == Igaz:
RefetchData = Igaz
más:
# az adatokat újra be kell szerezni?
ha az os.path.exists létezik (file_path_current):
lastmodDate = time.localtime (os.stat (file_path_current) [ST_MTIME])
lejárati dátum = (datetime.datetime.today () - datetime.timedelta (perc = self.EXPIRY_MINUTES)). timetuple ()

ha lejárati dátum> lastmodDate:
RefetchData = Igaz
más:
RefetchData = Hamis
más:
RefetchData = Igaz

# lekérni az aktuális feltételeket, vagy a webhelyről, vagy a „szedés eltávolításával”
ha RefetchData == Igaz:

# az aktuális állapotadatok beszerzése az xoap szolgáltatástól
próbálja ki:

# 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 & egység = m '
ha self.options.verbose == Igaz:
nyomtatás >> sys.stdout, «időjárási adatok lekérése innen«, url

Usock = urllib2.urlopen (url)
xml = usock.read ()
Usock.close ()
self.weatherxmldoc = minidom.parseString (xml)
kivéve:
print "fetchData: Váratlan hiba:", sys.exc_info () [0]
print "Nem lehet kapcsolatba lépni az időjárási forrással az aktuális viszonyok miatt"

# mondd meg a felhasználónak, ha a hely rossz ...
found = xml.find ("Érvénytelen hely van megadva")
ha megtalálják! = -1:
print "Érvénytelen hely van megadva"

# kikérdezi az időjárási adatokat, betölti az osztály szerkezetébe és pácolja
próbálja ki:

# előkészíti az időjárási adatlistákat
self.current_conditions = []
self.day_forecast = []
self.night_forecast = []

# általános adatok gyűjtése
időjárás_n = self.weatherxmldoc.documentElement
location_n = weather_n.getElementsByTagName ('loc') [0]
city_n = location_n.getElementsByTagName ('dnam') [0]
város = self.getText (város_n.gyerekNodes)

# az aktuális körülményekre vonatkozó adatok gyűjtése
day_of_week = u »Ma»
csapadék = u »N / A»
sunrise_n = location_n.getElementsByTagName ('sunr') [0]
sunrise = self.getText (sunrise_n.childNodes)
sunset_n = location_n.getElementsByTagName ('suns') [0]
sunset = self.getText (sunset_n.childNodes)
current_condition_n = weather_n.getElementsByTagName ('cc') [0]
current_desc_n = current_condition_n.getElementsByTagName ('t') [0]
current_desc = self.getText (current_desc_n.childNodes)
current_code_n = current_condition_n.getElementsByTagName ('ikon') [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 ('szél') [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)
páratartalom_n = jelenlegi_feltétel_n.getElementsByTagName ('hmid') [0]
páratartalom = self.getText (páratartalom_n.gyerekNodes)
hold_n = jelenlegi_feltétel_n.getElementsByTagName ('hold') [0]
hold_ikon_n = hold_n.getElementsByTagName ('ikon') [0]
hold_ikon = self.getText (hold_ikon_n.gyerekNodes)
hold_fázis_n = hold_n.getElementsByTagName ('t') [0]
holdfázis = self.getText (hold_fázis_n.childNodes)
current_conditions_data = WeatherData (napi_hét, aktuális_hőmérséklet, aktuális_hőmérséklet, jelenlegi_kód, jelenlegi_desc, csapadék, páratartalom, wind_direction, szélsebesség, wind_gusts, város, napkelte, napnyugta, holdfázis, moon_icon, bar_read, bar_desc)
self.current_conditions.append (current_conditions_data)

# előrejelzési adatok gyűjtése
bar_read = u »N / A»
bar_desc = u »N / A»
hold_fázis = u »N / A»
hold_ikon = u »na»
előrejelzés_n = időjárás_n.getElementsByTagName ('dayf') [0]
day_nodes = előrejelzés_n.getElementsByTagName ('nap')

napra a day_nodes-ben:
day_of_week = day.getAttribute ('t')
day_of_year = day.getAttribute ('dt')
high_temp_n = day.getElementsByTagName ('szia') [0]
high_temp = self.getText (high_temp_n.childNodes)
low_temp_n = day.getElementsByTagName ('alacsony') [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]
sunset = self.getText (sunset_n.childNodes)

# napos előrejelzés specifikus adatok
daytime_n = day.getElementsByTagName ('part') [0] # nap
condition_code_n = daytime_n.getElementsByTagName ('ikon') [0]
feltétel_kód = self.getText (feltétel_kód_n.gyerekNodes)
condition_n = daytime_n.getElementsByTagName ('t') [0]
feltétel = self.getText (feltétel_n.gyerekNodes)
rain_n = daytime_n.getElementsByTagName ('ppcp') [0]
precip = self.getText (csap_n.gyerekNodes)
páratartalom_n = nappali_n.getElementsByTagName ('hmid') [0]
páratartalom = self.getText (páratartalom_n.gyerekNodes)
wind_n = daytime_n.getElementsByTagName ('wind') [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 (napi_hét, alacsony hőmérséklet, magas hőmérséklet, feltétel_kód, állapot, csapadék, páratartalom, szélirány, szélsebesség, szélcsendek, város, napkelte, napnyugta, holdfázis, holdikon, bar_read, bar_desc)
self.day_forecast.append (day_forecast_data)

# éjszakai előrejelzés konkrét adatai
daytime_n = day.getElementsByTagName ('part') [1] # éjszaka
condition_code_n = daytime_n.getElementsByTagName ('ikon') [0]
feltétel_kód = self.getText (feltétel_kód_n.gyerekNodes)
condition_n = daytime_n.getElementsByTagName ('t') [0]
feltétel = self.getText (feltétel_n.gyerekNodes)
rain_n = daytime_n.getElementsByTagName ('ppcp') [0]
precip = self.getText (csap_n.gyerekNodes)
páratartalom_n = nappali_n.getElementsByTagName ('hmid') [0]
páratartalom = self.getText (páratartalom_n.gyerekNodes)
wind_n = daytime_n.getElementsByTagName ('wind') [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 (napi_hét, alacsony hőmérséklet, magas hőmérséklet, feltétel_kód, állapot, csapadék, páratartalom, szélirány, szélsebesség, széljárás, város, napkelte, napnyugta, holdfázis, holdikon, bar_read, bar_desc)
self.night_forecast.append (night_forecast_data)

# pácoljuk az adatokat a következő alkalommal!
fileoutput = nyitott (fájl_útvonal_ jelenlegi, 'w')
pickle.dump (self.current_conditions, fileoutput)
fileoutput.close ()

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

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

kivéve:
print "fetchData: Váratlan hiba:", sys.exc_info () [0]
print "Nem lehet lekérdezni az időjárási adatokat"

else: # időjárási adatok lekérése a pácolt osztályfájlokból
ha self.options.verbose == Igaz:
nyomtat >> sys.stdout, «időjárási adatok lekérése a fájlból:«, file_path_current

fileinput = nyitott (file_path_current, 'r')
self.current_conditions = savanyúság.load (fájlbemenet)
fileinput.close ()

ha self.options.verbose == Igaz:
print >> sys.stdout, "napi előrejelzési adatok lekérése fájlokból:", file_path_dayforecast, file_path_nightforecast

fileinput = nyitott (file_path_dayforecast, 'r')
self.day_forecast = pickle.load (fájlbemenet)
fileinput.close ()

ha self.options.verbose == Igaz:
print >> sys.stdout, "napi előrejelzési adatok lekérése fájlokból:", file_path_nightforecast, file_path_nightforecast

fileinput = nyitott (file_path_nightforecast, 'r')
self.night_forecast = pickle.load (fájlbemenet)
fileinput.close ()

def outputData (én):
#próbáld ki:

ha self.options.template! = Nincs:

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

más:

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

print output.encode ("utf-8")

#kivéve:
#print «outputData: Váratlan hiba:«, sys.exc_info () [0]

ha __name__ == "__main__":

parser = CommandLineParser ()
(opciók, args) = parser.parse_args ()

ha options.verbose == Igaz:
print >> sys.stdout, "location:", options.location
print >> sys.stdout, "imperial:", options.imperial
print >> sys.stdout, "datatype:", options.datatype
nyomtatás >> sys.stdout, "night:", options.night
print >> sys.stdout, "start day:", options.startday
print >> sys.stdout, "end day:", options.endday
print >> sys.stdout, "szóközök:", opciók.terek
print >> sys.stdout, "verbose:", options.verbose
print >> sys.stdout, "refetch:", options.refetch

# új globális időjárási objektum létrehozása
időjárás = GlobalWeather (opciók)
weather.fetchData ()
weather.outputData ()

Létrehozzuk a ~ / Conky / scripts / myweather.template fájlt

gedit ~ / Conky / scripts / myweather.template

a következőket illesztjük be:

{–Datatype = DW –startday = 1}: {–datatype = CC –startday = 1}
{–Datatype = HT –startday = 1} / {–datatype = LT –startday = 1} Szél {–datatype = WD –startday = 1} és {–datatype = WS –startday = 1} között
Páratartalom: {–datatype = HM –startday = 1} Csapadék: {–datatype = PC –startday = 1}
Napkelte: {–datatype = SR –startday = 1} Napnyugta: {–datatype = SS –startday = 1}
----------------
{–Datatype = DW –startday = 2}: {–datatype = CC –startday = 2}
{–Datatype = HT –startday = 2} / {–datatype = LT –startday = 2} Szél {–datatype = WD –startday = 2} és {–datatype = WS –startday = 2} között
Páratartalom: {–datatype = HM –startday = 2} Csapadék: {–datatype = PC –startday = 2}
Napkelte: {–datatype = SR –startday = 2} Napnyugta: {–datatype = SS –startday = 2}
----------------
{–Datatype = DW –startday = 3}: {–datatype = CC –startday = 3}
{–Datatype = HT –startday = 3} / {–datatype = LT –startday = 3} Szél {–datatype = WD –startday = 3} és {–datatype = WS –startday = 3} között
Páratartalom: {–datatype = HM –startday = 3} Csapadék: {–datatype = PC –startday = 3}
Napkelte: {–datatype = SR –startday = 3} Napnyugta: {–datatype = SS –startday = 3}
----------------
{–Datatype = DW –startday = 4}: {–datatype = CC –startday = 4}
{–Datatype = HT –startday = 4} / {–datatype = LT –startday = 4} Szél {–datatype = WD –startday = 4} és {–datatype = WS –startday = 4} között
Páratartalom: {–datatype = HM –startday = 4} Csapadék: {–datatype = PC –startday = 4}
Napkelte: {–datatype = SR –startday = 4} Napnyugta: {–datatype = SS –startday = 4}

Létrehozzuk a ~ / Conky / scripts / mail / conkyEmail.py fájlt (létre kell hoznunk a mail mappát)

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

és illessze be a következőket:

import os
karakterlánc importálása

# Írja be felhasználónevét és jelszavát alább dupla idézőjelben
# például. felhasználónév = »felhasználónév» és jelszó = »jelszó»
felhasználónév = »YOUR_USUARIO_SINARROBA«
jelszó = »A KULCS«

com = »wget -O - https: //» + felhasználónév + »:» + jelszó + »@ mail.google.com / mail / feed / atom –no-check-tanúsítvány»

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

ha fc == 0:
"0 új" nyomtatása
más:
print str (fc) + »új»

Tehát most 7 fájlja van:

A mappában: ~
-> .startconky << - futtathatóvá teszi

A mappában: ~ / Conky
-> conkymain
-> conkyforecast
-> conkymail

és a mappában: ~ / Conky / scripts
-> conkyForecast.py << - futtathatóvá teszi
-> myweather.sablon

és a mappában: ~ / Conky / scripts / mail
conkyEmail.py << - futtathatóvá teszi

És ennyi, pontosítások, ahol azt írja, hogy / home / user / ... a felhasználóneved megy, és abban a részben, ahol a Gmail adatok mennek, színekkel emeltem ki, ahová be kell tenned az adataidat.

hogy megölje a conky folyamatot, írjon egy konzolra

killall conky

hogy futtassa az írást egy konzolra

./.startconky

ha mindent beállított, ha azt szeretné, hogy az egyes munkamenetek elkezdődjenek

Rendszer—> Beállítások—> Munkamenetek és az indító programokban hozzáadjuk

A Névbe írhatjuk a Conky-t, a ./.startconky sorrendben, ezzel minden alkalommal elindul, amikor bekapcsolja a pc-t.

Ez az, remélem, hogy segít.


A cikk tartalma betartja a szerkesztői etika. A hiba bejelentéséhez kattintson a gombra itt.

Legyen Ön az első hozzászóló

Hagyja megjegyzését

E-mail címed nem kerül nyilvánosságra.

*

*

  1. Az adatokért felelős: Miguel Ángel Gatón
  2. Az adatok célja: A SPAM ellenőrzése, a megjegyzések kezelése.
  3. Legitimáció: Az Ön beleegyezése
  4. Az adatok közlése: Az adatokat csak jogi kötelezettség alapján továbbítjuk harmadik felekkel.
  5. Adattárolás: Az Occentus Networks (EU) által üzemeltetett adatbázis
  6. Jogok: Bármikor korlátozhatja, helyreállíthatja és törölheti adatait.