Conky, minha configuração

Ubunlog

Minutos 37

O Fecfactor me pediu ontem para publicar a configuração do conky que mostro na imagem abaixo

Como você pode ver, trata-se de cerca de 3 conkys, que são executados por meio de um script, sua configuração é baseada em este post postado pelo usuário Bruce M. nos fóruns de Ubuntu-Ar com algumas modificações no conky mail, que no meu caso é para o Gmail.

No post de referência está muito bem explicado pelo Bruce, mas também como um auxiliar de memória para mim, copiarei os passos a seguir e o código dos meus conkys para quem os tiver.

Bem, é claro que precisamos ter conky, curl e python instalados, então digitamos em um console:

sudo apt-get instalar conky curl python

A fonte de weather.ttf e arrows.ttf Está aqui. A fonte de moon.ttf Está aqui uma vez baixado, você deve copiá-los para / usr / share / fonts

Vamos agora criar nosso script chamado ~. / Startconky

gksudo gedit ~ / .startconky

dentro do arquivo vazio, colamos o seguinte

#! / Bin / bash
sleep 0 & # 0 bom para Xfce - use 20 a 30 para Gnome
conky -c ~ / Conky / conkymain &
#sleep 0 & # 0 bom para Xfce - use 1 para Gnome
conky -c ~ / Conky / conkyforecast &
#sleep 0 & # 0 bom para Xfce - use 1 para Gnome
conky -c ~ / Conky / conkymail &

Agora vamos criar o arquivo conkymain na pasta ~ / Conky, se não tivermos a pasta Conky, teremos que criá-la.

gedit ~ / Conky / conkymain

Eu uso a fonte Calibri, se você não tiver, substitua pela que você quiser.

Nós ficamos dentro do que se segue

fundo não
own_window sim
own_window_transparent sim
own_window_hints undecorated, below, sticky, skip_taskbar, skip_pager
própria_janela_cor preta
double_buffer sim
use_spacer à esquerda
use_xft sim
fonte calibri: tamanho = 9
xftfont calibri: size = 9
xftalpha 0.5
intervalo_atualização 5.0
maiúscula não # defina como sim se você quiser que todo o texto esteja em maiúsculas
pontilhado_borders 3
borda_margem 9
largura_borda 10
cor_padrão branco
default_outline_color preto
default_shade_color preto
cor0 ciano
color1 azul claro
cor 2 laranja
cor 3 amarelo
trigo da cor 4
color5 branco
color6 branco
color7 branco
color8 branco
color9 branco
alinhamento top_right # ou top_left, bottom_left, bottom_right
lacuna_x 10
lacuna_y 35
text_buffer_size 128 # use 1024 para a previsão
no_buffers yes # Subtrair os buffers do sistema de arquivos da memória usada?
draw_borders não
draw_outline yes # amplifica o texto se sim
draw_shades yes # shadecolor black

TEXTO
$ {font calibri: size = 12} $ {alignc} $ {color1} $ sysname $ kernel em $ machine} $ color $ font
$ {font calibri: size = 12} $ {alignc} $ {color2} $ {exec whoami} @ $ nodename $ color $ font
$ {color0} $ {hr 1} $ color
$ {font calibri: size = 20} $ {alignc} $ {time% H:% M} $ font
$ {font calibri: size = 12} $ {color1} $ {alignc} $ {time% A,% d% b. % Y} $ color $ fonte
$ {color3} UpTime: $ {alignr 2} $ uptime $ color
$ {color0} $ {hr 1} $ color
$ {voffset 5} $ {color2} CPU: $ {alignc} $ color $ running_processes $ {color1} / $ color $ process $ {alignr 2} $ {color2} $ {cpubar cpu0 14,80} $ color
$ {color1} $ {voffset -16} $ {alignr 5} $ cpu% $ color
$ {voffset 2} $ {color1} Carga média ($ {color3} Mín $ {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} Armazenado em buffer: $ color $ {buffers} $ {alignr 2} $ {color1} Em cache: $ color $ {cached}
$ {voffset 5} $ {color2} SWAP: $ color $ swap $ {color2} / $ color $ {swapmax} $ {alignr 2} $ {color2} $ {swapbar 14,80} $ color
$ {color1} $ {voffset -16} $ {alignr 5} $ swapperc%
$ {color0} $ {hr 1} $ color
$ {voffset 5} $ {color2} HD Info $ {color1} - $ color Grátis $ {color1} - Usado - $ {color2} Total
$ {voffset 5} $ {color1} Root: $ color $ {fs_free_perc /}% $ {alignr 2} $ {fs_free /} $ {color2} / $ {color1} $ {fs_used /} $ color / $ {color2} $ {fs_size /} $ color
$ {color1} Home: $ 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} $ color
$ {color1} De: $ color Buenos Aires, Argentina
$ {color1} Lat: $ {color2} 34 ° 35'S $ {color1} Longo: $ {color2} 58 ° 21'W $ {color1} Alt: $ {color2} 25 m $ color
$ {voffset 5} $ {color2} $ {font calibri: size = 12} hoje: $ font $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = CC} $ cor $ {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 $ Fonte
$ {alignc 10} $ {voffset 5} $ {color4} Vento: $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = WS} $ color
$ {color1} Umidade: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = HM} $ {alignr 2} $ {color1} Precipitação: $ {color3} $ { execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = PC} $ color
$ {alignc} $ {color1} Pressão: $ {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} $ color
$ {color1} Nascer do sol: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = SR} $ {alignr 2} $ {color1} Pôr do sol: $ {color3} $ { execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = SS} $ color
$ {voffset 15} $ {color1} Lua: $ {color4} $ {alignr 2} $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = MP} $ color
$ {voffset -20} $ {offset 80} $ {color4} $ {font moon phase: size = 20} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = MF} $ font $ color
$ {color0} $ {hr} $ color
$ {voffset 5} $ {color2} IP: $ {alignc} $ color $ {addr eth0}
$ {color1} Abaixo: $ color $ {downspeed eth0} k / s $ {alignr 2} $ {color1} Acima: $ color $ {upspeed eth0} k / s
$ {color1} Total: $ color $ {totaldown eth0} $ {alignr 2} $ {color1} Total: $ color $ {totalup eth0}
$ {color1} Entrada: $ color $ {tcp_portmon 1 32767 count} $ {color1} Saída: $ color $ {tcp_portmon 32768 61000 count} $ {alignr 2} $ {color1} Total: $ color $ {tcp_portmon 1 65535 count}
$ {voffset 5} $ {color2} Conexões: $ color $ {tcp_portmon 32768 61000 count} $ {alignr 2} $ {color2} Serviço / Porta $ 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

nós criamos o arquivo ~ / Conky / conkyforecast

gedit ~ / Conky / conkyforecast

e colamos o seguinte dentro

fundo não
own_window sim
own_window_transparent sim
own_window_hints undecorated, below, sticky, skip_taskbar, skip_pager
própria_janela_cor preta
double_buffer sim
use_spacer à esquerda
use_xft sim
fonte calibri: tamanho = 8
xftfont calibri: size = 8
xftalpha 0.5
intervalo_atualização 5.0
maiúscula não # defina como sim se você quiser que todo o texto esteja em maiúsculas
pontilhado_borders 3
borda_margem 9
largura_borda 10
cor_padrão branco
default_outline_color preto
default_shade_color preto
cor0 ciano
color1 azul claro
cor 2 laranja
cor 3 amarelo
trigo da cor 4
color5 branco
color6 branco
color7 branco
color8 branco
color9 branco
alinhamento bottom_left # or top_left, bottom_left, bottom_right
lacuna_x 10
lacuna_y 35
text_buffer_size 1024 # use 1024 para a previsão
no_buffers yes # Subtrair os buffers do sistema de arquivos da memória usada?
draw_borders não
draw_outline yes # amplifica o texto se sim
draw_shades yes # shadecolor black

