Conky, Mana iestatīšana

Fecfactor man vakar lūdza publicēt konja konfigurāciju, kuru es parādīju zemāk redzamajā ekrānuzņēmumā

Kā redzat, runa ir par 3 konkiem, kas tiek izpildīti, izmantojot skriptu, tā paša konfigurācija ir balstīta uz šo ziņu ievietojis lietotājs Brūss M. forumos Ubuntu-Ar ar dažām izmaiņām pasta konkā, kas manā gadījumā ir domāts Gmail.

Atsauces rakstā to ļoti labi izskaidro Brūss, bet arī kā atmiņas palīglīdzekli man es kopēšu veicamās darbības un savu konku kodu katram, kam tas ir.

Protams, mums ir jāinstalē konks, čokurošanās un pitons, tāpēc ierakstām konsolē:

sudo apt-get instalējiet conky curl python

Weather.ttf avots un bultiņas.ttf ir šeit. Mēness avots.ttf ir šeit kad esat lejupielādējis, tie ir jākopē uz / usr / share / fonts

Tagad izveidosim savu skriptu ar nosaukumu ~. / Startconky

gksudo gedit ~ / .startconky

tukšā faila iekšpusē mēs ielīmējam sekojošo

#! / bin / bash
gulēt 0 un # 0 labi Xfce - izmantojiet Gnome no 20 līdz 30
conky -c ~ / Conky / conkymain &
#sleep 0 & # 0 labi Xfce - izmantojiet 1 Gnome
conky -c ~ / Conky / conkyforecast &
#sleep 0 & # 0 labi Xfce - izmantojiet 1 Gnome
conky -c ~ / Conky / conkymail &

Tagad mēs izveidojam conkymain failu mapē ~ / Conky, ja mums nav mapes Conky, mums tas būs jāizveido.

gedit ~ / Conky / conkymain

Es izmantoju Calibri fontu, ja jums tā nav, nomainiet to ar visu, ko vēlaties.

Mēs turamies iekšā, kas seko

fona nr
own_window jā
own_wowow_transparent jā
own_window_hints nedekorēts, zemāk, lipīgs, skip_taskbar, skip_pager
savs_logu_krāsa melna
double_buffer jā
use_spacer pa kreisi
use_xft jā
fonta kalibri: size = 9
xftfont calibri: izmērs = 9
xftalpha 0.5
update_interval 5.0
lielie burti nē # iestatīts uz jā, ja vēlaties, lai viss teksts būtu ar lielajiem burtiem
stipled_borders 3
robežas_zīme 9
robežas_platums 10
noklusējuma_krāsa balta
noklusējuma_kontūras_krāsa melna
noklusējuma_ēnas_krāsa melna
krāsa0 ciāna
color1 gaiši zils
krāsa2 oranža
krāsa3 dzeltena
krāsa4 kvieši
krāsa5 balta
krāsa6 balta
krāsa7 balta
krāsa8 balta
krāsa9 balta
izlīdzināšana augšējā_ labā # vai augšējā kreisā, apakšējā_ kreisā, apakšējā labā
sprauga_x 10
sprauga_y 35
text_buffer_size 128 # prognozei izmantojiet 1024
no_buffers yes # Vai atņemt failu sistēmas buferus no izmantotās atmiņas?
vilkt_malas nr
draw_outline yes # pastiprina tekstu, ja jā
draw_shades jā # shadecolor melns

TEKSTS
$ {font calibri: size = 12} $ {alignc} $ {color1} $ sysname $ kodols vietnē $ machine} $ color $ fonts
$ {font calibri: size = 12} $ {alignc} $ {color2} $ {exec whoami} @ $ nodename $ color $ font
$ {color0} $ {hr 1} $ krāsa
$ {font calibri: size = 20} $ {alignc} $ {time% H:% M} $ fonts
$ {font calibri: size = 12} $ {color1} $ {alignc} $ {time% A,% d% b. % Y} $ color $ fonts
$ {color3} UpTime: $ {alignr 2} $ uptime $ color
$ {color0} $ {hr 1} $ krāsa
Procesors $ {voffset 5} $ {color2}: $ {alignc} $ color $ running_processes $ {color1} / $ color $ apstrādā $ {alignr 2} $ {color2} $ {cpubar cpu0 14,80} $ color
$ {color1} $ {voffset -16} $ {alignr 5} $ cpu% $ color
$ {voffset 2} $ {color1} Vidējā ielādes summa ($ {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} buferēts: $ color $ {buffers} $ {alignr 2} $ {color1} Kešatmiņā: $ 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} $ krāsa
$ {voffset 5} $ {color2} HD informācija $ {color1} - $ color Bezmaksas $ {color1} - lietota - $ {color2} kopā
$ {voffset 5} $ {color1} Sakne: $ color $ {fs_free_perc /}% $ {alignr 2} $ {fs_free /} $ {color2} / $ {color1} $ {fs_used /} $ color / $ {color2} $ {fs_size /} $ krāsa
$ {color1} Sākums: $ 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} $ krāsa
$ {color1} No: $ color Buenosairesa, Argentīna
$ {color1} Platums: $ {color2} 34 ° 35'S $ {color1} Garš: $ {color2} 58 ° 21'W $ {color1} Alt: $ {color2} 25 m $ krāsa
$ {voffset 5} $ {color2} $ {font calibri: size = 12} šodien: $ font $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = CC} $ krāsa $ {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} $ fonts
$ {alignc 20} $ {voffset -30} $ {font Arrows: size = 20} $ {color4} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = BF} $ color $ fonts
$ {alignc 10} $ {voffset 5} $ {color4} Vējš: $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = WS} $ color
$ {color1} Mitrums: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = HM} $ {alignr 2} $ {color1} Nokrišņi: $ {color3} $ { execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = PC} $ color
$ {alignc} $ {color1} Spiediens: $ {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} $ krāsa
$ {color1} Saullēkts: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = SR} $ {alignr 2} $ {color1} Saulriets: $ {color3} $ { execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = SS} $ krāsa
$ {voffset 15} $ {color1} Mēness: $ {color4} $ {alignr 2} $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = MP} $ color
fons $ krāsa
$ {color0} $ {hr} $ krāsa
$ {voffset 5} $ {color2} IP: $ {alignc} $ color $ {addr eth0}
$ {color1} uz leju: $ color $ {downspeed eth0} k / s $ {alignr 2} $ {color1} augšup: $ color $ {{uppeed eth0} k / s
$ {color1} Kopā: $ color $ {totaldown eth0} $ {alignr 2} $ {color1} Kopā: $ color $ {totalup eth0}
$ {color1} Ienākošais: $ color $ {tcp_portmon 1 32767 count} $ {color1} Izejošais: $ color $ {tcp_portmon 32768 61000 count} $ {alignr 2} $ {color1} Kopā: $ color $ {tcp_portmon 1 65535 count}
$ {voffset 5} $ {color2} Savienojumi: $ color $ {tcp_portmon 32768 61000 count} $ {alignr 2} $ {color2} Pakalpojums / ports $ 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

mēs izveidojam failu ~ / Conky / conkyforecast

gedit ~ / Conky / conkyforecast

un mēs ielīmējam iekšā sekojošo

fona nr
own_window jā
own_wowow_transparent jā
own_window_hints nedekorēts, zemāk, lipīgs, skip_taskbar, skip_pager
savs_logu_krāsa melna
double_buffer jā
use_spacer pa kreisi
use_xft jā
fonta kalibri: size = 8
xftfont calibri: izmērs = 8
xftalpha 0.5
update_interval 5.0
lielie burti nē # iestatīts uz jā, ja vēlaties, lai viss teksts būtu ar lielajiem burtiem
stipled_borders 3
robežas_zīme 9
robežas_platums 10
noklusējuma_krāsa balta
noklusējuma_kontūras_krāsa melna
noklusējuma_ēnas_krāsa melna
krāsa0 ciāna
color1 gaiši zils
krāsa2 oranža
krāsa3 dzeltena
krāsa4 kvieši
krāsa5 balta
krāsa6 balta
krāsa7 balta
krāsa8 balta
krāsa9 balta
izlīdzināšana bottom_left # vai top_left, bottom_left, bottom_right
sprauga_x 10
sprauga_y 35
text_buffer_size 1024 # prognozei izmantojiet 1024
no_buffers yes # Vai atņemt failu sistēmas buferus no izmantotās atmiņas?
vilkt_malas nr
draw_outline yes # pastiprina tekstu, ja jā
draw_shades jā # shadecolor melns

TEKSTS
$ {color4} $ {font calibri: size = 11} Paplašinātā prognoze $ font $ color
$ {color0} $ {hr} $ krāsa
$ {color4} $ {font calibri: size = 9} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –template = / home / user / Conky / scripts / myweather.template} $ font $ krāsa

