„Fecfactor“ vakar paprašė manęs paskelbti „conky“ konfigūraciją, kurią rodau žemiau esančiame paveikslėlyje
Kaip matote, tai yra apie 3 konkus, kurie vykdomi naudojant scenarijų, jo konfigūracija yra pagrįsta šis pranešimas paskelbė vartotojas Bruce M. forumuose „Ubuntu-Ar“ su kai kuriais pakeitimais pašto konke, kuris mano atveju yra skirtas „Gmail“.
Informaciniame įraše tai labai gerai paaiškina Bruce'as, bet taip pat kaip atminties priemonę man nukopijuosiu veiksmus, kurių reikia laikytis, ir savo kodų kodą tam, kas jį turi.
Na, žinoma, turime įdiegti „conky“, „curl“ ir „python“, kad įvestume konsolę:
sudo apt-get įdiegti conky curl python
Weather.ttf šaltinis ir rodyklės.ttf čia. Mėnulio šaltinis.ttf čia kai atsisiųsite, turite juos nukopijuoti į / usr / share / fonts
Dabar sukurkime savo scenarijų pavadinimu ~. / Startconky
gksudo gedit ~ / .startconky
tuščio failo viduje įklijuojame šiuos dalykus
#! / bin / bash
miegas 0 ir # 0 tinka „Xfce“ - „Gnome“ naudokite nuo 20 iki 30
conky -c ~ / Conky / conkymain &
#sleep 0 ir # 0 tinka „Xfce“ - naudokite 1 „Gnome“
conky -c ~ / Conky / conkyforecast &
#sleep 0 ir # 0 tinka „Xfce“ - naudokite 1 „Gnome“
conky -c ~ / Conky / conkymail ir
Dabar „conkymain“ failą kuriame ~ / Conky aplanke, kitaip turėsime „Conky“ aplanką, turėsime jį sukurti.
gedit ~ / Conky / conkymain
Aš naudoju „Calibri“ šriftą, jei jo neturite, pakeiskite jį kuo tik norite.
Mes laikomės viduje, kas seka
fonas Nr
langas taip
own_window_parparent yes
own_window_hints nedekoruotas, žemiau, lipnus, praleisti užduočių juostą, praleisti_pageris
savas_ lango_spalva juoda
double_buffer taip
Use_spacer left
use_xft taip
šrifto kalibras: dydis = 9
xftfont calibri: dydis = 9
xftalpha 0.5
„update_interval 5.0“
didžiosios ne # nustatytos taip, jei norite, kad visas tekstas būtų didžiosiomis raidėmis
nustatytos_ sienos 3
9
sienos_plotis 10
numatytasis_spalva balta
default_outline_color juoda
default_shade_color juoda
spalva0 žydra
spalva1 šviesiai mėlyna
spalva2 oranžinė
spalva3 geltona
spalva4 kviečiai
spalva5 balta
spalva6 balta
spalva7 balta
spalva8 balta
spalva9 balta
lygiuoti „top_right #“ arba „top_left“, „bottom_light“, „bottom_right“
spraga_x 10
tarpas_y 35
text_buffer_size 128 # prognozei naudokite 1024
no_buffers yes # Atimti failų sistemos buferius iš panaudotos atminties?
atkreipti_ sienos Nr
draw_outline yes # sustiprina tekstą, jei taip
draw_shades yes # shadecolor juodaTEKSTAS
$ {font calibri: size = 12} $ {alignc} $ {color1} $ sysname $ kernel $ machine} $ color $ font
$ {font calibri: size = 12} $ {alignc} $ {color2} $ {exec whoami} @ $ nodename $ color $ font
$ {color0} $ {hr 1} $ spalvos
$ {font calibri: size = 20} $ {alignc} $ {time% H:% M} $ šriftas
$ {font calibri: size = 12} $ {color1} $ {alignc} $ {time% A,% d% b. % Y} $ color $ šriftas
„$ {color3} UpTime“: „$ {alignr 2} $ uptime $ color“
$ {color0} $ {hr 1} $ spalvos
$ {voffset 5} $ {color2} procesorius: $ {alignc} $ color $ running_processes $ {color1} / $ color $ apdoroja $ {alignr 2} $ {color2} $ {cpubar cpu0 14,80} $ color
$ {color1} $ {voffset -16} $ {alignr 5} $ cpu% $ color
$ {voffset 2} $ {color1} Įkelties vidurkis ($ {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} buferinis: $ color $ {buffers} $ {alignr 2} $ {color1} talpykloje: $ 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} $ spalvos
$ {voffset 5} $ {color2} HD informacija $ {color1} - $ color Nemokama $ {color1} - naudota - iš viso $ {color2}
$ {voffset 5} $ {color1} šaknis: $ color $ {fs_free_perc /}% $ {alignr 2} $ {fs_free /} $ {color2} / $ {color1} $ {fs_used /} $ color / $ {color2} $ {fs_size /} $ spalva
$ {color1} Pagrindinis: $ color $ {fs_free_perc / home / user}% $ {alignr 2} $ {fs_free / home / user} $ {color2} / $ {color1} $ {fs_used / home / user} $ color / $ {color2} $ {fs_size / home / user} $ spalva
$ {color0} $ {hr 1} $ spalvos
$ {color1} Nuo: $ color Buenos Airės, Argentina
$ {color1} Plat.: $ {color2} 34 ° 35'S $ {color1} Ilgas: $ {color2} 58 ° 21'W $ {color1} Alt: $ {color2} 25 m $ spalva
$ {voffset 5} $ {color2} $ {font calibri: size = 12} šiandien: $ font $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = CC} $ spalva $ {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 Arrows: size = 20} $ {color4} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = BF} $ color $ šriftas
$ {alignc 10} $ {voffset 5} $ {color4} Wind: $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = WS} $ color
$ {color1} Drėgmė: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = HM} $ {alignr 2} $ {color1} Krituliai: $ {color3} $ { „execi 3600 python“ ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = PC} $ color
$ {alignc} $ {color1} slėgis: $ {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} $ spalvos
$ {color1} Saulėtekis: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = SR} $ {alignr 2} $ {color1} Saulėlydis: $ {color3} $ { „execi 3600 python“ ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = SS} $ color
$ {voffset 15} $ {color1} Mėnulis: $ {color4} $ {alignr 2} $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = MP} $ color
$ {voffset -20} $ {offset 80} $ {color4} $ {font moon fases: size = 20} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = MF} $ font $ spalva
$ {color0} $ {hr} $ spalvos
$ {voffset 5} $ {color2} IP: $ {alignc} $ color $ {addr eth0}
$ {color1} žemyn: $ color $ {downspeed eth0} k / s $ {alignr 2} $ {color1} aukštyn: $ color $ {upspeed eth0} k / s
$ {color1} Iš viso: $ color $ {totaldown eth0} $ {alignr 2} $ {color1} Iš viso: $ color $ {totalup eth0}
$ {color1} gaunamas: $ color $ {tcp_portmon 1 32767 count} $ {color1} išvykstamasis: $ color $ {tcp_portmon 32768 61000 count} $ {alignr 2} $ {color1} iš viso: $ color $ {tcp_portmon 1 65535 count}
$ {voffset 5} $ {color2} jungtys: $ color $ {tcp_portmon 32768 61000 count} $ {alignr 2} $ {color2} paslauga / prievadas $ 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
kuriame failą ~ / Conky / conkyforecast
gedit ~ / Conky / conkyforecast
ir mes įklijuojame šiuos dalykus į vidų
fonas Nr
langas taip
own_window_parparent yes
own_window_hints nedekoruotas, žemiau, lipnus, praleisti užduočių juostą, praleisti_pageris
savas_ lango_spalva juoda
double_buffer taip
Use_spacer left
use_xft taip
šrifto kalibras: dydis = 8
xftfont calibri: dydis = 8
xftalpha 0.5
„update_interval 5.0“
didžiosios ne # nustatytos taip, jei norite, kad visas tekstas būtų didžiosiomis raidėmis
nustatytos_ sienos 3
9
sienos_plotis 10
numatytasis_spalva balta
default_outline_color juoda
default_shade_color juoda
spalva0 žydra
spalva1 šviesiai mėlyna
spalva2 oranžinė
spalva3 geltona
spalva4 kviečiai
spalva5 balta
spalva6 balta
spalva7 balta
spalva8 balta
spalva9 balta
lygiuoti apačioje kairėje arba kairėje, apačioje kairėje, apačioje dešinėje
spraga_x 10
tarpas_y 35
text_buffer_size 1024 # prognozei naudokite 1024
no_buffers yes # Atimti failų sistemos buferius iš panaudotos atminties?
atkreipti_ sienos Nr
draw_outline yes # sustiprina tekstą, jei taip
draw_shades yes # shadecolor juodaTEKSTAS
$ {color4} $ {font calibri: size = 11} Išplėstinė prognozė $ font $ color
$ {color0} $ {hr} $ spalvos
$ {color4} $ {font calibri: size = 9} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –template = / home / user / Conky / scripts / myweather.template} $ font $ spalva
kuriame failą ~ / Conky / conkymail
gedit ~ / Conky / conkymail
į failą įklijuojame šiuos dalykus
fonas Nr
langas taip
own_window_parparent yes
own_window_hints nedekoruotas, žemiau, lipnus, praleisti užduočių juostą, praleisti_pageris
savas_ lango_spalva juoda
double_buffer taip
Use_spacer left
use_xft taip
šrifto kalibras: dydis = 8
xftfont calibri: dydis = 8
xftalpha 0.5
„update_interval 5.0“
didžiosios ne # nustatytos taip, jei norite, kad visas tekstas būtų didžiosiomis raidėmis
nustatytos_ sienos 3
9
sienos_plotis 10
numatytasis_spalva balta
default_outline_color juoda
default_shade_color juoda
spalva0 žydra
spalva1 šviesiai mėlyna
spalva2 oranžinė
spalva3 geltona
spalva4 kviečiai
spalva5 balta
spalva6 balta
spalva7 balta
spalva8 balta
spalva9 balta
lygiuoti apačioje kairėje arba kairėje, apačioje kairėje, apačioje dešinėje
spraga_x 565
tarpas_y 35
text_buffer_size 128 # prognozei naudokite 1024
no_buffers yes # Atimti failų sistemos buferius iš panaudotos atminties?
atkreipti_ sienos Nr
draw_outline yes # sustiprina tekstą, jei taip
draw_shades yes # shadecolor juodaTEKSTAS
$ {font calibri: size = 11} $ {alignc} $ {color4} „Gmail“
$ {color0} $ {hr} $ spalvos
$ {font calibri: size = 11} $ {color4} Mes turime $ {color3} $ {execi 300 python ~ / Conky / scripts / mail / conkyEmail.py} $ {color4} el.
Sukuriame failą aplanke ~ / Conky / scripts / conkyForecast.py (turime sukurti aplanką scenarijai)
gedit ~ / Conky / scripts / conkyForecast.py
#! / usr / bin / python
# - * - kodavimas: utf-8 - * -
####################################################### ###############################
# conkyForecast.py yra (nebe toks) paprastas (jau) python scenarijus, kurį galima rinkti
# išsami dabartinio oro informacija, skirta naudoti „conky“.
#
# Autorius: Kaivalagi
# Sukurta: 13 04 2008
# Modifikacijos:
# 14/04/2008 Leiskite prognozių duomenų dienų intervalus
# 14/04/2008 Patikrinkite, ar nėra ryšio su „xoap“ paslauga
# 18/04/2008 Leiskite nustatyti intervalų išvesties tarpus
# 18/04/2008 Leiskite prognozuoti nakties ir dienos prognozes
# 18/04/2008 Palaikykite sąlygos kodo teksto „CC“ parinkties lokalę, laukiančią ispanų kalbos
# 18/04/2008 Klasės duomenims naudokite marinavimą, o ne atidarykite xml. Tai apeina poreikį tardyti talpykloje esančius duomenis
# 19/04/2008 Pridėtas ispanų kalbos tekstas - ačiū Bruce'ui M
# 19/04/2008 Pridėtas skaitinis visų skaitinių išėjimų su vienetų galūne patikrinimas
# 19/04/2008 Pakeistas marinuotų agurkų failų pavadinimas, įtraukiant vietos kodą
# 19/04/2008 Pridėta ispanų savaitės dienų konversija per lokalę
# 20/04/2008 Pridėtas tinkamas komandos argumentų analizatorius
# 20/04/2008 Pridėta - trumpą savaitę diena, jei nurodoma savaitės diena, duomenų tipas sutrumpinamas iki 3 simbolių
# 21/04/2008 Fiksuotos lokalės parinktys prognozuojamai produkcijai
# 21/04/2008 Pridėta šablono parinktis, leidžianti pasirinktinį išvestį naudojant vieną exec skambutį 🙂
# 21/04/2008 „Hideunits“ pridėta parinktis, norint pašalinti, pavyzdžiui, mph ir C iš išėjimo
# 23/04/2008 Pašalinta - svarbiausia parinktis iš šablono, tai TURI būti nustatyta kaip standartinė scenarijaus iškvietimo parinktis ir nenaudojama šablono faile.
# 23/04/2008 Skaityta - svarbiausia šablono parinktis, įgalinanti metrines ar imperines reikšmes kiekvienam duomenų tipui. Pastaba, naudojant šablonus, komandinės eilutės parinktis neveiks.
# 23/04/2008 Pridėta išvestis, pranešanti vartotojui, jei nurodyta vieta yra bloga
# 24/04/2008 Pridėtas tvarkymas be ryšio, dabar bus grąžinti į talpykloje saugomus duomenis (klaidų, jei nėra talpyklos). Testai bandant atidaryti xoap.weather.com
# 24/04/2008 Fiksuotas Celsijaus ir Farenheito perskaičiavimas
# 06/05/2008 Atnaujintas URL, naudojamas atnaujinus žiniatinklio paslaugą
# 09/05/2008 Konsoliduota dabartinė būklė ir prognozės duomenys gaunami į vieną skambutį
# 09/05/2008 Prie duomenų tipų pridėta saulėtekis ir saulėlydis, kurie būdingi tiek dabartinėms sąlygoms, tiek prognozių duomenims
# 09/05/2008 Prie duomenų tipų pridėta mėnulio fazė, barometro rodmuo ir barometro aprašas, kurie yra būdingi tik esamoms sąlygoms, taigi ir prognozuojamos produkcijos N / A
# 09/05/2008 Pridėtos barometro vienetų konversijos nuo MB iki colių (Imperial)
# 09/05/2008 Atnaujintas ispanų kalbos tekstas. Ačiū Bruce M
# 10/05/2008 Pridėti prancūzų kalbos duomenys - ačiū benpaka
# 12/05/2008 Pridėtas naujas BF (su šriftu) duomenų tipas, kad būtų rodyklės simbolis (naudokite su šriftu Arrow.ttf) vietoj NSEW išvesties iš WD (vėjo kryptis)
# 12/05/2008 Atnaujinta WD išvestis, atsižvelgiant į lokalę, šiuo metu palaiko numatytuosius anglų ir ispanų kalbas - ačiū Bruce'ui M
# 18/05/2008 Pridėtas naujas MF (mėnulio šrifto) duomenų tipas, kad būtų pateiktas mėnulio šrifto simbolis (simboliai neteisingi ir dar nėra jokio šrifto).
# 21/05/2008 Esamoms sąlygoms pasirinkus –datatype = LT, dabar rodoma „jaučiasi“, o ne dabartinė temperatūra
#
# VISKAS:
# Sujungti pkl failus į vieną failą / klasę
# Pridėkite orų šriftą pagal mėnulio fazės išvestį pagal mėnulio piktogramos duomenis
# ??? Dar kokie nors reikalavimai iš ten?importuoti sys, os, socket, urllib2, datetime, time
iš xml.dom importuoti minidom
iš statistikos importo *
iš „optparse“ importo „OptionParser“
importuoti lokalę
importuoti „gettext“
importuoti marinatą
iš matematikos importo *APP = »conkyForecast.py»
DIR = os.path.dirname (__file__) + '/ lokalė'
gettext.bindtextdomain (APP, DIR)
gettext.textdomain (APP)
_ = gettext.gettextklasės „CommandLineParser“:
analizatorius = Nėra
def __init __ (savęs):
self.parser = OptionParser ()
self.parser.add_option («- l», »- vieta», dest = »vieta», numatytasis = »UKXX0103 ″, type =» string », metavar =» CODE », help = u» vietos kodas orų duomenims [ numatytasis:% default], naudokite šį URL, kad nustatytumėte savo vietos kodą pagal miesto pavadinimą: http://xoap.weather.com/search/search?where=Norwich »)
self.parser.add_option ("- d", "- duomenų tipas", dest = "duomenų tipas", numatytasis = "HT", tipas = "eilutė", metavar = "DATATYPE", help = u "[numatytasis:% numatytasis] Duomenų tipo parinktys yra: DW (savaitės diena), WF (orų šrifto išvestis), LT (prognozė: žema temperatūra, dabartinė: jaučiasi kaip temperatūra), HT (prognozė: aukšta temperatūra, srovė: dabartinė temperatūra), CC (dabartinė) Sąlygos), CT (sąlygų tekstas), kompiuteris (kritulių tikimybė), HM (drėgmė), WD (vėjo kryptis), WS (vėjo greitis), WG (vėjo gūsiai), CN (miesto pavadinimas), SR (saulėtekis), SS (saulėlydis), MP (mėnulio fazė), MF (mėnulio šriftas), BR (barometro rodmuo), BD (barometro aprašymas). Nenaudojama komandinėje eilutėje, kai naudojami šablonai. »)
self.parser.add_option («- s», »- startday», dest = »startday», type = »int», metavar = »NUMBER», help = u »apibrėžti pradžios dienos numerį, jei išleidžiamos praleistos dabartinės sąlygos . Netaikoma komandinėje eilutėje naudojant šablonus. »)
self.parser.add_option ("- e", "- endday", dest = "endday", type = "int", metavar = "NUMBER", help = u "apibrėžti pabaigos dienos numerį, jei praleisti tik pradinės dienos duomenys yra išvestis. Nenaudojama komandinėje eilutėje, kai naudojami šablonai. »)
self.parser.add_option («- S», »- tarpai», dest = »tarpai», type = »int», numatytasis = 1, metavar = »NUMBER», help = u »[numatytasis:% default] Apibrėžia tarpų tarp diapazono išvesties skaičius. Nenaudojama komandinėje eilutėje, kai naudojami šablonai. »)
self.parser.add_option («- t», »- template», dest = »template», type = »string», metavar = »FILE», help = u »apibrėžia šablono failą, kad generuotų išvestį per vieną skambutį. A rodomas failo elementas yra formos {–datatype = HT –startday = 1}. Kiekvieno elemento galimos parinktys: –datatype, –startday, –endday, –night, –shortweekday, –perperial, –hideunits –Spaces. Atkreipkite dėmesį, kad trumpos parinkčių formos šiuo metu nepalaikomos! Nė viena iš šių parinkčių netaikoma komandinėje eilutėje, kai naudojami šablonai. »)
self.parser.add_option («- L», »- lokalė», dest = »lokalė», type = »string», help = u »nepaiso kalbos išvesties sistemos lokalės (lt = anglų, es = ispanų, fr = prancūzų kalba, dar laukia) »)
self.parser.add_option ("- i", "- imperial", dest = "imperial", default = False, action = "store_true", help = u "prašyti imperijos vienetų, jei praleista išvestis yra metrinė. Netaikoma komandų eilutė, kai naudojate šablonus. »)
self.parser.add_option («- n», »- naktis», dest = »naktis», numatytasis = False, action = »store_true», help = u »perjungti išvestį į naktinius duomenis, jei bus praleista dienos išvestis. Netaikoma komandinėje eilutėje naudojant šablonus. »)
self.parser.add_option («- w», »- shortweekday», dest = »shortweekday», default = False, action = »store_true», help = u »Sutrumpinkite savaitės dienos duomenų tipą iki 3 simbolių. Netaikoma komandų eilutė, kai naudojate šablonus. »)
self.parser.add_option («- u», »- paslėpti vienetai», dest = »paslėpti vienetai», numatytasis = Klaidingas, veiksmas = »parduotuvės_ tiesa», žinynas = u »Slėpti tokius vienetus kaip mph arba C, laipsnių simboliai (°) yra vis dar rodoma. Netaikoma komandinėje eilutėje, kai naudojami šablonai. »)
self.parser.add_option ("- v", "- verbose", dest = "verbose", numatytasis = False, action = "store_true", help = u "prašyti išsamios išvesties, nėra geros idėjos bėgant per conky!" )
self.parser.add_option ("- r", "- atnaujinti", dest = "atnaujinti", numatytasis = "False", veiksmas = "parduotuvės_tiesa", help = u "gauti duomenis neatsižvelgiant į duomenų galiojimo laiką")def parse_args (savarankiškai):
(parinktys, argumentai) = self.parser.parse_args ()
grąža (pasirinkimai, argumentai)def print_help (savarankiškai):
grąžinti self.parser.print_help ()„WeatherData“ klasė:
def __init __ (savęs, savaitės dienos, žemas, aukštas, būsenos_kodas, būklės_tekstas, krituliai, drėgmė, vėjo_direktorius, vėjo greitis, vėjo_suaugimai, miestas, saulėtekis, saulėlydis, mėnulio_fazė, mėnulio_ikonas, barų skaitymas, bar_desc):
savęs.savaitės diena = u »» + savaitės diena
savęs.low = u »» + žemas
savęs.aukštas = u »» + aukštas
self.condition_code = u »» + condition_code
self.condition_text = u »» + condition_text
sav.precip = u »» + krit
savęs.drėgmė = u »» + drėgmė
self.wind_dir = u »» + wind_dir
self.wind_speed = u »» + wind_speed
self.wind_gusts = u »» + wind_gusts
self.city = u »» + miestas
savęs.saule = u »» + saulėtekis
self.sunset = u »» + saulėlydis
savęs.mėnesio_fazė = u »» + mėnulio_fazė
self.moon_icon = u »» + mėnulio piktograma
self.bar_read = u »» + bar_read
self.bar_desc = u »» + bar_desc„WeatherText“ klasė:
sąlygos_tekstas = {
«0»: _ (u »Tornado»),
«1»: _ (u »tropinė audra»),
«2»: _ (u »uraganas»),
«3»: _ (u »Smarkios perkūnijos»),
«4»: _ (u »Perkūnijos»),
«5»: _ (u »Mišrus lietus ir sniegas»),
«6»: _ (u »Mišrus lietus ir laivynas»),
«7»: _ (u »Mišrios krituliai»),
«8»: _ (u »Šąla šlapdriba»),
«9»: _ (u »šlapdriba»),
«10»: _ (u »Šąla lietus»),
«11»: _ (u »Dušai»),
«12»: _ (u »Dušai»),
«13»: _ (u »Sniego pūgos»),
«14»: _ (u »Nedideli sniego lietūs»),
«15»: _ (u »pučia sniegą»),
«16»: _ (u »Sniegas»),
«17»: _ (u »Sveika»),
«18»: _ (u »Sleet»),
«19»: _ (u »Dulkės»),
«20»: _ (u »Rūkas»),
«21»: _ (u »migla»),
«22»: _ (u »Dūmai»),
«23»: _ (u »Blustery»),
«24»: _ (u »Vėjuota»),
«25»: _ (u »Šaltas»),
«26»: _ (u »Debesuota»),
«27»: _ (u »Daugiausia debesuota»),
«28»: _ (u »Daugiausia debesuota»),
«29»: _ (u »Debesuota»),
«30»: _ (u »Debesuota»),
«31»: _ (u »Išvalyti»),
«32»: _ (u »Išvalyti»),
«33»: _ (u »mugė»),
«34»: _ (u »mugė»),
«35»: _ (u »Mišrus lietus ir kruša»),
«36»: _ (u »Karštas»),
«37»: _ (u »pavienės perkūnijos»),
«38»: _ (u »Išsibarsčiusios perkūnijos»),
«39»: _ (u »Išsibarsčiusios perkūnijos»),
«40»: _ (u »Išsisklaidę lietūs»),
«41»: _ (u »Stiprus sniegas»),
«42»: _ (u »Išsisklaidę sniego lietūs»),
«43»: _ (u »Stiprus sniegas»),
«44»: _ (u »Debesuota»),
«45»: _ (u »Perkūno lietus»),
«46»: _ (u »Sniego lietus»),
«47»: _ (u »pavienės perkūnijos»),
«Na»: _ (u »N / A»),
"-": _ (a ")
}sąlygos_tekstas_es = {
«0»: _ (u »Tornado»),
«1»: _ (u »tropinė audra»),
«2»: _ (u »Huracá¡n»),
«3»: _ (u »Stiprios audros»),
«4»: _ (u »Audros»),
«5»: _ (u »Mišrus lietus ir sniegas»),
«6»: _ (u »Mišrus lietus ir laivynas»),
«7»: _ (u »Sleet»),
«8»: _ (u »Šąla šlapdriba»),
«9»: _ (u »šlapdriba»),
«10»: _ (u »Šalsiantis lietus»), # arba stingdantis lietus
«11»: _ (u »Dušai»),
«12»: _ (u »Dušai»),
«13»: _ (u »Nedidelis sniegas»),
«14»: _ (u »Nedidelis sniegas»),
«15»: _ (u »Sniego pūgos»),
«16»: _ (u »Sniegas»),
«17»: _ (u »Sveika»),
«18»: _ (u »Sleet»),
«19»: _ (u »milteliai»),
«20»: _ (u »Rūkas»),
«21»: _ (u »migla»),
«22»: _ (u »Dūmai»),
«23»: _ (u »Tempest»),
«24»: _ (u »Vėjuota»),
«25»: _ (u »Fráo»),
«26»: _ (u »Labai debesuota»),
«27»: _ (u »Daugiausia debesuota»),
«28»: _ (u »Daugiausia debesuota»),
«29»: _ (u »Debesuota»),
«30»: _ (u »Debesuota»),
«31»: _ (u »Išvalyti»),
«32»: _ (u »Išvalyti»),
«33»: _ (u »Kažkas debesuota»),
«34»: _ (u »Kažkas debesuota»),
«35»: _ (u »Lietus su kruša»),
«36»: _ (u »Šiluma»),
«37»: _ (u »pavienės audros»),
«38»: _ (u »Išsibarsčiusios audros»),
«39»: _ (u »Išsibarsčiusios audros»),
«40»: _ (u »Išsisklaidę lietūs»),
«41»: _ (u »Stiprus sniegas»),
«42»: _ (u »Silpni ir padriki sniego krituliai»),
«43»: _ (u »Intensyvi Nevada»),
«44»: _ (u »Išsisklaidę debesys»),
«45»: _ (u »Audros»),
«46»: _ (u »Išsisklaidę sniego krituliai»),
«47»: _ (u »pavienės audros»),
«Na»: _ (u »N / A»),
"-": _ (a ")
}sąlygos_tekstas_fr = {
«0»: _ (u »Tornade»),
«1»: _ (u »Tempête Tropicale»),
«2»: _ (arba »Ouragan»),
«3»: _ (arba »Tvarko smurtą»),
«4»: _ (arba »Orageux»),
«5»: _ (u »Pluie et Neige»),
«6»: _ (u »Pluie et Neige Mouillée»),
«7»: _ (u »kintamasis vidurkis»),
«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»: _ (arba »Orages Isolés»),
«38»: _ (arba »Orages Localisés»),
«39»: _ (arba »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»: _ (arba »Orages»),
«46»: _ (u »Tempête de Neige»),
«47»: _ (arba »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 »»),
"-": _ (arba "")
}condition_moon_font = {
«0»: _ (u »1 ″),
«1»: _ (u »N»),
«2»: _ (u »O»),
«3»: _ (u »P»),
«4»: _ (u »Q»),
«5»: _ (u »R»),
«6»: _ (u »S»),
«7»: _ (u »T»),
«8»: _ (u »U»),
«9»: _ (u »V»),
«10»: _ (u »W»),
«11»: _ (u »X»),
«12»: _ (u »Y»),
«13»: _ (u »Z»),
«14»: _ (u »0 ″),
«15»: _ (u »0 ″),
«16»: _ (u »A»),
«17»: _ (u »B»),
«18»: _ (u »C»),
«19»: _ (u »D»),
«20»: _ (u »E»),
«21»: _ (u »F»),
«22»: _ (u »G»),
«23»: _ (u »H»),
«24»: _ (u »I»),
«25»: _ (u »J»),
«26»: _ (u »K»),
«27»: _ (u »L»),
«28»: _ (u »M»),
«29»: _ (u »1 ″),
«Na»: _ (u »»),
"-": _ (arba "")
}savaitės diena = {
„Šiandien“: _ (arba „Šiandien“),
«Pirmadienis»: _ (u »pirmadienis»),
«Antradienis»: _ (u »antradienis»),
«Trečiadienis»: _ (u »trečiadienis»),
«Ketvirtadienis»: _ (u »ketvirtadienis»),
«Penktadienis»: _ (u »penktadienis»),
„Šeštadienis“: _ (u „Šeštadienis“),
„Sekmadienis“: _ (u „sekmadienis“)
}savaitės savaitės_ trumpa diena = {
„Šiandien“: _ (u „Dabar“),
«Pirmadienis»: _ (u »pirmadienis),
«Antradienis»: _ (u »antradienis),
„Trečiadienis“: _ (u „trečiadienis“),
«Ketvirtadienis»: _ (u »ketvirtadienis),
«Penktadienis»: _ (u »penktadienis),
„Šeštadienis“: _ (u „Šeštadienis“),
„Sekmadienis“: _ (u „Saulė“)
}savaitės_dienos diena = {
„Šiandien“: _ (u „šiandien“),
„Pirmadienis“: _ (u „Pirmadienis“),
«Antradienis»: _ (u »antradienis»),
«Trečiadienis»: _ (u »trečiadienis»),
«Ketvirtadienis»: _ (u »ketvirtadienis»),
«Penktadienis»: _ (u »penktadienis»),
„Šeštadienis“: _ (u „Šeštadienis“),
„Sekmadienis“: _ (u „sekmadienis“)
}day_of_week_short_en = {
„Šiandien“: _ (u „šiandien“),
„Pirmadienis“: _ (u „pirmadienis“),
«Antradienis»: _ (u »jūra»),
«Trečiadienis»: _ (u »wed»),
«Ketvirtadienis»: _ (u »ketvirtadienis),
«Penktadienis»: _ (u »fri»),
„Šeštadienis“: _ (u „sėdi“),
„Sekmadienis“: _ (u „dom“)
}savaitės_dienos diena = {
«Šiandien»: _ (u »Aujourd'hui»),
«Pirmadienis»: _ (u »Lundi»),
«Antradienis»: _ (u »Užgavėnės»),
«Trečiadienis»: _ (u »Mercredi»),
«Ketvirtadienis»: _ (u »Jeudi»),
«Penktadienis»: _ (u »Vendredi»),
„Šeštadienis“: _ (u „Samedi“),
„Sekmadienis“: _ (u „Dimanche“)
}day_of_week_short_fr = {
«Šiandien»: _ (u »Auj»),
„Pirmadienis“: _ (u „Pirmadienis“),
«Antradienis»: _ (u »kovas»),
„Trečiadienis“: _ (u „Mer“),
«Ketvirtadienis»: _ (u »Jeu»),
«Penktadienis»: _ (u »Ateik“),
„Šeštadienis“: _ (u „Sam“),
„Sekmadienis“: _ (u „Dim“)
}guolis_arrow_font = {
«N»: _ (u »i»),
«NNE»: _ (u »j»),
«ŠR»: _ (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»),
„ŠN“: _ (u „f“),
«ŠV»: _ (u »g»),
«ŠNW»: _ (u »h»),
«Nėra»: _ (u »«)
}guolio_teksto_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“),
„Jų“),
„SSW“: _ (u „SSO“),
«SW»: _ (u »SO»),
„WSW“: _ (u „WOW“),
«W»: _ (u »O»),
«Vakarų»: _ (u »ONO»),
«ŠV»: _ (u »NE»),
«ŠNW»: _ (u »NNO»),
«Nėra»: _ (u »N \ A»)
}guolio_teksto_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“),
„Jų“),
„SSW“: _ (u „SSO“),
«SW»: _ (u »SO»),
„WSW“: _ (u „WOW“),
«W»: _ (u »O»),
«Vakarų»: _ (u »ONO»),
«ŠV»: _ (u »NE»),
«ŠNW»: _ (u »NNO»),
«Nėra»: _ (u »N \ A»)
}„GlobalWeather“ klasė:
dabartinės sąlygos = []
dienos prognozė = []
nakties_prognozė = []lokalė = "in"
parinktys = Nėra
weatherxmldoc = ""TEMP_FILEPATH_CURRENT = "/tmp/conkyForecast-c-LOCATION.pkl"
TEMP_FILEPATH_DAYFORECAST = "/tmp/conkyForecast-df-LOCATION.pkl"
TEMP_FILEPATH_NIGHTFORECAST = "/tmp/conkyForecast-nf-LOCATION.pkl"
EXPIRY_MINUTES = 30
DEFAULT_SPACING = u »«def __init __ (savęs, parinktys):
self.options = parinktys
jei self.options.locale == Nėra:
bandyti:
# self.locale = locale.getdefaultlocale () [0] [0: 2]
self.locale = «es» # komentuokite šią eilutę priversti Ispanijos lokalę
# self.locale = "fr" # komentuokite šią eilutę priversti prancūzišką lokalę
išskyrus:
spausdinti "lokalė nenustatyta"
Kitas:
# self.locale = self.options.locale
self.locale = «es» # komentuokite šią eilutę priversti Ispanijos lokalę
# self.locale = "fr" # komentuokite šią eilutę priversti prancūzišką lokalęjei self.options.verbose == Tiesa:
spausdinti >> sys.stdout, „locale set to“, self.localedef getText (savarankiškai, mazgas):
rc = ""
mazgui mazgų sąraše:
if node.nodeType == mazgas.TEXT_NODE:
rc = rc + mazgas.duomenys
grįžti rcdef getSpaces (savęs, tarpų):
string = u »»
jei tarpai == Nėra:
eilutė = self.DEFAULT_SPACING
Kitas:
i diapazone (0, tarpai + 1):
eilutė = eilutė + u »«
grąžinimo eilutėdef isNumeric (savarankiškai, eilutė):
bandyti:
manekenas = plūdė (stygos)
grįžti Tiesa
išskyrus:
grąžinti Falsedef isConnectionAvailable (savarankiškai):
# įsitikinkite, kad galime pasiekti weather.com serverį atidarydami URL
bandyti:
Usock = urllib2.urlopen ('http://xoap.weather.com')
„Usock.close“ ()
grįžti Tiesa
išskyrus:
grąžinti Falsedef getBearingText (savarankiškas, guolis):
guolis = plūdė (guolis)
jei guolis <11.25:
grįžti u »N»
elifo guolis <33.75:
grįžti atgal »NNE»
elifo guolis <56.25:
grįžti u »ŠR»
elifo guolis <78.75:
grįžti »JAN»
elifo guolis <101.25:
grįžti u »E»
elifo guolis <123.75:
grįžti »ESE»
elifo guolis <146.25:
grįžti u »SE»
elifo guolis <168.75:
grįžti u »SSE»
elifo guolis <191.25:
grįžti u »S»
elifo guolis <213.75:
grįžti atgal »SSW»
elifo guolis <236.25:
grįžti u »SW»
elifo guolis <258.75:
grįžti atgal »WSW»
elifo guolis <281.25:
grįžti u »W»
elifo guolis <303.75:
grįžti atgal »WNW»
elifo guolis <326.25:
grįžti atgal »NW»
elifo guolis <348.75:
grįžti atgal »NNW»
Kitas:
grįžti «N / A»def convertCelsiusToFahrenheit (savęs, temp):
grįžimo str (int (grindys (((plūdė (temp) * 9.0) /5.0) +32)))def convertKilometresToMiles (savarankiškai, dist):
grįžimo str (int (grindys (plūdės (dist) * 0.621371192)))def convertMillibarsToInches (savarankiškai, mb):
grįžimo str (int (grindys (plūdės (MB) / 33.8582)))def getTemplateList (savarankiškai, šablonas):
templatelist = =]
for template_part in template.split («{«):
jei template_part! = «»:
for template_part į template_part.split ("}"):
jei template_part! = «»:
templatelist.append (u »» + template_part)grįžti templatelist
def getOutputText (savęs, duomenų tipas, pradžios diena, pabaigos diena, naktis, savaitės savaitė, imperijos, slėpties vienetai, tarpai):
#bandyti:
išvestis = u »»# apibrėžti dabartinius išvesties vienetus
jei paslėpti vienetai == Klaidinga:
jei imperijos == Klaidinga:
tempunitas = u »° C»
greičio vienetas = u »km / h»
slėgio vienetas = u »mb»
Kitas:
tempunit = u »° F»
greičio vienetas = u »mph»
slėgio vienetas = u »į»
Kitas:
tempunit = u »°»
speedunit = u »»
slėgio vienetas = u »»jei pradžios diena == Nėra: # dabartinių sąlygų
jei duomenų tipas == "DW":
jei self.locale == "yra":
jei trumpą savaitę == Tiesa:
išėjimas = WeatherText.day_of_week_short_es [self.current_conditions [0] .day_of_week]
Kitas:
išvestis = WeatherText.day_of_week_es [self.current_conditions [0] .day_of_week]
elif self.locale == "fr":
jei trumpą savaitę == Tiesa:
output = WeatherText.day_of_week_short_fr [self.current_conditions [0] .day_of_week]
Kitas:
output = WeatherText.day_of_week_fr [self.current_conditions [0] .day_of_week]
Kitas:
jei trumpą savaitę == Tiesa:
išvestis = WeatherText.day_of_week_short [self.current_conditions [0] .day_of_week]
Kitas:
išvestis = WeatherText.day_of_week [self.current_conditions [0] .day_of_week]
elif duomenų tipas == "WF": # orų šriftas
išvestis = WeatherText.conditions_weather_font [self.current_conditions [0] .condition_code]
elif duomenų tipas == "LT":
string = self.current_conditions [0] .lėtas
if self.isNumeric (string) == Tiesa:
jei imperijos == Tiesa:
string = self.convertCelsiusToFahrenheit (eilutė)
eilutė = eilutė + tempunitas
išvestis = eilutė
elif duomenų tipas == "HT":
string = self.current_conditions [0] .aukštas
if self.isNumeric (string) == Tiesa:
jei imperijos == Tiesa:
string = self.convertCelsiusToFahrenheit (eilutė)
eilutė = eilutė + tempunitas
išvestis = eilutė
elif duomenų tipas == "CC":
jei self.locale == "yra":
išvestis = WeatherText.conditions_text_es [self.current_conditions [0] .condition_code]
elif self.locale == "fr":
išvestis = WeatherText.conditions_text_fr [self.current_conditions [0] .condition_code]
Kitas:
išvestis = WeatherText.conditions_text [self.current_conditions [0] .condition_code]
elif duomenų tipas == "CT":
išvestis = savęs. srovės_ sąlygos [0]. sąlygos_tekstas
elif duomenų tipas == "PC":
string = self.current_conditions [0] .precip
if self.isNumeric (string) == Tiesa:
eilutė = eilutė + u »%»
išvestis = eilutė
elif duomenų tipas == "HM":
string = self.current_conditions [0]. drėgmė
if self.isNumeric (string) == Tiesa:
eilutė = eilutė + u »%»
išvestis = eilutė
elif duomenų tipas == "WD":
string = self.current_conditions [0] .vėjo_direktorius
if self.isNumeric (string) == Tiesa:
string = self.getBearingText (eilutė)jei self.locale == "yra":
išvestis = WeatherText.bearing_text_es [string]
elif self.locale == "fr":
išvestis = WeatherText.bearing_text_fr [string]
Kitas:
išvestis = eilutėelif duomenų tipas == "BF":
string = self.current_conditions [0] .vėjo_direktorius
if self.isNumeric (string) == Tiesa:
string = WeatherText.bearing_arrow_font [self.getBearingText (string)]
išvestis = eilutė
elif duomenų tipas == "WS":
string = self.current_conditions [0] .vėjo_spartis
if self.isNumeric (string) == Tiesa:
jei imperijos == Tiesa:
string = self.convertKilometresToMiles (eilutė)
eilutė = eilutė + greičio vienetas
išvestis = eilutė
elif duomenų tipas == "WG":
string = self.current_conditions [0] .vėjo_bjauros
if self.isNumeric (string) == Tiesa:
jei imperijos == Tiesa:
string = self.convertKilometresToMiles (eilutė)
eilutė = eilutė + greičio vienetas
išvestis = eilutė
elif duomenų tipas == "CN":
išėjimas = savęs.srovės_lygos [0] .miestis
elif duomenų tipas == "SR":
išvestis = savęs. srovės_ sąlygos [0]. saulėtekis
elif duomenų tipas == "SS":
išvestis = savęs. srovės_ sąlygos [0]. saulėlydis
elif duomenų tipas == "MP":
išvestis = savaiminės srovės sąlygos [0]. mėnulio fazė
elif duomenų tipas == "MF":
išvestis = WeatherText.conditions_moon_font [self.current_conditions [0] .moon_icon]
elif duomenų tipas == "BR":
string = self.current_conditions [0] .bar_read
if self.isNumeric (string) == Tiesa:
jei imperijos == Tiesa:
string = self.convertMillibarsToInches (eilutė)
eilutė = eilutė + slėgio vienetas
išvestis = eilutė
elif duomenų tipas == "BD":
išvestis = savaiminės srovės_ sąlygos [0]. bar_desc
Kitas:
output = "\ nKLAIDA: reikalingas nežinomas duomenų tipas"else: # prognozės duomenys
if endday == Nėra: # jei nenustatyta pabaigos diena, naudokite startday
pabaigos diena = pradžios dienajei naktis == Tiesa: reikalinga # nakties prognozė
už dienos_numerį diapazone (pradžios diena, pabaigos diena + 1):
jei duomenų tipas == "DW":
jei self.locale == "yra":
jei trumpą savaitę == Tiesa:
output = output + self.getSpaces (tarpai) + WeatherText.day_of_week_short_es [self.night_forecast [day_number] .day_of_week]
Kitas:
output = output + self.getSpaces (tarpai) + WeatherText.day_of_week_es [self.night_forecast [day_number] .day_of_week]
elif self.locale == "fr":
jei trumpą savaitę == Tiesa:
output = output + self.getSpaces (tarpai) + WeatherText.day_of_week_short_fr [self.night_forecast [day_number] .day_of_week]
Kitas:
output = output + self.getSpaces (tarpai) + WeatherText.day_of_week_fr [self.night_forecast [day_number] .day_of_week]
Kitas:
jei trumpą savaitę == Tiesa:
output = output + self.getSpaces (tarpai) + WeatherText.day_of_week_short [self.night_forecast [day_number] .day_of_week]
Kitas:
išvestis = išvestis + self.getSpaces (tarpai) + WeatherText.day_of_week [self.night_forecast [day_number] .day_of_week]
elif duomenų tipas == "WF": # orų šriftas
output = output + self.getSpaces (tarpai) + WeatherText.conditions_weather_font [self.night_forecast [day_number] .condition_code]
elif duomenų tipas == "LT":
string = self.night_forecast [day_number] .low
if self.isNumeric (string) == Tiesa:
jei imperijos == Tiesa:
string = self.convertCelsiusToFahrenheit (eilutė)
eilutė = eilutė + tempunitas
output = output + self.getSpaces (tarpai) + eilutėelif duomenų tipas == "HT":
string = self.night_forecast [day_number] .high
if self.isNumeric (string) == Tiesa:
jei imperijos == Tiesa:
string = self.convertCelsiusToFahrenheit (eilutė)
eilutė = eilutė + tempunitas
output = output + self.getSpaces (tarpai) + eilutė
elif duomenų tipas == "CC":
jei self.locale == "yra":
output = output + self.getSpaces (tarpai) + WeatherText.conditions_text_es [self.night_forecast [day_number] .condition_code]
elif self.locale == "fr":
output = output + self.getSpaces (tarpai) + WeatherText.conditions_text_fr [self.night_forecast [day_number] .condition_code]
Kitas:
output = output + self.getSpaces (tarpai) + WeatherText.conditions_text [self.night_forecast [day_number] .condition_code]
elif duomenų tipas == "CT":
output = output + self.getSpaces (tarpai) + self.night_forecast [day_number] .condition_text
elif duomenų tipas == "PC":
string = self.night_forecast [day_number] .precip
if self.isNumeric (string) == Tiesa:
eilutė = eilutė + u »%»
output = output + self.getSpaces (tarpai) + eilutė
elif duomenų tipas == "HM":
string = self.night_forecast [day_number]. drėgmė
if self.isNumeric (string) == Tiesa:
eilutė = eilutė + u »%»
output = output + self.getSpaces (tarpai) + eilutė
elif duomenų tipas == "WD":
string = self.night_forecast [day_number] .wind_dir
jei self.locale == "yra":
output = output + self.getSpaces (tarpai) + WeatherText.bearing_text_es [string]
elif self.locale == "fr":
output = output + self.getSpaces (tarpai) + WeatherText.bearing_text_fr [string]
Kitas:
output = output + self.getSpaces (tarpai) + eilutėelif duomenų tipas == "BF":
output = output + self.getSpaces (tarpai) + WeatherText.bearing_arrow_font [self.night_forecast [day_number] .wind_dir]
elif duomenų tipas == "WS":
string = self.night_forecast [day_number] .wind_speed
if self.isNumeric (string) == Tiesa:
jei imperijos == Tiesa:
string = self.convertKilometresToMiles (eilutė)
eilutė = eilutė + greičio vienetas
output = output + self.getSpaces (tarpai) + eilutė
elif duomenų tipas == "WG":
string = self.night_forecast [day_number] .wind_gusts
if self.isNumeric (string) == Tiesa:
jei imperijos == Tiesa:
string = self.convertKilometresToMiles (eilutė)
eilutė = eilutė + greičio vienetas
output = output + self.getSpaces (tarpai) + eilutė
elif duomenų tipas == "CN":
output = output + self.getSpaces (tarpai) + self.night_forecast [day_number]. miestas
elif duomenų tipas == "SR":
output = output + self.getSpaces (tarpai) + self.night_forecast [day_number]. saulėtekis
elif duomenų tipas == "SS":
output = output + self.getSpaces (tarpai) + self.night_forecast [day_number] .sunset
elif duomenų tipas == "MP":
output = output + self.getSpaces (tarpai) + self.night_forecast [day_number]. mėnulio_fazė
elif duomenų tipas == "MF":
output = output + self.getSpaces (tarpai) + WeatherText.conditions_moon_font [self.night_forecast [day_number] .moon_icon]
elif duomenų tipas == "BR":
output = output + self.getSpaces (tarpai) + self.night_forecast [day_number]. bar_read
elif duomenų tipas == "BD":
output = output + self.getSpaces (tarpai) + self.night_forecast [day_number]. bar_desc
Kitas:
output = "\ nKLAIDA: reikalingas nežinomas duomenų tipas"
pertraukadar: norima # dienos prognozės
už dienos_numerį diapazone (pradžios diena, pabaigos diena + 1):
jei duomenų tipas == "DW":
jei self.locale == "yra":
jei trumpą savaitę == Tiesa:
output = output + self.getSpaces (tarpai) + WeatherText.day_of_week_short_es [self.day_forecast [day_number] .day_of_week]
Kitas:
output = output + self.getSpaces (tarpai) + WeatherText.day_of_week_es [self.day_forecast [day_number] .day_of_week]
elif self.locale == "fr":
jei trumpą savaitę == Tiesa:
output = output + self.getSpaces (tarpai) + WeatherText.day_of_week_short_fr [self.day_forecast [day_number] .day_of_week]
Kitas:
output = output + self.getSpaces (tarpai) + WeatherText.day_of_week_fr [self.day_forecast [day_number] .day_of_week]
Kitas:
jei trumpą savaitę == Tiesa:
output = output + self.getSpaces (tarpai) + WeatherText.day_of_week_short [self.day_forecast [day_number] .day_of_week]
Kitas:
output = output + self.getSpaces (tarpai) + WeatherText.day_of_week [self.day_forecast [day_number] .day_of_week]
elif duomenų tipas == "WF": # orų šriftas
output = output + self.getSpaces (tarpai) + WeatherText.conditions_weather_font [self.day_forecast [day_number] .condition_code]
elif duomenų tipas == "LT":
string = self.day_forecast [day_number] .low
if self.isNumeric (string) == Tiesa:
jei imperijos == Tiesa:
string = self.convertCelsiusToFahrenheit (eilutė)
eilutė = eilutė + tempunitas
output = output + self.getSpaces (tarpai) + eilutė
elif duomenų tipas == "HT":
string = self.day_forecast [day_number] .high
if self.isNumeric (string) == Tiesa:
jei imperijos == Tiesa:
string = self.convertCelsiusToFahrenheit (eilutė)
eilutė = eilutė + tempunitas
output = output + self.getSpaces (tarpai) + eilutė
elif duomenų tipas == "CC":
jei self.locale == "yra":
output = output + self.getSpaces (tarpai) + WeatherText.conditions_text_es [self.day_forecast [day_number] .condition_code]
elif self.locale == "fr":
output = output + self.getSpaces (tarpai) + WeatherText.conditions_text_fr [self.day_forecast [day_number] .condition_code]
Kitas:
išvestis = išvestis + self.getSpaces (tarpai) + WeatherText.conditions_text [self.day_forecast [day_number] .condition_code]
elif duomenų tipas == "CT":
output = output + self.getSpaces (tarpai) + self.day_forecast [day_number]. sąlygos_tekstas
elif duomenų tipas == "PC":
string = self.day_forecast [day_number] .precip
if self.isNumeric (string) == Tiesa:
eilutė = eilutė + u »%»
output = output + self.getSpaces (tarpai) + eilutė
elif duomenų tipas == "HM":
string = self.day_forecast [day_number]. drėgmė
if self.isNumeric (string) == Tiesa:
eilutė = eilutė + u »%»
output = output + self.getSpaces (tarpai) + eilutė
elif duomenų tipas == "WD":
string = self.day_forecast [day_number] .wind_dirjei self.locale == "yra":
output = output + self.getSpaces (tarpai) + WeatherText.bearing_text_es [string]
elif self.locale == "fr":
output = output + self.getSpaces (tarpai) + WeatherText.bearing_text_fr [string]
Kitas:
output = output + self.getSpaces (tarpai) + eilutėelif duomenų tipas == "BF":
output = output + self.getSpaces (tarpai) + WeatherText.bearing_arrow_font [self.day_forecast [day_number] .wind_dir]
elif duomenų tipas == "WS":
string = self.day_forecast [day_number] .wind_speed
if self.isNumeric (string) == Tiesa:
jei imperijos == Tiesa:
string = self.convertKilometresToMiles (eilutė)
eilutė = eilutė + greičio vienetas
output = output + self.getSpaces (tarpai) + eilutė
elif duomenų tipas == "WG":
string = self.day_forecast [day_number] .wind_gusts
if self.isNumeric (string) == Tiesa:
jei imperijos == Tiesa:
string = self.convertKilometresToMiles (eilutė)
eilutė = eilutė + greičio vienetas
output = output + self.getSpaces (tarpai) + eilutė
elif duomenų tipas == "CN":
output = output + self.getSpaces (tarpai) + self.day_forecast [day_number] .city
elif duomenų tipas == "SR":
output = output + self.getSpaces (tarpai) + self.day_forecast [day_number] .sunrise
elif duomenų tipas == "SS":
output = output + self.getSpaces (tarpai) + self.day_forecast [day_number]. saulėlydis
elif duomenų tipas == "MP":
output = output + self.getSpaces (tarpai) + self.day_forecast [day_number]. mėnulio_fazė
elif duomenų tipas == "MF":
output = output + self.getSpaces (tarpai) + WeatherText.conditions_moon_font [self.day_forecast [day_number] .moon_icon]
elif duomenų tipas == "BR":
output = output + self.getSpaces (tarpai) + self.day_forecast [day_number]. bar_read
elif duomenų tipas == "BD":
output = output + self.getSpaces (tarpai) + self.day_forecast [day_number]. bar_desc
Kitas:
output = u »\ nKLAIDA: reikalaujama nežinomo duomenų tipo»
pertraukaoutput = u »» + output.strip (u »«) # praranda priekinius / galinius tarpus
grąžinimo išvestis#isskyrus:
#print "getOutputText: Netikėta klaida:", sys.exc_info () [0]def getOutputTextFromTemplate (savarankiškai, šablonas):
#bandyti:# raktų į šablono duomenis
DATATYPE_KEY = "–datatype ="
STARTDAY_KEY = "-startday ="
ENDDAY_KEY = "–diena ="
NIGHT_KEY = "–naktis"
SHORTWEEKDAY_KEY = "–trumpoji savaitė"
IMPERIAL_KEY = "-perperial"
HIDEUNITS_KEY = "-hideunits"
SPACES_KEY = "–spaces ="išvestis = u »»
parinktis rasta = klaidinga
#įkelkite failą
bandyti:
fileinput = atidaryti (self.options.template)
template = fileinput.read ()
fileinput.close ()
išskyrus:
output = u »Šablono failas nerastas!»templatelist = self.getTemplateList (šablonas)
# leidžia pereiti per šablonų sąrašą ir nustatyti kiekvieno surasto elemento išvestį
i diapazone (0, len (templatelist) -1):pos = templatelist [i] .find (DATATYPE_KEY)
jei pos! = -1:
rasti variantas = tiesa
pos = pos + len (DATATYPE_KEY)
duomenų tipas = templatelist [i] [pos: pos + 4] .strip («}»). juosta («{«). juosta («-«). juosta (»«)
Kitas:
duomenų tipas = Nėrapos = templatelist [i] .find (STARTDAY_KEY)
jei pos! = -1:
rasti variantas = tiesa
pos = pos + len (STARTDAY_KEY)
pradžios diena = int (templatelist [i] [pos: pos + 4] .strip ("}"). juosta ("{"). juosta ("-"). juosta (""))
Kitas:
pradžios diena = nėrapos = templatelist [i] .find (ENDDAY_KEY)
jei pos! = -1:
rasti variantas = tiesa
pos = pos + len (ENDDAY_KEY)
pabaiga = int (templatelist [i] [pos: pos + 4] .strip ("}"). juosta ("{"). juosta ("-"). juosta (""))
Kitas:
pabaigos diena = Nėrapos = templatelist [i] .find (NIGHT_KEY)
jei pos! = -1:
rasti variantas = tiesa
naktis = Tiesa
Kitas:
naktis = Klaidingapos = templatelist [i] .find (SHORTWEEKDAY_KEY)
jei pos! = -1:
rasti variantas = tiesa
shortweekday = Tiesa
Kitas:
shortweekday = Klaidingapos = templatelist [i] .find (IMPERIAL_KEY)
jei pos! = -1:
rasti variantas = tiesa
imperinis = Tiesa
Kitas:
imperatoriškoji = klaidingapos = templatelist [i] .find (HIDEUNITS_KEY)
jei pos! = -1:
rasti variantas = tiesa
paslėpti vienetai = Tiesa
Kitas:
paslėpti vienetai = klaidingapos = templatelist [i] .find (SPACES_KEY)
jei pos! = -1:
rasti variantas = tiesa
pos = pos + len (SPACES_KEY)
tarpai = int (templatelist [i] [pos: pos + 4] .strip («}»). juosta («{«). juosta («-«). juosta (»«))
Kitas:
tarpai = 1jei parinktis rasta == Tiesa:
templatelist [i] = self.getOutputText (duomenų tipas, pradžios diena, pabaigos diena, naktis, savaitės diena, imperija, slėpiniai, tarpai)
parinktis rasta = klaidinga# pereiti sąrašą, sujungiant išvestį dabar, kai jis buvo užpildytas
prekei templatelist:
produkcija = produkcija + elementasgrąžinimo išvestis
#isskyrus:
#print "getOutputTextFromTemplate: Netikėta klaida:", sys.exc_info () [0]def fetchData (savarankiškai):
# visada gauti metrikos duomenis, šiuose duomenyse naudoti pokalbio funkcijas
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“)jei self.isConnectionAvailable () == Neteisingas:
jei egzistuoja os.path.exe (file_path_current):
RefetchData = klaidinga
dar: # nėra ryšio, nėra talpyklos, sprogimas!
spausdinti "Nėra interneto ryšio ir nėra duomenų apie orą talpykloje."
elif self.options.refetch == Tiesa:
RefetchData = Tiesa
Kitas:
# ar duomenis reikia vėl gauti?
jei egzistuoja os.path.exe (file_path_current):
lastmodDate = time.localtime (os.stat (file_path_current) [ST_MTIME])
expiryDate = (datetime.datetime.today () - datetime.timedelta (minutes = self.EXPIRY_MINUTES)). timetuple ()jei galiojimo pabaigos data> lastmodDate:
RefetchData = Tiesa
Kitas:
RefetchData = klaidinga
Kitas:
RefetchData = Tiesa# gauti dabartinių sąlygų duomenis iš svetainės arba „nuimant“
jei „RefetchData“ == Tiesa:# gauti dabartinių sąlygų duomenis iš „xoap“ tarnybos
bandyti:# 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 & vienetas = m '
jei self.options.verbose == Tiesa:
spausdinti >> sys.stdout, «gauti duomenis apie orą iš«, URLUsock = urllib2.urlopen (url)
xml = usock.read ()
„Usock.close“ ()
self.weatherxmldoc = minidom.parseString (xml)
išskyrus:
spausdinti „fetchData: Netikėta klaida:“, sys.exc_info () [0]
spausdinti "Nepavyko susisiekti su oro šaltiniu dėl dabartinių sąlygų"# pasakykite vartotojui, jei vieta yra bloga ...
found = xml.find ("Pateikta neteisinga vieta")
jei rasta! = -1:
spausdinti „Pateikta neteisinga vieta“# apklausti orų duomenis, įkelti į klasės struktūrą ir juos marinuoti
bandyti:# parengti orų duomenų sąrašus
self.current_conditions = []
self.day_forecast = []
self.night_forecast = []# rinkti bendruosius duomenis
weather_n = self.weatherxmldoc.documentElement
location_n = weather_n.getElementsByTagName ('loc') [0]
city_n = location_n.getElementsByTagName ('dnam') [0]
city = self.getText (city_n.childNodes)# rinkti dabartinių sąlygų duomenis
day_of_week = u »Šiandien»
kritimas = u »Nėra»
sunrise_n = location_n.getElementsByTagName ('sunr') [0]
sunrise = self.getText (sunrise_n.childNodes)
saulėlydžio_n = vieta_n.getElementsByTagName ('saulutės') [0]
saulėlydis = 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 ('piktograma') [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 ('juosta') [0]
bar_read_n = bar_n.getElementsByTagName ('r') [0]
bar_read = self.getText (bar_read_n.childNodes)
bar_desc_n = bar_n.getElementsByTagName ('d') [0]
bar_desc = self.getText (bar_desc_n.childNodes)
wind_n = current_condition_n.getElementsByTagName ('wind') [0]
wind_speed_n = wind_n.getElementsByTagName ('s') [0]
wind_speed = self.getText (wind_speed_n.childNodes)
wind_gust_n = wind_n.getElementsByTagName ('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)
drėgmės_n = dabartinė_lygų_n.getElementsByTagName ('hmid') [0]
drėgmė = self.getText (drėgmės_n.childNodes)
moon_n = current_condition_n.getElementsByTagName ('mėnulis') [0]
mėnulio_ikonas_n = mėnulis_n.getElementsByTagName ('piktograma') [0]
moon_icon = self.getText (mėnulio_ikonas_n.childNodes)
mėnulio_fazė_n = mėnulio_n.getElementsByTagName ('t') [0]
mėnulio_fazė = self.getText (mėnulio_fazės_n.childNodes)
current_conditions_data = WeatherData (savaitės_savaitė, dabartinis_tempimo_pratimas, dabartinis_tempimas, dabartinis_kodas, dabartinis_desc, krituliai, drėgnumas, vėjo kryptis, vėjo greitis, vėjo_būgštai, miestas, saulėtekis, saulėlydis, mėnulio_fazė, mėnulio_ikonas, juostos_srovė, bar_desc)
self.current_conditions.append (current_conditions_data)# rinkti prognozės duomenis
bar_read = u »Nėra»
bar_desc = u »Nėra»
mėnulio_fazė = u »Nėra»
moon_icon = u »na»
prognozės_n = orų_n.getElementsByTagName ('dayf') [0]
day_nodes = prognozės_n.getElementsByTagName ('diena')dienai day_nodes:
day_of_week = day.getAttribute ('t')
day_of_year = day.getAttribute ('dt')
high_temp_n = day.getElementsByTagName ('labas') [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]
saulėlydis = self.getText (sunset_n.childNodes)Konkretūs # dienos prognozės duomenys
daytime_n = day.getElementsByTagName ('part') [0] # diena
condition_code_n = daytime_n.getElementsByTagName ('piktograma') [0]
condition_code = self.getText (condition_code_n.childNodes)
condition_n = daytime_n.getElementsByTagName ('t') [0]
condition = self.getText (condition_n.childNodes)
rain_n = daytime_n.getElementsByTagName ('ppcp') [0]
lietus = self.getText (lietus_n.childNodes)
drėgmės_n = dienos metu_n.getElementsByTagName ('hmid') [0]
drėgmė = self.getText (drėgmės_n.childNodes)
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 (savaitės savaitės, žemos temperatūros, aukštos temperatūros, būklės kodo, būklės, kritulių, drėgmės, vėjo krypties, vėjo greičio, vėjo bangos, miesto, saulėtekio, saulėlydžio, mėnulio fazės, mėnulio_ikonų, barų skaitymo, bar_desc)
self.day_forecast.append (day_forecast_data)# konkrečios nakties prognozės duomenys
daytime_n = day.getElementsByTagName ('part') [1] # naktis
condition_code_n = daytime_n.getElementsByTagName ('piktograma') [0]
condition_code = self.getText (condition_code_n.childNodes)
condition_n = daytime_n.getElementsByTagName ('t') [0]
condition = self.getText (condition_n.childNodes)
rain_n = daytime_n.getElementsByTagName ('ppcp') [0]
lietus = self.getText (lietus_n.childNodes)
drėgmės_n = dienos metu_n.getElementsByTagName ('hmid') [0]
drėgmė = self.getText (drėgmės_n.childNodes)
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 (savaitės savaitės, žemos temperatūros, aukštos temperatūros, būklės kodo, būklės, kritulių, drėgmės, vėjo krypties, vėjo greičio, vėjo šlykštynių, miesto, saulėtekio, saulėlydžio, mėnulio fazės, mėnulio_ikonų, barų skaitymo, bar_desc)
self.night_forecast.append (night_forecast_data)# marinuoti duomenis kitam kartui!
fileoutput = atidaryti (file_path_current, 'w')
„pickle.dump“ („self.current_conditions“, failų išvestis)
fileoutput.close ()fileoutput = atidaryti (file_path_dayforecast, 'w')
pickle.dump (self.day_forecast, fileoutput)
fileoutput.close ()fileoutput = atidaryti (file_path_nightforecast, 'w')
pickle.dump (self.night_forecast, fileoutput)
fileoutput.close ()išskyrus:
spausdinti „fetchData: Netikėta klaida:“, sys.exc_info () [0]
spausdinti "Nepavyko ištirti orų duomenų"else: # gauti orų duomenis iš marinuotų klasės failų
jei self.options.verbose == Tiesa:
spausdinti >> sys.stdout, «oro duomenų gavimas iš failo:«, file_path_currentfileinput = atidaryti (file_path_current, 'r')
self.current_conditions = marinatas.load (failo įvestis)
fileinput.close ()jei self.options.verbose == Tiesa:
spausdinti >> sys.stdout, "gaunami dienos prognozės duomenys iš failų:", file_path_dayforecast, file_path_nightforecastfileinput = atidaryti (file_path_dayforecast, 'r')
self.day_forecast = pickle.load (failo įvestis)
fileinput.close ()jei self.options.verbose == Tiesa:
spausdinti >> sys.stdout, «dienos prognozių duomenų nuskaitymas iš failų:«, file_path_nightforecast, file_path_nightforecastfileinput = atidaryti (file_path_nightforecast, 'r')
self.night_forecast = pickle.load (failo įvestis)
fileinput.close ()def outputData (savarankiškai):
#bandyti:jei self.options.template! = Nėra:
output = self.getOutputTextFromTemplate (self.options.template)
Kitas:
output = self.getOutputText (self.options.datatype, self.options.startday, self.options.endday, self.options.night, self.options.sortweekday, self.options.perperial, self.options.hideunits, self. parinktys. tarpai)
spausdinti output.encode ("utf-8")
#isskyrus:
#print «outputData: Netikėta klaida:«, sys.exc_info () [0]jei __pavadinimas == "__main__":
analizatorius = CommandLineParser ()
(parinktys, argumentai) = parser.parse_args ()jei parinktys.verbose == Tiesa:
spausdinti >> sys.stdout, "location:", options.location
spausdinti >> sys.stdout, „imperial:“, options.imperial
spausdinti >> sys.stdout, "duomenų tipas:", options.datatype
spausdinti >> sys.stdout, "night:", options.night
spausdinti >> sys.stdout, "pradžios diena:", parinktys.pradiena
spausdinti >> sys.stdout, „pabaigos diena:“, parinktys.diena
spausdinti >> sys.stdout, „tarpai:“, „options.spaces“
spausdinti >> sys.stdout, "verbose:", options.verbose
spausdinti >> sys.stdout, „refetch:“, options.refetch# sukurti naują visuotinį orų objektą
oras = „GlobalWeather“ (pasirinktys)
weather.fetchData ()
weather.outputData ()
Sukuriame failą ~ / Conky / scripts / myweather.template
gedit ~ / Conky / scripts / myweather.template
į vidų įklijuojame:
{–Datatype = DW –startday = 1}: {–datatype = CC –startday = 1}
{–Datatype = HT –startday = 1} / {–datatype = LT –startday = 1} Vėjas nuo {–datatype = WD –startday = 1} iki {–datatype = WS –startday = 1}
Drėgmė: {–datatype = HM –startday = 1} Krituliai: {–datatype = PC –startday = 1}
Saulėtekis: {–datatype = SR –startday = 1} Saulėlydis: {–datatype = SS –pradiena = 1}
————————————————
{–Datatype = DW –startday = 2}: {–datatype = CC –startday = 2}
{–Datatype = HT –startday = 2} / {–datatype = LT –startday = 2} Vėjas nuo {–datatype = WD –startday = 2} iki {–datatype = WS –startday = 2}
Drėgmė: {–datatype = HM –startday = 2} Krituliai: {–datatype = PC –startday = 2}
Saulėtekis: {–datatype = SR –startday = 2} Saulėlydis: {–datatype = SS –pradiena = 2}
————————————————
{–Datatype = DW –startday = 3}: {–datatype = CC –startday = 3}
{–Datatype = HT –startday = 3} / {–datatype = LT –startday = 3} Vėjas nuo {–datatype = WD –startday = 3} iki {–datatype = WS –startday = 3}
Drėgmė: {–datatype = HM –startday = 3} Krituliai: {–datatype = PC –startday = 3}
Saulėtekis: {–datatype = SR –startday = 3} Saulėlydis: {–datatype = SS –pradiena = 3}
————————————————
{–Datatype = DW –startday = 4}: {–datatype = CC –startday = 4}
{–Datatype = HT –startday = 4} / {–datatype = LT –startday = 4} Vėjas nuo {–datatype = WD –startday = 4} iki {–datatype = WS –startday = 4}
Drėgmė: {–datatype = HM –startday = 4} Krituliai: {–datatype = PC –startday = 4}
Saulėtekis: {–datatype = SR –startday = 4} Saulėlydis: {–datatype = SS –pradiena = 4}
Sukuriame failą ~ / Conky / scripts / mail / conkyEmail.py (turime sukurti pašto aplanką)
gedit ~ / Conky / scripts / mail / conkyEmail.py
ir įklijuojame:
tave importuoti
importuoti eilutę# Žemiau kabutėse įveskite savo vartotojo vardą ir slaptažodį
# pvz. vartotojo vardas = »vartotojo vardas» ir slaptažodis = »slaptažodis»
vartotojo vardas = »JŪSŲ_USUARIO_SINARROBA«
slaptažodis = »JŪSŲ_RAKTAS«com = »wget -O - https: //» + vartotojo vardas + »:» + slaptažodis + »@ mail.google.com / mail / feed / atom –no-check-certificate»
temp = os.popen (com)
msg = temp.read ()
index = string.find (msg, » »)
index2 = string.find (msg, » »)
fc = int (msg [rodyklė + 11: rodyklė2])jei fc == 0:
spausdinti „0 naujų“
Kitas:
spausdinti str (fc) + »naujas»
Taigi dabar turite 7 failus:
Aplanke: ~
-> .startconky << - padaryti vykdomąjį
Aplanke: ~ / Conky
-> conkymain
-> conkyforecast
-> konjakas
ir aplanke: ~ / Conky / scripts
-> conkyForecast.py << - padaryti vykdomąjį
-> myweather.template
ir aplanke: ~ / Conky / scripts / mail
conkyEmail.py << - padaryti vykdomąjį
Štai ir viskas, patikslinimai, kur parašyta / home / user / ... jūsų vartotojo vardas ir toje vietoje, kur eina „Gmail“ duomenys, aš paryškinau spalvomis, kur turite įdėti savo duomenis.
norėdamas užmušti nešvankų procesą, rašyk į konsolę
killall conky
norėdamas paleisti „conky“, rašyk į konsolę
./.startconky
kai viską sutvarkysite, jei norite, kad kiekviena sesija prasidėtų
Sistema—> Nuostatos—> Seansai ir paleisties programose mes ją įtraukiame
Varde mes galime parašyti „Conky“, „Order ./.startconky“ su tuo, kad jis prasidės kiekvieną kartą, kai įjungsite kompiuterį.
Viskas, tikiuosi, kad tai jums padės.