TEXTO
$ {color4} $ {font calibri: size = 11} Previsão estendida $ font $ color
$ {color0} $ {hr} $ color
$ {color4} $ {font calibri: size = 9} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –template = / home / user / Conky / scripts / myweather.template} $ font $ cor

nós criamos o arquivo ~ / Conky / conkymail

gedit ~ / Conky / conkymail

colamos o seguinte no arquivo

fundo não
own_window sim
own_window_transparent sim
own_window_hints undecorated, below, sticky, skip_taskbar, skip_pager
própria_janela_cor preta
double_buffer sim
use_spacer à esquerda
use_xft sim
fonte calibri: tamanho = 8
xftfont calibri: size = 8
xftalpha 0.5
intervalo_atualização 5.0
maiúscula não # defina como sim se você quiser que todo o texto esteja em maiúsculas
pontilhado_borders 3
borda_margem 9
largura_borda 10
cor_padrão branco
default_outline_color preto
default_shade_color preto
cor0 ciano
color1 azul claro
cor 2 laranja
cor 3 amarelo
trigo da cor 4
color5 branco
color6 branco
color7 branco
color8 branco
color9 branco
alinhamento bottom_left # or top_left, bottom_left, bottom_right
lacuna_x 565
lacuna_y 35
text_buffer_size 128 # use 1024 para a previsão
no_buffers yes # Subtrair os buffers do sistema de arquivos da memória usada?
draw_borders não
draw_outline yes # amplifica o texto se sim
draw_shades yes # shadecolor black

TEXTO
$ {font calibri: size = 11} $ {alignc} $ {color4} Gmail
$ {color0} $ {hr} $ color
$ {font calibri: size = 11} $ {color4} Temos $ {color3} $ {execi 300 python ~ / Conky / scripts / mail / conkyEmail.py} $ {color4} email (s) $ font

Criamos um arquivo em ~ / Conky / scripts / conkyForecast.py (devemos criar a pasta de scripts)

gedit ~ / Conky / scripts / conkyForecast.py

#! / usr / bin / python
# - * - codificação: utf-8 - * -
############################################################### #####################################
# conkyForecast.py é um script Python (não tão) simples (mais) de reunir
# detalhes do clima atual para uso em conky.
#
# Autor: Kaivalagi
# Criado: 13/04/2008
# Modificações:
# 14/04/2008 Permitir intervalos de dias para dados de previsão
# 14/04/2008 Verifique a conectividade com o serviço xoap
# 18/04/2008 Permitir a configuração de espaços para saída de faixa
# 18/04/2008 Permitir saída de previsão diurna e noturna
# 18/04/2008 Suporte local para opção de texto de código de condição «CC», aguardando tradução para o idioma espanhol
# 18/04/2008 Use pickling para dados de classe em vez de abrir xml, isso evita a necessidade de interrogar dados em cache
# 19/04/2008 Texto de condição em espanhol adicionado - Obrigado Bruce M
# 19/04/2008 Adicionada verificação isnumérica em todas as saídas numéricas com sufixo de unidades
# 19/04/2008 Alteração na nomenclatura do arquivo pickle para incluir o código do local
# 19/04/2008 Adicionada conversão de dias da semana em espanhol via local
# 20/04/2008 Adicionado analisador de argumento de comando decente
# 20/04/2008 Adicionada opção –shortweekday, se dado o dia da semana, o tipo de dados é reduzido para 3 caracteres
# 21/04/2008 Opções de local fixo para saída de previsão
# 21/04/2008 Adicionada opção –template para permitir saída personalizada usando uma única chamada exec 🙂
# 21/04/2008 Adicionada opção –hideunits para remover, por exemplo, mph e C da saída
# 23/04/2008 Removida a opção –imperial do modelo, ela DEVE ser definida como uma opção padrão na chamada do script e não usada no arquivo de modelo.
# 23/04/2008 Lido - opção imperial para modelo, habilitando valores métricos ou imperiais por tipo de dados. Observe que ao usar modelos, a opção de linha de comando não funcionará.
# 23/04/2008 Adicionada saída notificando o usuário se a localização fornecida for ruim
# 24/04/2008 Tratamento adicionado para nenhuma conectividade, irá reverter para os dados em cache agora (erro se não houver cache). Testes tentando abrir xoap.weather.com
# 24/04/2008 Conversão corrigida de Celsius para Fahrenheit
# 06/05/2008 URL atualizado usado depois que o serviço da web foi atualizado
# 09/05/2008 Condições atuais consolidadas e dados de previsão coletados em uma chamada
# 09/05/2008 Adicionado nascer e pôr do sol aos tipos de dados, que são específicos para as condições atuais e dados de previsão
# 09/05/2008 Adicionada fase da lua, leitura do barômetro e descrição do barômetro aos tipos de dados, estes são apenas específicos para as condições atuais e, portanto, são N / A na saída prevista
# 09/05/2008 Adicionadas conversões de unidades para barômetro de mb para polegadas (imperial)
# 09/05/2008 Texto atualizado da condição em espanhol - Obrigado Bruce M
# 10/05/2008 Adicionados dados de localidade francesa - Obrigado benpaka
# 12/05/2008 Novo tipo de dados BF (fonte de rolamento) adicionado para fornecer um caractere de seta (use com a fonte Arrow.ttf) em vez de saída NSEW do WD (direção do vento)
# 12/05/2008 Saída do WD atualizada para ser específico do local, atualmente suporta inglês e espanhol padrão - Obrigado Bruce M
# 18/05/2008 Novo tipo de dados MF (fonte lua) adicionado para fornecer um caractere de fonte lua (caracteres incorretos e nenhuma fonte dedicada ainda).
# 21/05/2008 Para as condições atuais, a opção –datatype = LT agora exibe a temperatura "agradável" em vez da temperatura atual
#
# TUDO:
# Consolide arquivos pkl em um arquivo / classe
# Adicionar uma fonte meteorológica com base na saída da fase da lua com base nos dados do ícone da lua
# ??? Há mais requisitos por aí?

importar sys, os, socket, urllib2, datetime, time
de xml.dom import minidom
da importação estatística *
de optparse import OptionParser
importar local
importar gettext
importar picles
da importação matemática *

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

classe CommandLineParser:

analisador = Nenhum

def __init __ (self):