mēs izveidojam failu ~ / Conky / conkymail

gedit ~ / Conky / conkymail

failā ielīmējam sekojošo

fona nr
own_window jā
own_wowow_transparent jā
own_window_hints nedekorēts, zemāk, lipīgs, skip_taskbar, skip_pager
savs_logu_krāsa melna
double_buffer jā
use_spacer pa kreisi
use_xft jā
fonta kalibri: size = 8
xftfont calibri: izmērs = 8
xftalpha 0.5
update_interval 5.0
lielie burti nē # iestatīts uz jā, ja vēlaties, lai viss teksts būtu ar lielajiem burtiem
stipled_borders 3
robežas_zīme 9
robežas_platums 10
noklusējuma_krāsa balta
noklusējuma_kontūras_krāsa melna
noklusējuma_ēnas_krāsa melna
krāsa0 ciāna
color1 gaiši zils
krāsa2 oranža
krāsa3 dzeltena
krāsa4 kvieši
krāsa5 balta
krāsa6 balta
krāsa7 balta
krāsa8 balta
krāsa9 balta
izlīdzināšana bottom_left # vai top_left, bottom_left, bottom_right
sprauga_x 565
sprauga_y 35
text_buffer_size 128 # prognozei izmantojiet 1024
no_buffers yes # Vai atņemt failu sistēmas buferus no izmantotās atmiņas?
vilkt_malas nr
draw_outline yes # pastiprina tekstu, ja jā
draw_shades jā # shadecolor melns

TEKSTS
$ {font calibri: size = 11} $ {alignc} $ {color4} Gmail
$ {color0} $ {hr} $ krāsa
$ {font calibri: size = 11} $ {color4} Mums ir $ {color3} $ {execi 300 python ~ / Conky / scripts / mail / conkyEmail.py} $ {color4} e-pasts (s) $ fonts

Mēs izveidojam failu mapē ~ / Conky / scripts / conkyForecast.py (jāizveido skriptu mape)

gedit ~ / Conky / scripts / conkyForecast.py

#! / usr / bin / python
# - * - kodēšana: utf-8 - * -
######################################################### ################################
# conkyForecast.py ir (ne tik) vienkāršs (vairs) pitona skripts, kuru var apkopot
# informācija par pašreizējiem laikapstākļiem lietošanai Conky.
#
# Autors: Kaivalagi
# Izveidots: 13
# Modifikācijas:
# 14/04/2008 Atļaut prognožu datiem dienu diapazonus
# 14/04/2008 Pārbaudiet savienojamību ar xoap pakalpojumu
# 18/04/2008 Atļaut iestatīt atstarpes izvades atstarpes
# 18/04/2008 Atļaut nakts un dienas prognozes
# 18/04/2008 Atbalsta nosacījuma koda teksta “CC” lokalizāciju, kas gaida spāņu valodas tulkošanu
# 18/04/2008 Klases datiem izmantojiet kodināšanu, nevis atveriet xml, tādējādi apejot nepieciešamību nopratināt kešatmiņā saglabātos datus
# 19/04/2008 Pievienots spāņu valodas teksts - paldies Brūsam M
# 19/04/2008 Pievienota ciparu izejas ciparu pārbaude ar vienību sufiksu
# 19/04/2008 Mainīts marinādes faila nosaukums, iekļaujot tajā atrašanās vietas kodu
# 19/04/2008 Pievienota spāņu nedēļas dienu konvertēšana, izmantojot lokalizāciju
# 20/04/2008 Pievienots pienācīgs komandu argumentu parsētājs
# 20/04/2008 Pievienots - īsnedēļas diena, ja nedēļas dienā datu tips tiek saīsināts līdz 3 rakstzīmēm
# 21/04/2008 Fiksētas lokalizācijas opcijas prognozes izvadei
# 21/04/2008 Pievienota opcija -template, lai atļautu pielāgotu izvadi, izmantojot vienu exec zvanu 🙂
# 21/04/2008 Pievienota opcija Hideunits, lai no izvades noņemtu, piemēram, mph un C
# 23/04/2008 No veidnes ir noņemta opcija Opperial, tā OBLIGĀTI jāiestata kā standarta opcija skripta izsaukumā un netiek izmantota veidnes failā.
# 23/04/2008 Izlasīta - veidnes opcija, kas ļauj metriskām vai imperatīvām vērtībām katram datu tipam. Ņemiet vērā, ka, izmantojot veidnes, komandrindas opcija nedarbosies.
# 23/04/2008 Pievienota izeja, kas paziņo lietotājam, ja norādītā atrašanās vieta ir slikta
# 24/04/2008 Pievienota apstrāde bez savienojuma, tagad tiks atgriezti kešatmiņā saglabātie dati (kļūda, ja kešatmiņa nepastāv). Pārbaudes, mēģinot atvērt vietni xoap.weather.com
# 24/04/2008 Fiksēts Celsija un Fārenheita konversija
# 06/05/2008 Atjaunināts URL, kas izmantots pēc tīmekļa pakalpojuma atjaunināšanas
# 09/05/2008 Konsolidētais pašreizējais stāvoklis un prognozes dati tiek ielādēti vienā zvanā
# 09/05/2008 Datatipiem pievienots saullēkts un saulriets, tie ir raksturīgi gan pašreizējiem apstākļiem, gan prognozes datiem
# 09/05/2008 Datatipiem pievienota mēness fāze, barometra rādījums un barometra apraksts, tie ir raksturīgi tikai pašreizējiem apstākļiem, tāpat kā prognozējamajai izejai nav
# 09/05/2008 Pievienoti barometra mērvienību pārrēķini no MB uz collām (Imperial)
# 09/05/2008 Atjaunināts spāņu valodas teksts - paldies Brūsam M
# 10/05/2008 Pievienoti franču valodas dati - paldies benpaka
# 12/05/2008 Pievienots jauns BF (nesoša fonta) datu tips, lai nodrošinātu bultiņas rakstzīmi (izmantojiet ar fontu Arrow.ttf), nevis NSEW izvades no WD (vēja virziens)
# 12/05/2008 Atjaunināta WD izvade, lai tā būtu lokālai raksturīga, pašlaik atbalsta noklusējuma angļu un spāņu valodu - paldies Brūsam M
# 18/05/2008 Pievienots jauns MF (mēness fonta) datu tips, lai nodrošinātu mēness fonta rakstzīmi (rakstzīmes ir nepareizas un vēl nav veltīta fonta).
# 21/05/2008 Pašreizējiem apstākļiem opcija –datatype = LT tagad parāda temperatūru “justies kā”, nevis pašreizējo temperatūru
#
# VISS:
# Konsolidējiet pkl failus vienā failā / klasē
# Pievienojiet laika apstākļu fontu, pamatojoties uz mēness fāzes izvadi, pamatojoties uz mēness ikonas datiem
# ??? Vai tur vēl kādas prasības?

importēt sys, os, socket, urllib2, datetime, time
no xml.dom importēt minidomu
no stat importa *
no optparse importēšanas OptionParser
importēt lokalizāciju
importēt gettext
importēt marinētu gurķi
no matemātikas importa *

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

klase CommandLineParser:

parsētājs = Nav

def __init __ (pats):

self.parser = OptionParser ()
self.parser.add_option («- l», »- atrašanās vieta», dest = »atrašanās vieta», noklusējums = »UKXX0103 ″, type =» string », metavar =» CODE », help = u» atrašanās vietas kods laika datiem [ noklusējums:% default], izmantojiet šo vietrādi URL, lai noteiktu pilsētas atrašanās vietas kodu pēc pilsētas nosaukuma: http://xoap.weather.com/search/search?where=Norwich »)
self.parser.add_option ("- d", "- datu tips", dest = "datu tips", noklusējums = "HT", tips = "virkne", metavar = "DATATYPE", help = u "[noklusējums:% default] Datu veida opcijas ir: DW (nedēļas diena), WF (laika fontu izeja), LT (prognoze: zema temperatūra, pašreizējā: jūtama kā temperatūra), HT (prognoze: augsta temperatūra, pašreizējā: pašreizējā temperatūra), CC (pašreizējā CT (apstākļu teksts), PC (nokrišņu iespēja), HM (mitrums), WD (vēja virziens), WS (vēja ātrums), WG (vēja brāzmas), CN (pilsētas nosaukums), SR (saullēkts), SS (saulriets), MP (mēness fāze), MF (mēness fonts), BR (barometra rādījums), BD (barometra apraksts). Lietojot veidnes, komandrindā nav piemērojams. »)
self.parser.add_option («- s», »- startday», dest = »startday», type = »int», metavar = »NUMBER», help = u »definē sākuma dienas numuru, ja tiek izlaisti izlaisti pašreizējie apstākļi Lietojot veidnes, komandrindā nav piemērojams. »)
self.parser.add_option ("- e", "- endday", dest = "endday", type = "int", metavar = "NUMBER", help = u "definē beigu dienas numuru, ja izlaiž tikai sākuma dienas datus ir izvade. Lietojot veidnes, komandrindā nav piemērojams. »)
self.parser.add_option («- S», »- atstarpes», dest = »atstarpes», type = »int», noklusējums = 1, metavar = »NUMBER», help = u »[noklusējums:% default] Definē atstarpju skaits starp diapazona izvade. Lietojot veidnes, komandrindā nav.
self.parser.add_option («- t», »- veidne», dest = »veidne», type = »virkne», metavar = »FILE», help = u »definē veidnes failu, lai ģenerētu izvadi vienā zvanā. A failā redzamais vienums ir formā {–datatype = HT –startday = 1}. Katrā vienumā ir iespējamas šādas iespējas: –datatype, –startday, –endday, –night, –ortweekday, –perperial, –hideunits, –Spaces. Ņemiet vērā, ka opciju īsās formas pašlaik netiek atbalstītas! Izmantojot veidnes, neviena no šīm opcijām nav piemērojama komandrindā.
self.parser.add_option («- L», »- locale», dest = »locale», type = »string», help = u »ignorē sistēmas lokalizāciju valodas izvadei (lv = angļu, es = spāņu, fr = franču valoda, vēl būs priekšā) »)
self.parser.add_option ("- i", "- imperial", dest = "imperial", default = False, action = "store_true", help = u "pieprasīt impērijas vienības, ja izlaista izeja ir metriskā. Nav piemērojams komandrinda, lietojot veidnes. »)
self.parser.add_option («- n», »- nakts», dest = »nakts», noklusējums = False, action = »store_true», help = u »pārslēgt izvadi uz nakts datiem, ja tiks izlaista dienas izeja. Lietojot veidnes, komandrindā nav piemērojams. »)
self.parser.add_option («- w», »- shortweekday», dest = »shortweekday», default = False, action = »store_true», help = u »Saīsiniet nedēļas dienas datu tipu līdz 3 rakstzīmēm. Nav piemērojams plkst. komandrinda, lietojot veidnes. »)
self.parser.add_option («- u», »- slēpošanas vienības», dest = »slēptās vienības», noklusējums = False, action = »veikala_tiesība», help = u »Slēpt tādas vienības kā mph vai C, grādu simboli (°) ir joprojām tiek rādīts. Lietojot veidnes, komandrindā nav piemērojams. »)
self.parser.add_option («- v», »- verbose», dest = »verbose», default = False, action = »store_true», help = u »pieprasīt verbose output, nav laba ideja, skrienot caur conky!)
self.parser.add_option ("- r", "- atjaunot", dest = "atjaunot", noklusējums = False, action = "store_true", help = u "ielādēt datus neatkarīgi no datu termiņa beigām")

def parse_args (pats):
(opcijas, argumenti) = self.parser.parse_args ()
atdeve (opcijas, argumenti)

def print_help (pats):
atgriezties self.parser.print_help ()

klase WeatherData:
def __init __ (sevis, nedēļas_nedēļas, zems, augsts, stāvokļa_kods, nosacījuma_teksts, nokrišņi, mitrums, vēja_direktors, vēja ātrums, vēja_gari, pilsēta, saullēkts, saulriets, mēness_fāze, mēness_ikonu, bar_read, bar_desc):
self.day_of_week = u »» + day_of_week
self.low = u »» + zems
sevis.augsts = u »» + augsts
self.condition_code = u »» + condition_code
self.condition_text = u »» + condition_text
self.precip = u »» + nokrišņi
sevis mitrums = u »» + mitrums
self.wind_dir = u »» + wind_dir
self.wind_speed = u »» + wind_speed
self.wind_gusts = u »» + wind_gusts
self.city = u »» + pilsēta
sevis.saullēkts = u »» + saullēkts
self.sunset = u »» + saulriets
self.moon_phase = u »» + mēness_fāze
self.moon_icon = u »» + moon_icon
self.bar_read = u »» + bar_read
self.bar_desc = u »» + bar_desc

klase WeatherText:

nosacījumu_teksts = {
«0»: _ (u »Tornado»),
«1»: _ (u »tropiskā vētra»),
«2»: _ (u »viesuļvētra»),
«3»: _ (u »Spēcīgi pērkona negaisi»),
«4»: _ (u »Pērkona negaiss»),
«5»: _ (u »Jaukts lietus un sniegs»),
«6»: _ (u »Jaukts lietus un flote»),
«7»: _ (u »Jaukti nokrišņi»),
«8»: _ (u »Saldējošs lietus»),
«9»: _ (u »Drizzle»),
«10»: _ (u »sasalstošs lietus»),
«11»: _ (u »Dušas»),
«12»: _ (u »Dušas»),
«13»: _ (u »Sniega putekļi»),
«14»: _ (u »Neliela sniega lietus»),
«15»: _ (u »Pūtošs sniegs»),
«16»: _ (u »Sniegs»),
«17»: _ (u »Sveika»),
«18»: _ (u »Sleet»),
«19»: _ (u »Putekļi»),
«20»: _ (u »Migla»),
«21»: _ (u »dūmaka»),
«22»: _ (u »Dūmi»),
«23»: _ (u »Blustery»),
«24»: _ (u »Vējains»),
«25»: _ (u »Auksts»),
«26»: _ (u »Mākoņains»),
«27»: _ (u »Pārsvarā mākoņains»),
«28»: _ (u »Pārsvarā mākoņains»),
«29»: _ (u »Daļēji mākoņains»),
«30»: _ (u »Daļēji mākoņains»),
«31»: _ (u »Notīrīt»),
«32»: _ (u »Notīrīt»),
«33»: _ (u »Gadatirgus»),
«34»: _ (u »Gadatirgus»),
«35»: _ (u »Jaukts lietus un krusa»),
«36»: _ (u »Karsts»),
«37»: _ (u »Atsevišķi pērkona negaisi»),
«38»: _ (u »Izkaisīti pērkona negaisi»),
«39»: _ (u »Izkaisīti pērkona negaisi»),
«40»: _ (u »Izkliedētas lietusgāzes»),
«41»: _ (u »Stiprs sniegs»),
«42»: _ (u »Izkliedētas sniega lietus»),
«43»: _ (u »Stiprs sniegs»),
«44»: _ (u »Daļēji mākoņains»),
«45»: _ (u »Pērkona lietusgāzes»),
«46»: _ (u »Sniega lietus»),
«47»: _ (u »Atsevišķi pērkona negaisi»),
«Na»: _ (u »N / A»),
"-": _ (a ")
}

nosacījumu_teksts_es = {
«0»: _ (u »Tornado»),
«1»: _ (u »tropiskā vētra»),
«2»: _ (u »Huracá¡n»),
«3»: _ (u »Spēcīgas vētras»),
«4»: _ (u »Vētras»),
«5»: _ (u »Jaukts lietus un sniegs»),
«6»: _ (u »Jaukts lietus un flote»),
«7»: _ (u »Sleet»),
«8»: _ (u »Saldējošs lietus»),
«9»: _ (u »Drizzle»),
«10»: _ (u »Saldējošs lietus»), # vai sasalstošs lietus
«11»: _ (u »Dušas»),
«12»: _ (u »Dušas»),
«13»: _ (u »Neliels sniegs»),
«14»: _ (u »Neliels sniegs»),
«15»: _ (u »Sniega putenis»),
«16»: _ (u »Sniegs»),
«17»: _ (u »Sveika»),
«18»: _ (u »Sleet»),
«19»: _ (u »pulveris»),
«20»: _ (u »Migla»),
«21»: _ (u »dūmaka»),
«22»: _ (u »Dūmi»),
«23»: _ (u »Tempest»),
«24»: _ (u »Vējains»),
«25»: _ (u »Fráo»),
«26»: _ (u »Ļoti mākoņains»),
«27»: _ (u »Pārsvarā mākoņains»),
«28»: _ (u »Pārsvarā mākoņains»),
«29»: _ (u »Daļēji mākoņains»),
«30»: _ (u »Daļēji mākoņains»),
«31»: _ (u »Notīrīt»),
«32»: _ (u »Notīrīt»),
«33»: _ (u »Apmācies»),
«34»: _ (u »Apmācies»),
«35»: _ (u »Lietus ar krusu»),
«36»: _ (u »Siltums»),
«37»: _ (u »Izolētas vētras»),
«38»: _ (u »Izkliedētas vētras»),
«39»: _ (u »Izkliedētas vētras»),
«40»: _ (u »Izkliedētas lietusgāzes»),
«41»: _ (u »Stiprs sniegs»),
«42»: _ (u »Vāji un izkliedēti sniegputeņi»),
«43»: _ (u »Intensīvā Nevada»),
«44»: _ (u »Izkliedēti mākoņi»),
«45»: _ (u »Vētras»),
«46»: _ (u »Izkaisīti sniegputeni»),
«47»: _ (u »Izolētas vētras»),
«Na»: _ (u »N / A»),
"-": _ (a ")
}

nosacījumu_teksts_fr = {
«0»: _ (u »Tornade»),
«1»: _ (u »Tempête Tropicale»),
«2»: _ (vai »Ouragan»),
«3»: _ (vai »Vada vardarbības»),
«4»: _ (vai »Orageux»),
«5»: _ (u »Pluie et Neige»),
«6»: _ (u »Pluie et Neige Mouillée»),
«7»: _ (u »Mainīgs vidējais rādītājs»),
«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»: _ (vai »Orages Isolés»),
«38»: _ (vai »Orages Localisés»),
«39»: _ (vai »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»: _ (vai »Orages»),
«46»: _ (u »Tempête de Neige»),
«47»: _ (vai »Orages Isolés»),
«Na»: _ (u »N / A»),
"-": _ (a ")
}

nosacījumi_laiks_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 »»),
"-": _ (vai "")
}

nosacījumi_mēness_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 »»),
"-": _ (vai "")
}

nedēļas_diena = {
"Šodien": _ (vai "Šodien"),
«Pirmdiena»: _ (u »Pirmdiena),
«Otrdiena»: _ (u »otrdiena),
«Trešdiena»: _ (u »trešdiena),
«Ceturtdiena»: _ (u »ceturtdiena»),
"Piektdiena": _ (u "piektdiena"),
"Sestdiena": _ (u "Sestdiena"),
"Svētdiena": _ (u "svētdiena")
}

dienas_nedēļas_saīsinājums = {
"Šodien": _ (u "Tagad"),
«Pirmdiena»: _ (u »pirmdiena),
«Otrdiena»: _ (u »otrdiena),
«Trešdiena»: _ (u »trešdiena),
«Ceturtdiena»: _ (u »ceturtdiena),
«Piektdiena»: _ (u »piektdiena),
"Sestdiena": _ (u "Sestdiena"),
"Svētdiena": _ (u "Saule")
}

nedēļas_nedēļas_diena = {
"Šodien": _ (u "šodien"),
«Pirmdiena»: _ (u »Pirmdiena),
«Otrdiena»: _ (u »otrdiena),
«Trešdiena»: _ (u »trešdiena),
«Ceturtdiena»: _ (u »ceturtdiena»),
«Piektdiena»: _ (u »piektdiena»),
"Sestdiena": _ (u "Sestdiena"),
"Svētdiena": _ (u "svētdiena")
}

dienas_nedēļas_sort_es = {
"Šodien": _ (u "šodien"),
"Pirmdiena": _ (u "pirmdiena"),
«Otrdiena»: _ (u »jūra»),
«Trešdiena»: _ (u »wed»),
«Ceturtdiena»: _ (u »ceturtdiena),
«Piektdiena»: _ (u »fri»),
"Sestdiena": _ (u "sēdēja"),
"Svētdiena": _ (u "dom")
}

dienas_nedēļas_fr = {
«Šodien»: _ (u »Aujourd'hui»),
«Pirmdiena»: _ (u »Lundi»),
«Otrdiena»: _ (u »Mardi»),
«Trešdiena»: _ (u »Mercredi»),
«Ceturtdiena»: _ (u »Jeudi»),
«Piektdiena»: _ (u »Vendredi»),
"Sestdiena": _ (u "Samedi"),
"Svētdiena": _ (u "Dimanche")
}

day_of_week_short_fr = {
«Šodien»: _ (u »Auj»),
"Pirmdiena": _ (u "Pirmdiena"),
«Otrdiena»: _ (u »Mar»),
"Trešdiena": _ (u "Mer"),
«Ceturtdiena»: _ (u »Jeu»),
«Piektdiena»: _ (u »Nāc»),
"Sestdiena": _ (u "Sems"),
"Svētdiena": _ (u "Dim")
}

gultnis_arrow_font = {
«N»: _ (u »i»),
«NNE»: _ (u »j»),
«ZA»: _ (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»),
"RZR": _ (u "f"),
«ZR»: _ (u »g»),
«ZRR»: _ (u »h»),
«N / A»: _ (u »«)
}

gultņu_teksta_es = {
«N»: _ (u »N»),
«NNE»: _ (u »NNE»),
«NE»: _ (u »NE»),
«ENE»: _ (u »ENE»),
«E»: _ (u »E»),
«ESE»: _ (u »ESE»),
«SE»: _ (u »DA»),
"SSE": _ (u "SSE"),
"Viņu"),
"SSW": _ (u "SSO"),
«SW»: _ (u »SO»),
"WSW": _ (u "WOW"),
«W»: _ (u »O»),
«RZR»: _ (u »ONO»),
«ZR»: _ (u »NĒ»),
«NNW»: _ (u »NNO»),
«N / A»: _ (u »N \ A»)
}

gultņu_teksta_fr = {
«N»: _ (u »N»),
«NNE»: _ (u »NNE»),
«NE»: _ (u »NE»),
«ENE»: _ (u »ENE»),
«E»: _ (u »E»),
«ESE»: _ (u »ESE»),
«SE»: _ (u »DA»),
"SSE": _ (u "SSE"),
"Viņu"),
"SSW": _ (u "SSO"),
«SW»: _ (u »SO»),
"WSW": _ (u "WOW"),
«W»: _ (u »O»),
«RZR»: _ (u »ONO»),
«ZR»: _ (u »NĒ»),
«NNW»: _ (u »NNO»),
«N / A»: _ (u »N \ A»)
}

klase GlobalWeather:

pašreizējie_nosacījumi = []
dienas_prognoze = []
nakts_prognoze = []

locale = "iekš"

opcijas = Nav
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 __ (pats, opcijas):

self.options = opcijas

ja self.options.locale == Nav:
mēģiniet:
# self.locale = locale.getdefaultlocale () [0] [0: 2]
self.locale = «es» # atcelt šo līniju, lai piespiestu Spānijas lokalizāciju
# self.locale = "fr" # atcelt šo rindiņu, lai piespiestu franču valodu
izņemot:
drukāt "lokalizācija nav iestatīta"
cits:
# self.locale = self.options.locale
self.locale = «es» # atcelt šo līniju, lai piespiestu Spānijas lokalizāciju
# self.locale = "fr" # atcelt šo rindiņu, lai piespiestu franču valodu

ja self.options.verbose == True:
drukāt >> sys.stdout, "lokalizācija iestatīta uz", self.locale

def getText (pats, mezgls):
rc = ""
mezglam mezglu sarakstā:
ja node.nodeType == mezgls.TEXT_NODE:
rc = rc + mezgls.dati
atgriešanās rc

def getSpaces (sevis, atstarpes):
string = u »»
ja atstarpes == Nav:
virkne = self.DEFAULT_SPACING
cits:
i diapazonā (0, atstarpes + 1):
virkne = virkne + u »«
atgriešanās virkne

def isNumeric (pats, virkne):
mēģiniet:
manekens = pludiņš (virkne)
atgriešanās True
izņemot:
atgriezties Nepatiesa

def isConnectionAvailable (pats):
# pārliecinieties, ka mēs varam piekļūt weather.com serverim, atverot vietrādi URL
mēģiniet:
Usock = urllib2.urlopen ('http://xoap.weather.com')
Usock.close ()
atgriešanās True
izņemot:
atgriezties Nepatiesa

def getBearingText (pats, gultnis):
gultnis = pludiņš (gultnis)
ja gultnis ir <11.25:
atgriezties u »N»
elif gultnis <33.75:
atgriezties u »NNE»
elif gultnis <56.25:
atgriezties u »ZA»
elif gultnis <78.75:
atgriezties u »JAN»
elif gultnis <101.25:
atgriezties u »E»
elif gultnis <123.75:
atgriezties u »ESE»
elif gultnis <146.25:
atgriezties u »SE»
elif gultnis <168.75:
atgriezties u »SSE»
elif gultnis <191.25:
atgriezties u »S»
elif gultnis <213.75:
atgriezties u »SSW»
elif gultnis <236.25:
atgriezties u »SW»
elif gultnis <258.75:
atgriezties u »WSW»
elif gultnis <281.25:
atgriezties u »W»
elif gultnis <303.75:
atgriešanās u »RNR»
elif gultnis <326.25:
atgriešanās u »ZR»
elif gultnis <348.75:
atgriešanās u »ZRR»
cits:
atgriešanās «N / A»

def convertCelsiusToFahrenheit (pats, temp):
atgriešanās str (int (grīda (((pludiņš (temp) * 9.0) /5.0) +32)))

def convertKilometresToMiles (self, dist):
atgriešanās str (int (grīda (pludiņš (dist) * 0.621371192)))

def convertMillibarsToInches (self, mb):
atgriešanās str (int (grīda (pludiņš (mb) / 33.8582)))

def getTemplateList (pats, veidne):

veidņu saraksts = []

par template_part veidnē template.split («{«):
ja template_part! = «»:
par template_part vietnē template_part.split ("}"):
ja template_part! = «»:
templatelist.append (u »» + template_part)

atgriezties templatelist

def getOutputText (sevis, datu tips, sākuma diena, beigu diena, nakts, īsa nedēļas diena, imperators, slēptuves, atstarpes)
# mēģinājums:
izeja = u »»

# definēt izejas pašreizējās vienības
ja slēptāji == Nepatiesa:
ja imperators == Nepatiesa:
tempunit = u »° C»
speedunit = u »km / h»
spiediena vienība = u »mb»
cits:
tempunit = u »° F»
ātruma vienība = u »mph»
spiediena vienība = u »iekšā»
cits:
tempunit = u »°»
speedunit = u »»
spiediena vienība = u »»

ja sākuma diena == Nav: # pašreizējie apstākļi

ja datu tips == "DW":
ja self.locale == "ir":
ja īsu nedēļu == True:
izeja = WeatherText.day_of_week_short_es [self.current_conditions [0] .day_of_week]
cits:
izeja = WeatherText.day_of_week_es [self.current_conditions [0] .day_of_week]
elif self.locale == "fr":
ja īsu nedēļu == True:
izeja = WeatherText.day_of_week_short_fr [self.current_conditions [0] .day_of_week]
cits:
izeja = WeatherText.day_of_week_fr [self.current_conditions [0] .day_of_week]
cits:
ja īsu nedēļu == True:
izeja = WeatherText.day_of_week_short [self.current_conditions [0] .day_of_week]
cits:
izeja = WeatherText.day_of_week [self.current_conditions [0] .day_of_week]
elif datatips == "WF": # laika fonts
izeja = WeatherText.conditions_weather_font [self.current_conditions [0] .condition_code]
elif datu tips == "LT":
virkne = self.current_conditions [0] .low
ja self.isNumeric (virkne) == True:
ja imperators == True:
string = self.convertCelsiusToFahrenheit (virkne)
virkne = virkne + tempunits
izeja = virkne
elif datu tips == "HT":
virkne = self.current_conditions [0] .augsts
ja self.isNumeric (virkne) == True:
ja imperators == True:
string = self.convertCelsiusToFahrenheit (virkne)
virkne = virkne + tempunits
izeja = virkne
elif datu tips == "CC":
ja self.locale == "ir":
izeja = WeatherText.conditions_text_es [self.current_conditions [0] .condition_code]
elif self.locale == "fr":
izeja = WeatherText.conditions_text_fr [self.current_conditions [0] .condition_code]
cits:
izeja = WeatherText.conditions_text [self.current_conditions [0] .condition_code]
elif datu tips == "CT":
izeja = self.current_conditions [0] .condition_text
elif datu tips == "PC":
string = self.current_conditions [0] .precip
ja self.isNumeric (virkne) == True:
string = virkne + u »%»
izeja = virkne
elif datu tips == "HM":
string = self.current_conditions [0]. mitrums
ja self.isNumeric (virkne) == True:
string = virkne + u »%»
izeja = virkne
elif datu tips == "WD":
virkne = self.current_conditions [0] .wind_dir
ja self.isNumeric (virkne) == True:
string = self.getBearingText (virkne)

ja self.locale == "ir":
izvade = WeatherText.bearing_text_es [virkne]
elif self.locale == "fr":
izeja = WeatherText.bearing_text_fr [virkne]
cits:
izeja = virkne

elif datu tips == "BF":
virkne = self.current_conditions [0] .wind_dir
ja self.isNumeric (virkne) == True:
string = WeatherText.bearing_arrow_font [self.getBearingText (virkne)]
izeja = virkne
elif datu tips == "WS":
virkne = self.current_conditions [0] .wind_speed
ja self.isNumeric (virkne) == True:
ja imperators == True:
string = self.convertKilometresToMiles (virkne)
virkne = virkne + ātruma vienība
izeja = virkne
elif datu tips == "WG":
string = self.current_conditions [0] .vēja_gari
ja self.isNumeric (virkne) == True:
ja imperators == True:
string = self.convertKilometresToMiles (virkne)
virkne = virkne + ātruma vienība
izeja = virkne
elif datu tips == "CN":
izlaide = pašapstrāvas_nosacījumi [0] .pilsēta
elif datu tips == "SR":
izeja = self.current_conditions [0] .saullēkts
elif datu tips == "SS":
izeja = self.current_conditions [0]. saulriets
elif datu tips == "MP":
izeja = self.current_conditions [0] .mēness_fāze
elif datu tips == "MF":
izeja = WeatherText.conditions_moon_font [self.current_conditions [0] .moon_icon]
elif datu tips == "BR":
string = self.current_conditions [0] .bar_read
ja self.isNumeric (virkne) == True:
ja imperators == True:
string = self.convertMillibarsToInches (virkne)
virkne = virkne + spiediena vienība
izeja = virkne
elif datu tips == "BD":
izeja = self.current_conditions [0] .bar_desc
cits:
output = "\ nKĻŪDA: pieprasīts nezināms datu tips"

cits: # prognozes dati

if endday == Nav: # ja nav iestatīta beigu diena, izmantojiet sākuma dienu
beigu diena = sākuma diena

ja nakts == Patiesi: nepieciešama # nakts prognoze

dienas_skaitlim diapazonā (sākuma diena, beigu diena + 1):

ja datu tips == "DW":
ja self.locale == "ir":
ja īsu nedēļu == True:
output = output + self.getSpaces (atstarpes) + WeatherText.day_of_week_short_es [self.night_forecast [day_number] .day_of_week]
cits:
output = output + self.getSpaces (atstarpes) + WeatherText.day_of_week_es [self.night_forecast [day_number] .day_of_week]
elif self.locale == "fr":
ja īsu nedēļu == True:
output = output + self.getSpaces (atstarpes) + WeatherText.day_of_week_short_fr [self.night_forecast [day_number] .day_of_week]
cits:
output = output + self.getSpaces (atstarpes) + WeatherText.day_of_week_fr [self.night_forecast [day_number] .day_of_week]
cits:
ja īsu nedēļu == True:
output = output + self.getSpaces (atstarpes) + WeatherText.day_of_week_short [self.night_forecast [day_number] .day_of_week]
cits:
izeja = izeja + self.getSpaces (atstarpes) + WeatherText.day_of_week [self.night_forecast [day_number] .day_of_week]
elif datatips == "WF": # laika fonts
output = output + self.getSpaces (atstarpes) + WeatherText.conditions_weather_font [self.night_forecast [day_number] .condition_code]
elif datu tips == "LT":
virkne = self.night_forecast [dienas_skaitlis] .low
ja self.isNumeric (virkne) == True:
ja imperators == True:
string = self.convertCelsiusToFahrenheit (virkne)
virkne = virkne + tempunits
izeja = izeja + self.getSpaces (atstarpes) + virkne

elif datu tips == "HT":
virkne = self.night_forecast [dienas_skaitlis] .augsts
ja self.isNumeric (virkne) == True:
ja imperators == True:
string = self.convertCelsiusToFahrenheit (virkne)
virkne = virkne + tempunits
izeja = izeja + self.getSpaces (atstarpes) + virkne
elif datu tips == "CC":
ja self.locale == "ir":
izeja = izeja + self.getSpaces (atstarpes) + WeatherText.conditions_text_es [self.night_forecast [dienas_numurs] .condition_code]
elif self.locale == "fr":
izeja = izeja + self.getSpaces (atstarpes) + WeatherText.conditions_text_fr [self.night_forecast [dienas_numurs] .condition_code]
cits:
izeja = izeja + self.getSpaces (atstarpes) + WeatherText.conditions_text [self.night_forecast [dienas_numurs] .condition_code]
elif datu tips == "CT":
izeja = izeja + self.getSpaces (atstarpes) + self.night_forecast [dienas_numurs] .nosacījuma_teksts
elif datu tips == "PC":
string = self.night_forecast [day_number] .precip
ja self.isNumeric (virkne) == True:
string = virkne + u »%»
izeja = izeja + self.getSpaces (atstarpes) + virkne
elif datu tips == "HM":
string = self.night_forecast [day_number]. mitrums
ja self.isNumeric (virkne) == True:
string = virkne + u »%»
izeja = izeja + self.getSpaces (atstarpes) + virkne
elif datu tips == "WD":
virkne = self.night_forecast [dienas_skaitlis] .wind_dir
ja self.locale == "ir":
izeja = izeja + self.getSpaces (atstarpes) + WeatherText.bearing_text_es [virkne]
elif self.locale == "fr":
izeja = izeja + self.getSpaces (atstarpes) + WeatherText.bearing_text_fr [virkne]
cits:
izeja = izeja + self.getSpaces (atstarpes) + virkne

elif datu tips == "BF":
output = output + self.getSpaces (atstarpes) + WeatherText.bearing_arrow_font [self.night_forecast [day_number] .wind_dir]
elif datu tips == "WS":
string = self.night_forecast [day_number] .wind_speed
ja self.isNumeric (virkne) == True:
ja imperators == True:
string = self.convertKilometresToMiles (virkne)
virkne = virkne + ātruma vienība
izeja = izeja + self.getSpaces (atstarpes) + virkne
elif datu tips == "WG":
virkne = self.night_forecast [dienas_skaitlis] .vēja_gari
ja self.isNumeric (virkne) == True:
ja imperators == True:
string = self.convertKilometresToMiles (virkne)
virkne = virkne + ātruma vienība
izeja = izeja + self.getSpaces (atstarpes) + virkne
elif datu tips == "CN":
izeja = izeja + self.getSpaces (atstarpes) + self.night_forecast [dienas_skaitlis] .city
elif datu tips == "SR":
izeja = izeja + self.getSpaces (atstarpes) + self.night_forecast [dienas_skaitlis] .sunrise
elif datu tips == "SS":
izeja = izeja + self.getSpaces (atstarpes) + self.night_forecast [dienas_skaitlis] .sunset
elif datu tips == "MP":
izeja = izeja + self.getSpaces (atstarpes) + self.night_forecast [dienas_skaitlis] .mēness_fāze
elif datu tips == "MF":
output = output + self.getSpaces (atstarpes) + WeatherText.conditions_moon_font [self.night_forecast [day_number] .moon_icon]
elif datu tips == "BR":
output = output + self.getSpaces (atstarpes) + self.night_forecast [dienas_skaitlis] .bar_read
elif datu tips == "BD":
output = output + self.getSpaces (atstarpes) + self.night_forecast [dienas_skaitlis] .bar_desc
cits:
output = "\ nKĻŪDA: pieprasīts nezināms datu tips"
pārtraukums

cits: vēlama # dienas prognoze

dienas_skaitlim diapazonā (sākuma diena, beigu diena + 1):

ja datu tips == "DW":
ja self.locale == "ir":
ja īsu nedēļu == True:
output = output + self.getSpaces (atstarpes) + WeatherText.day_of_week_short_es [self.day_forecast [day_number] .day_of_week]
cits:
output = output + self.getSpaces (atstarpes) + WeatherText.day_of_week_es [self.day_forecast [day_number] .day_of_week]
elif self.locale == "fr":
ja īsu nedēļu == True:
output = output + self.getSpaces (atstarpes) + WeatherText.day_of_week_short_fr [self.day_forecast [day_number] .day_of_week]
cits:
output = output + self.getSpaces (atstarpes) + WeatherText.day_of_week_fr [self.day_forecast [day_number] .day_of_week]
cits:
ja īsu nedēļu == True:
izeja = izeja + self.getSpaces (atstarpes) + WeatherText.day_of_week_short [self.day_forecast [day_number] .day_of_week]
cits:
izeja = izeja + self.getSpaces (atstarpes) + WeatherText.day_of_week [self.day_forecast [day_number] .day_of_week]
elif datatips == "WF": # laika fonts
output = output + self.getSpaces (atstarpes) + WeatherText.conditions_weather_font [self.day_forecast [day_number] .condition_code]
elif datu tips == "LT":
string = self.day_forecast [dienas_skaitlis] .low
ja self.isNumeric (virkne) == True:
ja imperators == True:
string = self.convertCelsiusToFahrenheit (virkne)
virkne = virkne + tempunits
izeja = izeja + self.getSpaces (atstarpes) + virkne
elif datu tips == "HT":
virkne = self.day_forecast [dienas_skaitlis] .augsts
ja self.isNumeric (virkne) == True:
ja imperators == True:
string = self.convertCelsiusToFahrenheit (virkne)
virkne = virkne + tempunits
izeja = izeja + self.getSpaces (atstarpes) + virkne
elif datu tips == "CC":
ja self.locale == "ir":
output = output + self.getSpaces (atstarpes) + WeatherText.conditions_text_es [self.day_forecast [dienas_numurs] .condition_code]
elif self.locale == "fr":
output = output + self.getSpaces (atstarpes) + WeatherText.conditions_text_fr [self.day_forecast [dienas_numurs] .condition_code]
cits:
izeja = izeja + self.getSpaces (atstarpes) + WeatherText.conditions_text [self.day_forecast [dienas_numurs] .condition_code]
elif datu tips == "CT":
output = output + self.getSpaces (atstarpes) + self.day_forecast [dienas_numurs] .nosacījuma_teksts
elif datu tips == "PC":
string = self.day_forecast [day_number] .precip
ja self.isNumeric (virkne) == True:
string = virkne + u »%»
izeja = izeja + self.getSpaces (atstarpes) + virkne
elif datu tips == "HM":
string = self.day_forecast [day_number]. mitrums
ja self.isNumeric (virkne) == True:
string = virkne + u »%»
izeja = izeja + self.getSpaces (atstarpes) + virkne
elif datu tips == "WD":
string = self.day_forecast [day_number] .wind_dir

ja self.locale == "ir":
izeja = izeja + self.getSpaces (atstarpes) + WeatherText.bearing_text_es [virkne]
elif self.locale == "fr":
izeja = izeja + self.getSpaces (atstarpes) + WeatherText.bearing_text_fr [virkne]
cits:
izeja = izeja + self.getSpaces (atstarpes) + virkne

elif datu tips == "BF":
output = output + self.getSpaces (atstarpes) + WeatherText.bearing_arrow_font [self.day_forecast [day_number] .wind_dir]
elif datu tips == "WS":
string = self.day_forecast [day_number] .wind_speed
ja self.isNumeric (virkne) == True:
ja imperators == True:
string = self.convertKilometresToMiles (virkne)
virkne = virkne + ātruma vienība
izeja = izeja + self.getSpaces (atstarpes) + virkne
elif datu tips == "WG":
virkne = self.day_forecast [dienas_skaitlis] .vēja_gari
ja self.isNumeric (virkne) == True:
ja imperators == True:
string = self.convertKilometresToMiles (virkne)
virkne = virkne + ātruma vienība
izeja = izeja + self.getSpaces (atstarpes) + virkne
elif datu tips == "CN":
izeja = izeja + self.getSpaces (atstarpes) + self.day_forecast [dienas_skaitlis] .city
elif datu tips == "SR":
izeja = izeja + self.getSpaces (atstarpes) + self.day_forecast [dienas_skaitlis] .sunrise
elif datu tips == "SS":
izeja = izeja + self.getSpaces (atstarpes) + self.day_forecast [dienas_skaitlis] .sunset
elif datu tips == "MP":
izeja = izeja + self.getSpaces (atstarpes) + self.day_forecast [dienas_skaitlis] .mēness_fāze
elif datu tips == "MF":
izeja = izeja + self.getSpaces (atstarpes) + WeatherText.conditions_moon_font [self.day_forecast [day_number] .moon_icon]
elif datu tips == "BR":
output = output + self.getSpaces (atstarpes) + self.day_forecast [day_number]. bar_read
elif datu tips == "BD":
izeja = izeja + self.getSpaces (atstarpes) + self.day_forecast [dienas_numurs] .bar_desc
cits:
output = u »\ n KĻŪDA: pieprasīts nezināms datu tips»
pārtraukums

izeja = u »» + output.strip (u »«) # zaudē vadošās / pēdējās atstarpes
atgriešanās izeja

#izņemot:
#print "getOutputText: Negaidīta kļūda:", sys.exc_info () [0]

def getOutputTextFromTemplate (pats, veidne):
# mēģinājums:

# taustiņi veidņu datiem
DATATYPE_KEY = "–datatype ="
STARTDAY_KEY = "-startday ="
ENDDAY_KEY = "–diena ="
NIGHT_KEY = "–nakts"
SHORTWEEKDAY_KEY = "–šīsnedēļas diena"
IMPERIAL_KEY = "-perperial"
HIDEUNITS_KEY = "–slēpt vienības"
SPACES_KEY = "–spaces ="

izeja = u »»

atrasts variants = nepatiesa

# ielādējiet failu
mēģiniet:
fileinput = atvērts (self.options.template)
template = fileinput.read ()
fileinput.close ()
izņemot:
output = u »Veidnes fails nav atrasts!»

templatelist = self.getTemplateList (veidne)

# ļauj iziet veidņu sarakstu un noteikt katra atrastā vienuma izvadi
i diapazonā (0, len (templatelist) -1):

pos = templatelist [i] .find (DATATYPE_KEY)
ja poz! = -1:
atrasts variants = patiess
pos = pos + len (DATATYPE_KEY)
datu tips = templatelist [i] [pos: pos + 4] .strip («}»). sloksne («{«). sloksne («-«). sloksne (»«)
cits:
datu tips = nav

pos = templatelist [i] .find (STARTDAY_KEY)
ja poz! = -1:
atrasts variants = patiess
pos = pos + len (STARTDAY_KEY)
sākuma diena = int (templatelist [i] [pos: pos + 4] .strip ("}"). strip ("{"). strip ("-"). strip (""))
cits:
sākuma diena = nav

pos = templatelist [i] .find (ENDDAY_KEY)
ja poz! = -1:
atrasts variants = patiess
pos = pos + len (ENDDAY_KEY)
endday = int (templatelist [i] [pos: pos + 4] .strip ("}"). strip ("{"). strip ("-"). strip (""))
cits:
beigu diena = nav

pos = templatelist [i] .find (NIGHT_KEY)
ja poz! = -1:
atrasts variants = patiess
nakts = True
cits:
nakts = nepatiesa

pos = templatelist [i] .find (SHORTWEEKDAY_KEY)
ja poz! = -1:
atrasts variants = patiess
īsa nedēļa = taisnība
cits:
shortweekday = Nepatiesa

pos = templatelist [i] .find (IMPERIAL_KEY)
ja poz! = -1:
atrasts variants = patiess
impērijas = True
cits:
imperators = nepatiesa

pos = templatelist [i] .find (HIDEUNITS_KEY)
ja poz! = -1:
atrasts variants = patiess
slēptāji = patiess
cits:
slēptāji = Nepatiesa

pos = templatelist [i] .find (SPACES_KEY)
ja poz! = -1:
atrasts variants = patiess
pos = pos + len (SPACES_KEY)
atstarpes = int (templatelist [i] [pos: pos + 4] .strip («}»). strip («{«). strip («-«). strip (»«))
cits:
atstarpes = 1

ja opcija atrasta == True:
templatelist [i] = self.getOutputText (datu tips, sākuma diena, beigu diena, nakts, īsās nedēļas diena, imperators, slēptuves, atstarpes)
atrasts variants = nepatiesa

# iziet sarakstu, apvienojot izvadi tagad, kad tas ir aizpildīts
vienumam templatelist:
izeja = izeja + vienums

atgriešanās izeja

#izņemot:
#print "getOutputTextFromTemplate: Negaidīta kļūda:", sys.exc_info () [0]

def fetchData (pats):

# vienmēr iegūst metrikas datus, šajos datos izmantojiet sarunu 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)

ja self.isConnectionAvailable () == Nepatiesa:
ja eksistē os.path.exe (file_path_current):
RefetchData = Nepatiesa
cits: # nav savienojuma, nav kešatmiņas, sprādziens!
print "Nav pieejams interneta savienojums un nav laika datu kešatmiņā."
elif self.options.refetch == Taisnība:
RefetchData = Patiesa
cits:
# vai dati ir jāatgūst vēlreiz?
ja eksistē 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 ()

ja derīguma termiņš> lastmodDate:
RefetchData = Patiesa
cits:
RefetchData = Nepatiesa
cits:
RefetchData = Patiesa

# ielādējiet pašreizējo apstākļu datus vai nu no vietnes, vai arī "noņemot"
ja RefetchData == True:

# iegūt pašreizējo apstākļu datus no xoap servisa
mēģiniet:

# 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 & vienība = m '
ja self.options.verbose == True:
drukāt >> sys.stdout, «laika apstākļu datu iegūšana no«, URL

Usock = urllib2.urlopen (url)
xml = usock.read ()
Usock.close ()
self.weatherxmldoc = minidom.parseString (xml)
izņemot:
print "fetchData: Negaidīta kļūda:", sys.exc_info () [0]
print "Nevar sazināties ar laika apstākļu avotu par pašreizējiem apstākļiem"

# pastāstiet lietotājam, ja atrašanās vieta ir slikta…
found = xml.find ("Norādīta nederīga atrašanās vieta")
ja atrodams! = -1:
drukāt "Norādīta nederīga atrašanās vieta"

# iztaujāt laika apstākļu datus, ielādēt klases struktūrā un marinēt tos
mēģiniet:

# sagatavot laika apstākļu datu sarakstus
self.current_conditions = []
self.day_forecast = []
self.night_forecast = []

# apkopot vispārīgus datus
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)

# apkopot pašreizējo apstākļu datus
day_of_week = u »Šodien»
nokrišņi = u »N / A»
sunrise_n = location_n.getElementsByTagName ('sunr') [0]
saullēkts = self.getText (saullēkta_n.childNodes)
sunset_n = location_n.getElementsByTagName ('suns') [0]
saulriets = 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 ('ikona') [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 ('josla') [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 ('vējš') [0]
wind_speed_n = wind_n.getElementsByTagName ('s') [0]
wind_speed = self.getText (wind_speed_n.childNodes)
wind_gust_n = wind_n.getElementsByTagName ('brāzma') [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)
mitruma_n = pašreizējais_nosacījums_n.getElementsByTagName ('hmid') [0]
mitrums = self.getText (mitruma_n.childNodes)
moon_n = current_condition_n.getElementsByTagName ('mēness') [0]
moon_icon_n = moon_n.getElementsByTagName ('ikona') [0]
moon_icon = self.getText (moon_icon_n.childNodes)
moon_phase_n = moon_n.getElementsByTagName ('t') [0]
moon_phase = self.getText (moon_phase_n.childNodes)
current_conditions_data = WeatherData (nedēļas_nedēļas, pašreizējās_tempas_dzejas, pašreizējais_temp, pašreizējais_kods, pašreizējais_desc, nokrišņi, mitrums, vēja_virziens, vēja ātrums, vēja_gari, pilsēta, saullēkts, saulriets, mēness_fāze, mēness_ikonu, joslu_read, bar_desc)
self.current_conditions.append (current_conditions_data)

# apkopot prognozes datus
bar_read = u »N / A»
bar_desc = u »N / A»
mēness_fāze = u »N / A»
moon_icon = u »na»
prognozes_n = laika_n.getElementsByTagName ('dayf') [0]
day_nodes = prognoze_n.getElementsByTagName ('diena')

dienai day_nodes:
day_of_week = day.getAttribute ('t')
day_of_year = day.getAttribute ('dt')
high_temp_n = day.getElementsByTagName ('čau') [0]
high_temp = self.getText (high_temp_n.childNodes)
low_temp_n = day.getElementsByTagName ('zems') [0]
low_temp = self.getText (low_temp_n.childNodes)

sunrise_n = day.getElementsByTagName ('sunr') [0]
saullēkts = self.getText (saullēkta_n.childNodes)
sunset_n = day.getElementsByTagName ('suns') [0]
saulriets = self.getText (sunset_n.childNodes)

Konkrēti dati par # dienu prognozi
daytime_n = day.getElementsByTagName ('part') [0] # diena
condition_code_n = daytime_n.getElementsByTagName ('ikona') [0]
condition_code = self.getText (condition_code_n.childNodes)
condition_n = daytime_n.getElementsByTagName ('t') [0]
nosacījums = self.getText (nosacījums_n.childNodes)
rain_n = daytime_n.getElementsByTagName ('ppcp') [0]
nokrišņi = self.getText (liets_n.childNodes)
mitruma_n = dienas laikā_n.getElementsByTagName ('hmid') [0]
mitrums = self.getText (mitruma_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 ('brāzma') [0]
wind_gusts = self.getText (wind_gusts_n.childNodes)
day_forecast_data = WeatherData (nedēļas_nedēļas, zemas temperatūras, augstās temperatūras, stāvokļa_kods, stāvoklis, nokrišņi, mitrums, vēja virziens, vēja ātrums, vēja_griezumi, pilsēta, saullēkts, saulriets, mēness_fāze, mēness_ikonu, joslu_līmeņa, bar_desc)
self.day_forecast.append (day_forecast_data)

# nakts prognozes specifiski dati
daytime_n = day.getElementsByTagName ('part') [1] # nakts
condition_code_n = daytime_n.getElementsByTagName ('ikona') [0]
condition_code = self.getText (condition_code_n.childNodes)
condition_n = daytime_n.getElementsByTagName ('t') [0]
nosacījums = self.getText (nosacījums_n.childNodes)
rain_n = daytime_n.getElementsByTagName ('ppcp') [0]
nokrišņi = self.getText (liets_n.childNodes)
mitruma_n = dienas laikā_n.getElementsByTagName ('hmid') [0]
mitrums = self.getText (mitruma_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 ('brāzma') [0]
wind_gusts = self.getText (wind_gusts_n.childNodes)
night_forecast_data = WeatherData (nedēļas_nedēļas, zemas temperatūras, augstās temperatūras, stāvokļa_kods, stāvoklis, nokrišņi, mitrums, vēja virziens, vēja ātrums, vēja_griezumi, pilsēta, saullēkts, saulriets, mēness_fāze, mēness_ikonu, joslu_līmeņa, bar_desc)
self.night_forecast.append (night_forecast_data)

# marinējiet datus nākamajai reizei!
fileoutput = atvērts (file_path_current, 'w')
pickle.dump (self.current_conditions, fileoutput)
fileoutput.close ()

fileoutput = atvērts (file_path_dayforecast, 'w')
pickle.dump (self.day_forecast, fileoutput)
fileoutput.close ()

fileoutput = atvērts (file_path_nightforecast, 'w')
pickle.dump (self.night_forecast, fileoutput)
fileoutput.close ()

izņemot:
print "fetchData: Negaidīta kļūda:", sys.exc_info () [0]
drukāt "Nevar izjautāt laika apstākļu datus"

cits: # iegūt laika apstākļu datus no marinētiem klases failiem
ja self.options.verbose == True:
drukāt >> sys.stdout, «laika apstākļu datu iegūšana no faila:«, file_path_current

fileinput = atvērts (file_path_current, 'r')
self.current_conditions = marinēt.load (faila ievade)
fileinput.close ()

ja self.options.verbose == True:
drukāt >> sys.stdout, "ielādē dienas prognozes datus no failiem:", file_path_dayforecast, file_path_nightforecast

fileinput = atvērts (file_path_dayforecast, 'r')
self.day_forecast = pickle.load (faila ievade)
fileinput.close ()

ja self.options.verbose == True:
drukāt >> sys.stdout, «dienas prognožu datu iegūšana no failiem:«, file_path_nightforecast, file_path_nightforecast

fileinput = atvērts (file_path_nightforecast, 'r')
self.night_forecast = pickle.load (faila ievade)
fileinput.close ()

def outputData (pats):
# mēģinājums:

ja self.options.template! = Nav:

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

cits:

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

drukas output.encode ("utf-8")

#izņemot:
#print «outputData: Negaidīta kļūda:«, sys.exc_info () [0]

ja __nosaukums == "__main__":

parsētājs = CommandLineParser ()
(opcijas, args) = parser.parse_args ()

ja options.verbose == True:
drukāt >> sys.stdout, "location:", options.location
drukāt >> sys.stdout, "imperial:", options.imperial
drukāt >> sys.stdout, "datatype:", options.datatype
drukāt >> sys.stdout, "night:", options.night
drukāt >> sys.stdout, "sākuma diena:", options.startday
drukāt >> sys.stdout, "beigu diena:", options.endday
drukāt >> sys.stdout, "atstarpes:", options.spaces
drukāt >> sys.stdout, "verbose:", options.verbose
drukāt >> sys.stdout, "atjaunot:", options.refetch

# izveidot jaunu globālu laika objektu
laika apstākļi = GlobalWeather (opcijas)
weather.fetchData ()
weather.outputData ()

Mēs izveidojam failu ~ / Conky / scripts / myweather.template

gedit ~ / Conky / scripts / myweather.template

iekšpusē ielīmējam:

{–Datatype = DW –startday = 1}: {–datatype = CC –startday = 1}
{–Datatype = HT –startday = 1} / {–datatype = LT –startday = 1} Vējš no {–datatype = WD –startday = 1} līdz {–datatype = WS –startday = 1}
Mitrums: {–datatype = HM –startday = 1} Nokrišņi: {–datatype = PC –startday = 1}
Saullēkts: {–datatype = SR –startday = 1} Saulriets: {–datatype = SS –startday = 1}
————————————————
{–Datatype = DW –startday = 2}: {–datatype = CC –startday = 2}
{–Datatype = HT –startday = 2} / {–datatype = LT –startday = 2} Vējš no {–datatype = WD –startday = 2} līdz {–datatype = WS –startday = 2}
Mitrums: {–datatype = HM –startday = 2} Nokrišņi: {–datatype = PC –startday = 2}
Saullēkts: {–datatype = SR –startday = 2} Saulriets: {–datatype = SS –startday = 2}
————————————————
{–Datatype = DW –startday = 3}: {–datatype = CC –startday = 3}
{–Datatype = HT –startday = 3} / {–datatype = LT –startday = 3} Vējš no {–datatype = WD –startday = 3} līdz {–datatype = WS –startday = 3}
Mitrums: {–datatype = HM –startday = 3} Nokrišņi: {–datatype = PC –startday = 3}
Saullēkts: {–datatype = SR –startday = 3} Saulriets: {–datatype = SS –startday = 3}
————————————————
{–Datatype = DW –startday = 4}: {–datatype = CC –startday = 4}
{–Datatype = HT –startday = 4} / {–datatype = LT –startday = 4} Vējš no {–datatype = WD –startday = 4} līdz {–datatype = WS –startday = 4}
Mitrums: {–datatype = HM –startday = 4} Nokrišņi: {–datatype = PC –startday = 4}
Saullēkts: {–datatype = SR –startday = 4} Saulriets: {–datatype = SS –startday = 4}

Mēs izveidojam failu ~ / Conky / scripts / mail / conkyEmail.py (jāizveido pasta mape)

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

un ielīmējiet iekšpusē:

importēt tevi
importa virkne

# Ievadiet savu lietotājvārdu un paroli zemāk pēdiņās
# piem. lietotājvārds = »lietotājvārds» un parole = »parole»
lietotājvārds = »YOUR_USUARIO_SINARROBA«
parole = »SAVS_KEY«

com = »wget -O - https: //» + lietotājvārds + »:» + parole + »@ 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 [indekss + 11: indekss2])

ja fc == 0:
izdrukāt "0 jaunu"
cits:
drukas str (fc) + »jauns»

Tātad tagad jums ir 7 faili:

Mapē: ~
-> .startconky << - padarīt izpildāmu

Mapē: ~ / Conky
-> conkymain
-> conkyforecast
-> konkymail

un mapē: ~ / Conky / scripts
-> conkyForecast.py << - padarīt izpildāmu
-> myweather.template

un mapē: ~ / Conky / scripts / mail
conkyEmail.py << - padarīt izpildāmu

Un tas ir viss, precizējumi, kur teikts / home / user / ... jūsu lietotājvārds un tajā daļā, kur iet Gmail dati, es iezīmēju krāsās, kur jums jāievieto dati.

lai nogalinātu viltus procesu, rakstiet uz konsoli

killall conky

lai palaistu konku, rakstiet uz konsoli

./.startconky

kad viss ir noregulēts, ja vēlaties, lai katra sesija sāktos

Sistēma—> Preferences—> Sesijas un startēšanas programmās mēs to pievienojam

Nosaukumā mēs varam rakstīt Conky, secībā ./.startconky ar to, ka tas sāksies katru reizi, kad ieslēdzat datoru.

Tas ir viss, es ceru, ka tas jums palīdzēs.