self.parser = OptionParser ()
self.parser.add_option («- l», »- location», dest = »location», default = »UKXX0103 ″, type =» string », metavar =» CODE », help = u» código de localização para dados meteorológicos [ default:% default], Use o seguinte url para determinar o código do seu local pelo nome da cidade: http://xoap.weather.com/search/search?where=Norwich »)
self.parser.add_option ("- d", "- datatype", dest = "datatype", default = "HT", type = "string", metavar = "DATATYPE", help = u "[padrão:% default] As opções de tipo de dados são: DW (dia da semana), WF (saída da fonte do tempo), LT (previsão: baixa temperatura, corrente: parece a temperatura), HT (previsão: alta temperatura, corrente: temperatura atual), CC (atual Condições), CT (texto das condições), PC (possibilidade de precipitação), HM (umidade), WD (direção do vento), WS (velocidade do vento), WG (rajadas de vento), CN (nome da cidade), SR (nascer do sol), SS (pôr do sol), MP (fase da lua), MF (fonte da lua), BR (leitura do barômetro), BD (descrição do barômetro). Não aplicável na linha de comando ao usar modelos. »)
self.parser.add_option («- s», »- startday», dest = »startday», type = »int», metavar = »NUMBER», help = u »define o número do dia inicial, se as condições atuais omitidas forem geradas . Não aplicável na linha de comando ao usar modelos. »)
self.parser.add_option ("- e", "- endday", dest = "endday", type = "int", metavar = "NUMBER", help = u "define o número do dia final, se omitido apenas os dados do dia inicial é a saída. Não aplicável na linha de comando ao usar modelos. »)
self.parser.add_option («- S», »- espaços», dest = »espaços», tipo = »int», padrão = 1, metavar = »NÚMERO», ajuda = u »[padrão:% padrão] Define o número de espaços entre a saída variada. Não aplicável na linha de comando ao usar modelos. »)
self.parser.add_option («- t», »- template», dest = »template», type = »string», metavar = »FILE», help = u »define um arquivo de template para gerar saída em uma chamada. A item exibível no arquivo está no formato {–datatype = HT –startday = 1}. A seguir estão as opções possíveis dentro de cada item: –datatype, –startday, –endday, –night, –shortweekday, –imperial, –hideunits, –Spaces. Observe que as formas curtas das opções não são suportadas no momento! Nenhuma dessas opções é aplicável na linha de comando ao usar modelos. »)
self.parser.add_option («- L», »- locale», dest = »locale», type = »string», help = u »sobrescrever a localidade do sistema para a saída do idioma (en = inglês, es = espanhol, fr = francês, mais por vir) »)
self.parser.add_option ("- i", "- imperial", dest = "imperial", default = False, action = "store_true", help = u "solicitar unidades imperiais, se a saída omitida estiver no sistema métrico. Não aplicável em linha de comando ao usar modelos. »)
self.parser.add_option («- n», »- night», dest = »night», default = False, action = »store_true», help = u »muda a saída para dados noturnos, se omitido a saída diurna será gerada. Não aplicável na linha de comando ao usar modelos. »)
self.parser.add_option («- w», »- shortweekday», dest = »shortweekday», default = False, action = »store_true», help = u »Encurte o tipo de dados do dia da semana para 3 caracteres. Não aplicável em linha de comando ao usar modelos. »)
self.parser.add_option («- u», »- hideunits», dest = »hideunits», default = False, action = »store_true», help = u »Ocultar unidades como mph ou C, símbolos de grau (°) são ainda mostrado. Não aplicável na linha de comando ao usar modelos. »)
self.parser.add_option ("- v", "- verbose", dest = "verbose", default = False, action = "store_true", help = u "solicitar saída detalhada, não é uma boa ideia ao executar conky!" )
self.parser.add_option ("- r", "- refetch", dest = "refetch", default = False, action = "store_true", help = u "buscar dados independentemente da expiração dos dados")

def parse_args (self):
(opções, args) = self.parser.parse_args ()
return (opções, args)

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

classe WeatherData:
def __init __ (self, day_of_week, low, high, condition_code, condition_text, precip, umidade, wind_dir, wind_speed, wind_rusts, city, sunrise, sunset, moon_phase, moon_icon, bar_read, bar_desc):
self.day_of_week = u »» + day_of_week
self.low = u »» + baixo
self.high = u »» + high
self.condition_code = u »» + condition_code
self.condition_text = u »» + texto_condição
self.precip = u »» + precip
auto.umidade = u »» + umidade
self.wind_dir = u »» + wind_dir
self.wind_speed = u »» + wind_speed
self.wind_gusts = u »» + wind_gusts
self.city = u »» + cidade
self.sunrise = u »» + nascer do sol
self.sunset = u »» + pôr do sol
self.moon_phase = u »» + moon_phase
self.moon_icon = u »» + moon_icon
self.bar_read = u »» + bar_read
self.bar_desc = u »» + bar_desc

classe WeatherText:

texto_condições = {
«0»: _ (u »Tornado»),
«1»: _ (u »Tempestade tropical»),
«2»: _ (u »Furacão»),
«3»: _ (u »Tempestades severas»),
«4»: _ (u »Tempestades»),
«5»: _ (u »Chuva e neve mistas»),
«6»: _ (u »Chuva e granizo mistos»),
«7»: _ (u »Precipitação mista»),
«8»: _ (u »Chuvisco Congelante»),
«9»: _ (u »Chuvisco»),
«10»: _ (u »Chuva Congelante»),
«11»: _ (u »Chuveiros»),
«12»: _ (u »Chuveiros»),
«13»: _ (u »Ondas de neve»),
«14»: _ (u »Pancadas leves de neve»),
«15»: _ (u »Sopro de neve»),
«16»: _ (u »Neve»),
«17»: _ (u »Salve»),
«18»: _ (u »granizo»),
«19»: _ (u »Poeira»),
«20»: _ (u »Nevoeiro»),
«21»: _ (u »Haze»),
«22»: _ (u »Fumaça»),
«23»: _ (u »Tempestade»),
«24»: _ (u »Ventoso»),
«25»: _ (u »Frio»),
«26»: _ (u »Nublado»),
«27»: _ (u »Muito Nublado»),
«28»: _ (u »Muito Nublado»),
«29»: _ (u »Parcialmente Nublado»),
«30»: _ (u »Parcialmente Nublado»),
«31»: _ (u »Limpar»),
«32»: _ (u »Limpar»),
«33»: _ (u »Razoável»),
«34»: _ (u »Razoável»),
«35»: _ (u »Chuva e granizo mistos»),
«36»: _ (u »Quente»),
«37»: _ (u »Tempestades isoladas»),
«38»: _ (u »Tempestades Espalhadas»),
«39»: _ (u »Tempestades Espalhadas»),
«40»: _ (u »Chuveiros Espalhados»),
«41»: _ (u »Neve Pesada»),
«42»: _ (u »Pancadas de neve dispersas»),
«43»: _ (u »Neve Pesada»),
«44»: _ (u »Parcialmente Nublado»),
«45»: _ (u »Chuva trovão»),
«46»: _ (u »Pancadas de neve»),
«47»: _ (u »Tempestades isoladas»),
«Na»: _ (u »N / A»),
"-": _(uma")
}

condições_texto_es = {
«0»: _ (u »Tornado»),
«1»: _ (u »Tempestade tropical»),
«2»: _ (u »Huracá¡n»),
«3»: _ (u »Tempestades Fortes»),
«4»: _ (u »Tempestades»),
«5»: _ (u »Chuva e neve mistas»),
«6»: _ (u »Chuva e granizo mistos»),
«7»: _ (u »granizo»),
«8»: _ (u »Chuvisco Congelante»),
«9»: _ (u »Chuvisco»),
«10»: _ (u »Chuva congelante»), # ou chuva congelante
«11»: _ (u »Chuveiros»),
«12»: _ (u »Chuveiros»),
«13»: _ (u »neve fraca»),
«14»: _ (u »neve fraca»),
«15»: _ (u »Nevasca de neve»),
«16»: _ (u »Neve»),
«17»: _ (u »Salve»),
«18»: _ (u »granizo»),
«19»: _ (u »Pó»),
«20»: _ (u »Nevoeiro»),
«21»: _ (u »Haze»),
«22»: _ (u »Fumaça»),
«23»: _ (u »Tempestade»),
«24»: _ (u »Ventoso»),
«25»: _ (u »Fráo»),
«26»: _ (u »Muito Nublado»),
«27»: _ (u »Muito Nublado»),
«28»: _ (u »Muito Nublado»),
«29»: _ (u »Parcialmente Nublado»),
«30»: _ (u »Parcialmente Nublado»),
«31»: _ (u »Limpar»),
«32»: _ (u »Limpar»),
«33»: _ (u »Algo Nublado»),
«34»: _ (u »Algo Nublado»),
«35»: _ (u »Chuva com granizo»),
«36»: _ (u »Calor»),
«37»: _ (u »Tempestades isoladas»),
«38»: _ (u »Tempestades Espalhadas»),
«39»: _ (u »Tempestades Espalhadas»),
«40»: _ (u »Chuveiros Espalhados»),
«41»: _ (u »Neve Pesada»),
«42»: _ (u »Quedas de neve fracas e dispersas»),
«43»: _ (u »Intense Nevada»),
«44»: _ (u »Nuvens Espalhadas»),
«45»: _ (u »Tempestades»),
«46»: _ (u »Quedas de neve dispersas»),
«47»: _ (u »Tempestades isoladas»),
«Na»: _ (u »N / A»),
"-": _(uma")
}

condições_texto_fr = {
«0»: _ (u »Tornade»),
«1»: _ (u »Tempête Tropicale»),
«2»: _ (ou »Ouragan»),
«3»: _ (ou »Orages violentos»),
«4»: _ (ou »Orageux»),
«5»: _ (u »Pluie et Neige»),
«6»: _ (u »Pluie et Neige Mouillée»),
«7»: _ (u »Variável avec averses»),
«8»: _ (u »Bruine Givrante»),
«9»: _ (u »Bruine»),
«10»: _ (u »Pluie Glacante»),
«11»: _ (u »Aversão»),
«12»: _ (u »Aversão»),
«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»: _ (ou »Orages Isolés»),
«38»: _ (ou »Orages Localisés»),
«39»: _ (ou »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»: _ (ou »Orages»),
«46»: _ (u »Tempête de Neige»),
«47»: _ (ou »Orages Isolés»),
«Na»: _ (u »N / A»),
"-": _(uma")
}

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

condições_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 »»),
"-": _(ou"")
}

dia_da_semana = {
"Hoje": _ (ou "Hoje"),
«Segunda-feira»: _ (u »segunda-feira»),
«Terça»: _ (u »terça»),
«Quarta-feira»: _ (u »quarta-feira»),
«Quinta-feira»: _ (u »quinta-feira»),
"Sexta-feira": _ (u "sexta-feira"),
"Sábado": _ (u "sábado"),
"Domingo": _ (u "Domingo")
}

dia_da_semana_curto = {
"Hoje": _ (u "Agora"),
«Segunda-feira»: _ (u »seg»),
«Terça»: _ (u »ter»),
"Quarta": _ (u "Quarta"),
«Quinta-feira»: _ (u »qui»),
«Sexta»: _ (u »Sex»),
"Sábado": _ (u "sáb"),
"Domingo": _ (u "Sol")
}

dia_de_semana_es = {
"Hoje": _ (u "hoje"),
"Segunda-feira": _ (u "segunda-feira"),
«Terça»: _ (u »terça»),
«Quarta-feira»: _ (u »quarta-feira»),
«Quinta-feira»: _ (u »quinta-feira»),
«Sexta-feira»: _ (u »sexta-feira»),
"Sábado": _ (u "sábado"),
"Domingo": _ (u "Domingo")
}

day_of_week_short_en = {
"Hoje": _ (u "hoje"),
"Segunda-feira": _ (u "mon"),
«Terça-feira»: _ (u »mar»),
«Quarta-feira»: _ (u »qua»),
«Quinta-feira»: _ (u »qui»),
«Sexta»: _ (u »sex»),
"Sábado": _ (u "sáb"),
"Domingo": _ (u "dom")
}

dia_de_semana_fr = {
«Hoje»: _ (u »Aujourd'hui»),
«Segunda-feira»: _ (u »Lundi»),
«Terça»: _ (u »Mardi»),
«Quarta-feira»: _ (u »Mercredi»),
«Quinta-feira»: _ (u »Jeudi»),
«Sexta-feira»: _ (u »Vendredi»),
"Sábado": _ (u "Samedi"),
"Domingo": _ (u "Dimanche")
}

dia_da_semana_short_fr = {
«Hoje»: _ (u »Auj»),
"Segunda-feira": _ (u "seg"),
«Terça»: _ (u »março»),
"Quarta-feira": _ (u "Mer"),
«Quinta-feira»: _ (u »Jeu»),
«Sexta»: _ (u »Venha»),
"Sábado": _ (u "Sam"),
"Domingo": _ (u "Escuro")
}

rolamento_arrow_font = {
«N»: _ (u »i»),
«NNE»: _ (u »j»),
«NE»: _ (u »k»),
«ENE»: _ (u »l»),
«E»: _ (u »m»),
«ESE»: _ (u »n»),
"SE": _ (u "o"),
«SSE»: _ (u »p»),
«S»: _ (u »a»),
«SSW»: _ (u »b»),
«SW»: _ (u »c»),
"WSW": _ (u "d"),
«W»: _ (u »e»),
"WNW": _ (u "f"),
«NW»: _ (u »g»),
«NNW»: _ (u »h»),
«N / A»: _ (u »«)
}

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

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

classe GlobalWeather:

condições_atual = []
dia_previsão = []
previsão_noturna = []

locale = "em"

opções = Nenhuma
climaxmldoc = «»

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 __ (self, options):

self.options = opções

if self.options.locale == Nenhum:
tente:
# self.locale = locale.getdefaultlocale () [0] [0: 2]
self.locale = «es» #descomente esta linha para forçar a localidade em espanhol
# self.locale = "fr" #uncomment esta linha para forçar a localidade francesa
exceto:
imprimir "local não definido"
outro:
# self.locale = self.options.locale
self.locale = «es» #descomente esta linha para forçar a localidade em espanhol
# self.locale = "fr" #uncomment esta linha para forçar a localidade francesa

if self.options.verbose == Verdadeiro:
imprimir >> sys.stdout, "locale definido como", self.locale

def getText (self, nodelist):
rc = ""
para nó na lista de nós:
se node.nodeType == node.TEXT_NODE:
rc = rc + nó.dados
retorno rc

def getSpaces (self, spaces):
string = u »»
se espaços == Nenhum:
string = self.DEFAULT_SPACING
outro:
para i no intervalo (0, espaços + 1):
string = string + u »«
string de retorno

def isNumeric (self, string):
tente:
dummy = float (string)
retornar verdadeiro
exceto:
retorna falso

def isConnectionAvailable (self):
# certifique-se de que podemos acessar o servidor de weather.com abrindo o url
tente:
Usock = urllib2.urlopen ('http://xoap.weather.com')
Usock.close ()
retornar verdadeiro
exceto:
retorna falso

def getBearingText (self, bearing):
rolamento = flutuação (rolamento)
se rolamento <11.25:
retornar u »N»
rolamento elif <33.75:
retornar u »NNE»
rolamento elif <56.25:
retornar u »NE»
rolamento elif <78.75:
voltar u »JAN»
rolamento elif <101.25:
retornar u »E»
rolamento elif <123.75:
retornar u »ESE»
rolamento elif <146.25:
retornar u »SE»
rolamento elif <168.75:
retornar u »SSE»
rolamento elif <191.25:
retornar u »S»
rolamento elif <213.75:
retornar u »SSW»
rolamento elif <236.25:
retornar u »SW»
rolamento elif <258.75:
retornar u »WSW»
rolamento elif <281.25:
retornar u »W»
rolamento elif <303.75:
retornar u »WNW»
rolamento elif <326.25:
retornar u »NW»
rolamento elif <348.75:
retornar u »NNW»
outro:
retornar «N / A»

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

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

def convertMillibarsToInches (self, mb):
return str (int (floor (float (mb) /33.8582)))

def getTemplateList (self, template):

lista de modelos = []

para template_part em template.split («{«):
if template_part! = «»:
para template_part em template_part.split ("}"):
if template_part! = «»:
templatelist.append (u »» + template_part)

retorno templatelista

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

# define unidades atuais para saída
if hideunidades == False:
se imperial == Falso:
tempunit = u »° C»
speedunit = u »kph»
pressureunit = u »mb»
outro:
tempunit = u »° F»
speedunit = u »mph»
pressureunit = u »em»
outro:
tempunit = u »°»
speedunit = u »»
pressureunit = u »»

if startday == None: # condições atuais

se datatype == "DW":
if self.locale == "is":
if shortweekday == Verdadeiro:
output = WeatherText.day_of_week_short_es [self.current_conditions [0] .day_of_week]
outro:
output = WeatherText.day_of_week_es [self.current_conditions [0] .day_of_week]
elif self.locale == "fr":
if shortweekday == Verdadeiro:
output = WeatherText.day_of_week_short_fr [self.current_conditions [0] .day_of_week]
outro:
output = WeatherText.day_of_week_fr [self.current_conditions [0] .day_of_week]
outro:
if shortweekday == Verdadeiro:
output = WeatherText.day_of_week_short [self.current_conditions [0] .day_of_week]
outro:
output = WeatherText.day_of_week [self.current_conditions [0] .day_of_week]
elif datatype == "WF": # fonte meteorológica
output = WeatherText.conditions_weather_font [self.current_conditions [0] .condition_code]
elif datatype == "LT":
string = self.current_conditions [0] .low
if self.isNumeric (string) == True:
se imperial == Verdadeiro:
string = self.convertCelsiusToFahrenheit (string)
string = string + tempo
saída = string
elif datatype == "HT":
string = self.current_conditions [0] .high
if self.isNumeric (string) == True:
se imperial == Verdadeiro:
string = self.convertCelsiusToFahrenheit (string)
string = string + tempo
saída = string
elif datatype == "CC":
if self.locale == "is":
output = WeatherText.conditions_text_es [self.current_conditions [0] .condition_code]
elif self.locale == "fr":
output = WeatherText.conditions_text_fr [self.current_conditions [0] .condition_code]
outro:
output = WeatherText.conditions_text [self.current_conditions [0] .condition_code]
elif datatype == "CT":
output = self.current_conditions [0] .condition_text
elif datatype == "PC":
string = self.current_conditions [0] .precip
if self.isNumeric (string) == True:
string = string + u »%»
saída = string
elif datatype == "HM":
string = self.current_conditions [0] .umidity
if self.isNumeric (string) == True:
string = string + u »%»
saída = string
elif datatype == "WD":
string = self.current_conditions [0] .wind_dir
if self.isNumeric (string) == True:
string = self.getBearingText (string)

if self.locale == "is":
output = WeatherText.bearing_text_es [string]
elif self.locale == "fr":
output = WeatherText.bearing_text_fr [string]
outro:
saída = string

elif datatype == "BF":
string = self.current_conditions [0] .wind_dir
if self.isNumeric (string) == True:
string = WeatherText.bearing_arrow_font [self.getBearingText (string)]
saída = string
elif datatype == "WS":
string = self.current_conditions [0] .wind_speed
if self.isNumeric (string) == True:
se imperial == Verdadeiro:
string = self.convertKilometresToMiles (string)
string = string + unidade de velocidade
saída = string
elif datatype == "WG":
string = self.current_conditions [0] .wind_gusts
if self.isNumeric (string) == True:
se imperial == Verdadeiro:
string = self.convertKilometresToMiles (string)
string = string + unidade de velocidade
saída = string
elif datatype == "CN":
output = self.current_conditions [0] .city
elif datatype == "SR":
output = self.current_conditions [0] .sunrise
elif datatype == "SS":
output = self.current_conditions [0] .sunset
elif datatype == "MP":
output = self.current_conditions [0] .moon_phase
elif datatype == "MF":
output = WeatherText.conditions_moon_font [self.current_conditions [0] .moon_icon]
elif datatype == "BR":
string = self.current_conditions [0] .bar_read
if self.isNumeric (string) == True:
se imperial == Verdadeiro:
string = self.convertMillibarsToInches (string)
string = string + unidade de pressão
saída = string
elif datatype == "BD":
output = self.current_conditions [0] .bar_desc
outro:
output = "\ nERRO: Tipo de dados desconhecido solicitado"

else: # dados de previsão

if endday == None: # se nenhum endday foi definido, use startday
dia final = dia inicial

if night == True: # previsão noturna necessária

para day_number no intervalo (dia de início, dia de término + 1):

se datatype == "DW":
if self.locale == "is":
if shortweekday == Verdadeiro:
output = output + self.getSpaces (espaços) + WeatherText.day_of_week_short_es [self.night_forecast [day_number] .day_of_week]
outro:
output = output + self.getSpaces (espaços) + WeatherText.day_of_week_es [self.night_forecast [day_number] .day_of_week]
elif self.locale == "fr":
if shortweekday == Verdadeiro:
output = output + self.getSpaces (espaços) + WeatherText.day_of_week_short_fr [self.night_forecast [day_number] .day_of_week]
outro:
output = output + self.getSpaces (espaços) + WeatherText.day_of_week_fr [self.night_forecast [day_number] .day_of_week]
outro:
if shortweekday == Verdadeiro:
output = output + self.getSpaces (espaços) + WeatherText.day_of_week_short [self.night_forecast [day_number] .day_of_week]
outro:
output = output + self.getSpaces (espaços) + WeatherText.day_of_week [self.night_forecast [day_number] .day_of_week]
elif datatype == "WF": # fonte meteorológica
output = output + self.getSpaces (espaços) + WeatherText.conditions_weather_font [self.night_forecast [day_number] .condition_code]
elif datatype == "LT":
string = self.night_forecast [day_number] .low
if self.isNumeric (string) == True:
se imperial == Verdadeiro:
string = self.convertCelsiusToFahrenheit (string)
string = string + tempo
output = output + self.getSpaces (espaços) + string

elif datatype == "HT":
string = self.night_forecast [day_number] .high
if self.isNumeric (string) == True:
se imperial == Verdadeiro:
string = self.convertCelsiusToFahrenheit (string)
string = string + tempo
output = output + self.getSpaces (espaços) + string
elif datatype == "CC":
if self.locale == "is":
output = output + self.getSpaces (espaços) + WeatherText.conditions_text_es [self.night_forecast [day_number] .condition_code]
elif self.locale == "fr":
output = output + self.getSpaces (espaços) + WeatherText.conditions_text_fr [self.night_forecast [day_number] .condition_code]
outro:
output = output + self.getSpaces (espaços) + WeatherText.conditions_text [self.night_forecast [day_number] .condition_code]
elif datatype == "CT":
output = output + self.getSpaces (espaços) + self.night_forecast [day_number] .condition_text
elif datatype == "PC":
string = self.night_forecast [day_number] .precip
if self.isNumeric (string) == True:
string = string + u »%»
output = output + self.getSpaces (espaços) + string
elif datatype == "HM":
string = self.night_forecast [day_number] .humidity
if self.isNumeric (string) == True:
string = string + u »%»
output = output + self.getSpaces (espaços) + string
elif datatype == "WD":
string = self.night_forecast [day_number] .wind_dir
if self.locale == "is":
output = output + self.getSpaces (espaços) + WeatherText.bearing_text_es [string]
elif self.locale == "fr":
output = output + self.getSpaces (espaços) + WeatherText.bearing_text_fr [string]
outro:
output = output + self.getSpaces (espaços) + string

elif datatype == "BF":
output = output + self.getSpaces (espaços) + WeatherText.bearing_arrow_font [self.night_forecast [day_number] .wind_dir]
elif datatype == "WS":
string = self.night_forecast [day_number] .wind_speed
if self.isNumeric (string) == True:
se imperial == Verdadeiro:
string = self.convertKilometresToMiles (string)
string = string + unidade de velocidade
output = output + self.getSpaces (espaços) + string
elif datatype == "WG":
string = self.night_forecast [day_number] .wind_gusts
if self.isNumeric (string) == True:
se imperial == Verdadeiro:
string = self.convertKilometresToMiles (string)
string = string + unidade de velocidade
output = output + self.getSpaces (espaços) + string
elif datatype == "CN":
output = output + self.getSpaces (espaços) + self.night_forecast [day_number] .city
elif datatype == "SR":
output = output + self.getSpaces (espaços) + self.night_forecast [day_number] .sunrise
elif datatype == "SS":
output = output + self.getSpaces (espaços) + self.night_forecast [day_number] .sunset
elif datatype == "MP":
output = output + self.getSpaces (espaços) + self.night_forecast [day_number] .moon_phase
elif datatype == "MF":
output = output + self.getSpaces (espaços) + WeatherText.conditions_moon_font [self.night_forecast [day_number] .moon_icon]
elif datatype == "BR":
output = output + self.getSpaces (espaços) + self.night_forecast [day_number] .bar_read
elif datatype == "BD":
output = output + self.getSpaces (espaços) + self.night_forecast [day_number] .bar_desc
outro:
output = "\ nERRO: Tipo de dados desconhecido solicitado"
quebrar

else: previsão de # dia desejada

para day_number no intervalo (dia de início, dia de término + 1):

se datatype == "DW":
if self.locale == "is":
if shortweekday == Verdadeiro:
output = output + self.getSpaces (espaços) + WeatherText.day_of_week_short_es [self.day_forecast [day_number] .day_of_week]
outro:
output = output + self.getSpaces (espaços) + WeatherText.day_of_week_es [self.day_forecast [day_number] .day_of_week]
elif self.locale == "fr":
if shortweekday == Verdadeiro:
output = output + self.getSpaces (espaços) + WeatherText.day_of_week_short_fr [self.day_forecast [day_number] .day_of_week]
outro:
output = output + self.getSpaces (espaços) + WeatherText.day_of_week_fr [self.day_forecast [day_number] .day_of_week]
outro:
if shortweekday == Verdadeiro:
output = output + self.getSpaces (espaços) + WeatherText.day_of_week_short [self.day_forecast [day_number] .day_of_week]
outro:
output = output + self.getSpaces (espaços) + WeatherText.day_of_week [self.day_forecast [day_number] .day_of_week]
elif datatype == "WF": # fonte meteorológica
output = output + self.getSpaces (espaços) + WeatherText.conditions_weather_font [self.day_forecast [day_number] .condition_code]
elif datatype == "LT":
string = self.day_forecast [day_number] .low
if self.isNumeric (string) == True:
se imperial == Verdadeiro:
string = self.convertCelsiusToFahrenheit (string)
string = string + tempo
output = output + self.getSpaces (espaços) + string
elif datatype == "HT":
string = self.day_forecast [day_number] .high
if self.isNumeric (string) == True:
se imperial == Verdadeiro:
string = self.convertCelsiusToFahrenheit (string)
string = string + tempo
output = output + self.getSpaces (espaços) + string
elif datatype == "CC":
if self.locale == "is":
output = output + self.getSpaces (espaços) + WeatherText.conditions_text_es [self.day_forecast [day_number] .condition_code]
elif self.locale == "fr":
output = output + self.getSpaces (espaços) + WeatherText.conditions_text_fr [self.day_forecast [day_number] .condition_code]
outro:
output = output + self.getSpaces (espaços) + WeatherText.conditions_text [self.day_forecast [day_number] .condition_code]
elif datatype == "CT":
output = output + self.getSpaces (espaços) + self.day_forecast [day_number] .condition_text
elif datatype == "PC":
string = self.day_forecast [day_number] .precip
if self.isNumeric (string) == True:
string = string + u »%»
output = output + self.getSpaces (espaços) + string
elif datatype == "HM":
string = self.day_forecast [day_number] .humidity
if self.isNumeric (string) == True:
string = string + u »%»
output = output + self.getSpaces (espaços) + string
elif datatype == "WD":
string = self.day_forecast [day_number] .wind_dir

if self.locale == "is":
output = output + self.getSpaces (espaços) + WeatherText.bearing_text_es [string]
elif self.locale == "fr":
output = output + self.getSpaces (espaços) + WeatherText.bearing_text_fr [string]
outro:
output = output + self.getSpaces (espaços) + string

elif datatype == "BF":
output = output + self.getSpaces (espaços) + WeatherText.bearing_arrow_font [self.day_forecast [day_number] .wind_dir]
elif datatype == "WS":
string = self.day_forecast [day_number] .wind_speed
if self.isNumeric (string) == True:
se imperial == Verdadeiro:
string = self.convertKilometresToMiles (string)
string = string + unidade de velocidade
output = output + self.getSpaces (espaços) + string
elif datatype == "WG":
string = self.day_forecast [day_number] .wind_gusts
if self.isNumeric (string) == True:
se imperial == Verdadeiro:
string = self.convertKilometresToMiles (string)
string = string + unidade de velocidade
output = output + self.getSpaces (espaços) + string
elif datatype == "CN":
output = output + self.getSpaces (espaços) + self.day_forecast [day_number] .city
elif datatype == "SR":
output = output + self.getSpaces (espaços) + self.day_forecast [day_number] .sunrise
elif datatype == "SS":
output = output + self.getSpaces (espaços) + self.day_forecast [day_number] .sunset
elif datatype == "MP":
output = output + self.getSpaces (espaços) + self.day_forecast [day_number] .moon_phase
elif datatype == "MF":
output = output + self.getSpaces (espaços) + WeatherText.conditions_moon_font [self.day_forecast [day_number] .moon_icon]
elif datatype == "BR":
output = output + self.getSpaces (espaços) + self.day_forecast [day_number] .bar_read
elif datatype == "BD":
output = output + self.getSpaces (espaços) + self.day_forecast [day_number] .bar_desc
outro:
output = u »\ nERRO: Tipo de dados desconhecido solicitado»
quebrar

output = u »» + output.strip (u »«) # perder espaços à esquerda / à direita
saída de retorno

#exceto:
#print "getOutputText: Erro inesperado:", sys.exc_info () [0]

def getOutputTextFromTemplate (self, template):
#tentar:

# chaves para os dados do modelo
DATATYPE_KEY = "–datatype ="
STARTDAY_KEY = "–startday ="
ENDDAY_KEY = "–endday ="
NIGHT_KEY = "–noite"
SHORTWEEKDAY_KEY = "–shortweekday"
IMPERIAL_KEY = "–imperial"
HIDEUNITS_KEY = "–unidades ocultas"
SPACES_KEY = "–spaces ="

output = u »»

opção encontrada = False

# carregue o arquivo
tente:
fileinput = open (self.options.template)
template = fileinput.read ()
fileinput.close ()
exceto:
output = u »Arquivo de modelo não encontrado!»

templatelist = self.getTemplateList (template)

# permite percorrer a lista de modelos e determinar a saída de cada item encontrado
para i no intervalo (0, len (templatelist) -1):

pos = templatelist [i] .find (DATATYPE_KEY)
se pos! = -1:
optionfound = Verdadeiro
pos = pos + len (DATATYPE_KEY)
tipo de dados = templatelist [i] [pos: pos + 4] .strip («}»). strip («{«). strip («-«). strip (»«)
outro:
tipo de dados = Nenhum

pos = templatelist [i] .find (STARTDAY_KEY)
se pos! = -1:
optionfound = Verdadeiro
pos = pos + len (STARTDAY_KEY)
startday = int (templatelist [i] [pos: pos + 4] .strip ("}"). strip ("{"). strip ("-"). strip (""))
outro:
startday = Nenhum

pos = templatelist [i] .find (ENDDAY_KEY)
se pos! = -1:
optionfound = Verdadeiro
pos = pos + len (ENDDAY_KEY)
endday = int (templatelist [i] [pos: pos + 4] .strip ("}"). strip ("{"). strip ("-"). strip (""))
outro:
endday = Nenhum

pos = templatelist [i] .find (NIGHT_KEY)
se pos! = -1:
optionfound = Verdadeiro
noite = verdadeiro
outro:
noite = falso

pos = templatelist [i] .find (SHORTWEEKDAY_KEY)
se pos! = -1:
optionfound = Verdadeiro
dia da semana curto = Verdadeiro
outro:
dia da semana curto = Falso

pos = templatelist [i] .find (IMPERIAL_KEY)
se pos! = -1:
optionfound = Verdadeiro
imperial = verdadeiro
outro:
imperial = falso

pos = templatelist [i] .find (HIDEUNITS_KEY)
se pos! = -1:
optionfound = Verdadeiro
hideunidades = Verdadeiro
outro:
unidades ocultas = Falso

pos = templatelist [i] .find (SPACES_KEY)
se pos! = -1:
optionfound = Verdadeiro
pos = pos + len (SPACES_KEY)
espaços = int (templatelist [i] [pos: pos + 4] .strip («}»). strip («{«). strip («-«). strip (»«))
outro:
espaços = 1

if optionfound == Verdadeiro:
templatelist [i] = self.getOutputText (datatype, startday, endday, night, shortweekday, imperial, hideunits, spaces)
opção encontrada = False

# percorra a lista concatenando a saída agora que ela foi preenchida
para o item no templatelist:
saída = saída + item

saída de retorno

#exceto:
#print "getOutputTextFromTemplate: Erro inesperado:", sys.exc_info () [0]

def fetchData (self):

# sempre busca dados de métricas, usa funções de conversação nesses dados
file_path_current = self.TEMP_FILEPATH_CURRENT.replace ("LOCATION", self.options.location)
file_path_dayforecast = self.TEMP_FILEPATH_DAYFORECAST.replace ("LOCATION", self.options.location)
file_path_nightforecast = self.TEMP_FILEPATH_NIGHTFORECAST.replace ("LOCATION", self.options.location)

if self.isConnectionAvailable () == False:
se os.path.exists (file_path_current):
RefetchData = Falso
else: # sem conexão, sem cache, bang!
print "Não há conexão com a Internet disponível e não existem dados meteorológicos em cache."
elif self.options.refetch == Verdadeiro:
RefetchData = Verdadeiro
outro:
# os dados precisam ser recuperados novamente?
se os.path.exists (file_path_current):
lastmodDate = time.localtime (os.stat (file_path_current) [ST_MTIME])
expiryDate = (datetime.datetime.today () - datetime.timedelta (minutos = self.EXPIRY_MINUTES)).

if expiryDate> lastmodDate:
RefetchData = Verdadeiro
outro:
RefetchData = Falso
outro:
RefetchData = Verdadeiro

# busca os dados das condições atuais, seja no site ou 'retirando'
se RefetchData == Verdadeiro:

# obter dados das condições atuais do serviço xoap
tente:

# 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 & unidade = m '
if self.options.verbose == Verdadeiro:
imprimir >> sys.stdout, «buscando dados meteorológicos de«, url

Usock = urllib2.urlopen (url)
xml = usock.read ()
Usock.close ()
self.weatherxmldoc = minidom.parseString (xml)
exceto:
imprimir "fetchData: Erro inesperado:", sys.exc_info () [0]
imprimir "Incapaz de contactar a fonte meteorológica para as condições actuais"

# diga ao usuário se a localização é ruim ...
found = xml.find ("Local inválido fornecido")
se encontrado! = -1:
imprimir "Local inválido fornecido"

# interrogue os dados meteorológicos, carregue na estrutura da classe e decida
tente:

# preparar listas de dados meteorológicos
self.condições_atual = []
self.day_forecast = []
self.night_forecast = []

# coletar dados gerais
clima_n = self.weatherxmldoc.documentElement
location_n = weather_n.getElementsByTagName ('loc') [0]
city_n = location_n.getElementsByTagName ('dnam') [0]
city ​​= self.getText (city_n.childNodes)

# coletar dados das condições atuais
day_of_week = u »Hoje»
precip = u »N / A»
sunrise_n = location_n.getElementsByTagName ('sunr') [0]
sunrise = self.getText (sunrise_n.childNodes)
sunset_n = location_n.getElementsByTagName ('suns') [0]
sunset = self.getText (sunset_n.childNodes)
current_condition_n = weather_n.getElementsByTagName ('cc') [0]
current_desc_n = current_condition_n.getElementsByTagName ('t') [0]
current_desc = self.getText (current_desc_n.childNodes)
current_code_n = current_condition_n.getElementsByTagName ('ícone') [0]
current_code = self.getText (current_code_n.childNodes)
current_temp_n = current_condition_n.getElementsByTagName ('tmp') [0]
current_temp = self.getText (current_temp_n.childNodes)
current_temp_feels_n = current_condition_n.getElementsByTagName ('flik') [0]
current_temp_feels = self.getText (current_temp_feels_n.childNodes)
bar_n = current_condition_n.getElementsByTagName ('bar') [0]
bar_read_n = bar_n.getElementsByTagName ('r') [0]
bar_read = self.getText (bar_read_n.childNodes)
bar_desc_n = bar_n.getElementsByTagName ('d') [0]
bar_desc = self.getText (bar_desc_n.childNodes)
wind_n = current_condition_n.getElementsByTagName ('wind') [0]
wind_speed_n = wind_n.getElementsByTagName ('s') [0]
wind_speed = self.getText (wind_speed_n.childNodes)
wind_gust_n = wind_n.getElementsByTagName ('rajada') [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)
umidade_n = current_condition_n.getElementsByTagName ('hmid') [0]
umidade = self.getText (umidade_n.childNodes)
moon_n = current_condition_n.getElementsByTagName ('moon') [0]
moon_icon_n = moon_n.getElementsByTagName ('ícone') [0]
moon_icon = self.getText (moon_icon_n.childNodes)
moon_phase_n = moon_n.getElementsByTagName ('t') [0]
moon_phase = self.getText (moon_phase_n.childNodes)
current_conditions_data = WeatherData (day_of_week, current_temp_feels, current_temp, current_code, current_desc, precip, umidade, wind_direction, wind_speed, wind_gusts, city, sunset, moon_phase, moon_icon, bar_read, bar_desc)
self.current_conditions.append (current_conditions_data)

# coleta dados de previsão
bar_read = u »N / A»
bar_desc = u »N / A»
moon_phase = u »N / A»
moon_icon = u »na»
forecast_n = weather_n.getElementsByTagName ('dayf') [0]
day_nodes = forecast_n.getElementsByTagName ('dia')

para dia em day_nodes:
day_of_week = day.getAttribute ('t')
day_of_year = day.getAttribute ('dt')
high_temp_n = day.getElementsByTagName ('hi') [0]
high_temp = self.getText (high_temp_n.childNodes)
low_temp_n = day.getElementsByTagName ('low') [0]
low_temp = self.getText (low_temp_n.childNodes)

sunrise_n = day.getElementsByTagName ('sunr') [0]
sunrise = self.getText (sunrise_n.childNodes)
sunset_n = day.getElementsByTagName ('suns') [0]
sunset = self.getText (sunset_n.childNodes)

Dados específicos da previsão de # dia
daytime_n = day.getElementsByTagName ('part') [0] # dia
condition_code_n = daytime_n.getElementsByTagName ('icon') [0]
condition_code = self.getText (condition_code_n.childNodes)
condição_n = daytime_n.getElementsByTagName ('t') [0]
condição = self.getText (condition_n.childNodes)
precip_n = daytime_n.getElementsByTagName ('ppcp') [0]
precip = self.getText (precip_n.childNodes)
umidade_n = daytime_n.getElementsByTagName ('hmid') [0]
umidade = self.getText (umidade_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 ('rajada') [0]
wind_gusts = self.getText (wind_gusts_n.childNodes)
day_forecast_data = WeatherData (day_of_week, low_temp, high_temp, condition_code, condition, precip, umidade, wind_direction, wind_speed, wind_gusts, city, sunrise, sunset, moon_phase, moon_icon, bar_read, bar_desc)
self.day_forecast.append (day_forecast_data)

Dados específicos de previsão de # noite
daytime_n = day.getElementsByTagName ('part') [1] # noite
condition_code_n = daytime_n.getElementsByTagName ('icon') [0]
condition_code = self.getText (condition_code_n.childNodes)
condição_n = daytime_n.getElementsByTagName ('t') [0]
condição = self.getText (condition_n.childNodes)
precip_n = daytime_n.getElementsByTagName ('ppcp') [0]
precip = self.getText (precip_n.childNodes)
umidade_n = daytime_n.getElementsByTagName ('hmid') [0]
umidade = self.getText (umidade_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 ('rajada') [0]
wind_gusts = self.getText (wind_gusts_n.childNodes)
night_forecast_data = WeatherData (day_of_week, low_temp, high_temp, condition_code, condition, precip, umidade, wind_direction, wind_speed, wind_gusts, city, sunrise, sunset, moon_phase, moon_icon, bar_read, bar_desc)
self.night_forecast.append (night_forecast_data)

# conservar os dados para a próxima vez!
fileoutput = open (file_path_current, 'w')
pickle.dump (self.current_conditions, fileoutput)
fileoutput.close ()

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

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

exceto:
imprimir "fetchData: Erro inesperado:", sys.exc_info () [0]
imprimir "Incapaz de interrogar os dados meteorológicos"

else: # busca dados meteorológicos de arquivos de classe conservados
if self.options.verbose == Verdadeiro:
imprimir >> sys.stdout, «buscando dados meteorológicos do arquivo:«, file_path_current

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

if self.options.verbose == Verdadeiro:
imprimir >> sys.stdout, "buscando dados de previsão do dia de arquivos:", file_path_dayforecast, file_path_nightforecast

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

if self.options.verbose == Verdadeiro:
imprimir >> sys.stdout, «buscando dados de previsão do dia dos arquivos:«, file_path_nightforecast, file_path_nightforecast

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

def outputData (self):
#tentar:

if self.options.template! = Nenhum:

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

outro:

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

imprimir output.encode ("utf-8")

#exceto:
#print «outputData: Erro inesperado:«, sys.exc_info () [0]

if __name__ == "__main__":

parser = CommandLineParser ()
(opções, args) = parser.parse_args ()

if options.verbose == Verdadeiro:
imprimir >> sys.stdout, "local:", opções.local
imprimir >> sys.stdout, "imperial:", options.imperial
imprimir >> sys.stdout, "datatype:", options.datatype
imprimir >> sys.stdout, "night:", options.night
imprimir >> sys.stdout, "start day:", options.startday
imprimir >> sys.stdout, "end day:", options.endday
imprimir >> sys.stdout, "spaces:", options.spaces
imprimir >> sys.stdout, "verbose:", options.verbose
imprimir >> sys.stdout, "refetch:", options.refetch

# criar um novo objeto climático global
clima = GlobalWeather (opções)
weather.fetchData ()
weather.outputData ()

Criamos o arquivo ~ / Conky / scripts / myweather.template

gedit ~ / Conky / scripts / myweather.template

colamos o seguinte dentro:

{–Datatype = DW –startday = 1}: {–datatype = CC –startday = 1}
{–Datatype = HT –startday = 1} / {–datatype = LT –startday = 1} Vento de {–datatype = WD –startday = 1} a {–datatype = WS –startday = 1}
Umidade: {–datatype = HM –startday = 1} Precipitação: {–datatype = PC –startday = 1}
Nascer do sol: {–datatype = SR –startday = 1} Pôr do sol: {–datatype = SS –startday = 1}
———————————————–
{–Datatype = DW –startday = 2}: {–datatype = CC –startday = 2}
{–Datatype = HT –startday = 2} / {–datatype = LT –startday = 2} Vento de {–datatype = WD –startday = 2} a {–datatype = WS –startday = 2}
Umidade: {–datatype = HM –startday = 2} Precipitação: {–datatype = PC –startday = 2}
Nascer do sol: {–datatype = SR –startday = 2} Pôr do sol: {–datatype = SS –startday = 2}
———————————————–
{–Datatype = DW –startday = 3}: {–datatype = CC –startday = 3}
{–Datatype = HT –startday = 3} / {–datatype = LT –startday = 3} Vento de {–datatype = WD –startday = 3} a {–datatype = WS –startday = 3}
Umidade: {–datatype = HM –startday = 3} Precipitação: {–datatype = PC –startday = 3}
Nascer do sol: {–datatype = SR –startday = 3} Pôr do sol: {–datatype = SS –startday = 3}
———————————————–
{–Datatype = DW –startday = 4}: {–datatype = CC –startday = 4}
{–Datatype = HT –startday = 4} / {–datatype = LT –startday = 4} Vento de {–datatype = WD –startday = 4} a {–datatype = WS –startday = 4}
Umidade: {–datatype = HM –startday = 4} Precipitação: {–datatype = PC –startday = 4}
Nascer do sol: {–datatype = SR –startday = 4} Pôr do sol: {–datatype = SS –startday = 4}

Criamos o arquivo ~ / Conky / scripts / mail / conkyEmail.py (devemos criar a pasta de correio)

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

e cole o seguinte dentro:

importar os
importar string

#Insira seu nome de usuário e senha abaixo entre aspas duplas
# por exemplo. nome de usuário = »nome de usuário» e senha = »senha»
nome de usuário = »YOUR_USUARIO_SINARROBA«
senha = »SUA CHAVE«

com = »wget -O - https: //» + nome de usuário + »:» + senha + »@ 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 [índice + 11: índice2])

se fc == 0:
imprimir "0 novo"
outro:
imprimir str (fc) + »novo»

Agora você tem 7 arquivos:

Na pasta: ~
-> .startconky << - torna executável

Na pasta: ~ / Conky
-> conkymain
-> conkyforecast
-> conkymail

e na pasta: ~ / Conky / scripts
-> conkyForecast.py << - tornar executável
-> myweather.template

e na pasta: ~ / Conky / scripts / mail
conkyEmail.py << - tornar executável

E é isso, esclarecimentos, onde está escrito / home / usuário / ... seu nome de usuário vai e na parte para onde vão os dados do Gmail, destaquei em cores onde você tem que colocar seus dados.

para matar o processo conky, escreva para um console

Killall Conky

para executar o conky write em um console

./.startconky

depois de ter tudo ajustado, se você quiser conky para iniciar cada sessão

Sistema—> Preferências—> Sessões e nos programas de inicialização nós o adicionamos

Em Nome podemos escrever Conky, em Order ./.startconky com isso ele iniciará toda vez que você ligar o pc.

É isso, espero que te ajude.


Deixe um comentário

Seu endereço de email não será publicado. Campos obrigatórios são marcados com *

*

*

  1. Responsável pelos dados: Miguel Ángel Gatón
  2. Finalidade dos dados: Controle de SPAM, gerenciamento de comentários.
  3. Legitimação: Seu consentimento
  4. Comunicação de dados: Os dados não serão comunicados a terceiros, exceto por obrigação legal.
  5. Armazenamento de dados: banco de dados hospedado pela Occentus Networks (UE)
  6. Direitos: A qualquer momento você pode limitar, recuperar e excluir suas informações.