Конки, Моя установка

Ubunlog

37 минут

Вчера Fecfactor попросил меня опубликовать конфигурацию conky, которую я показываю на скриншоте ниже.

Как видите, есть 3 conkys, которые выполняются с помощью скрипта, его конфигурация основана на это сообщение опубликовано пользователем Bruce M. на форумах Ubuntu-Ар с некоторыми изменениями в почтовом ящике, который в моем случае предназначен для Gmail.

В справочном посте это очень хорошо объяснено Брюсом, но также как помощь памяти для меня, я собираюсь скопировать шаги, которым нужно следовать, и код моих conkys для тех, у кого он есть.

Ну, конечно, нам нужно установить conky, curl и python, поэтому мы набираем в консоли:

sudo apt-get установить conky curl python

Источник weather.ttf и arrows.ttf здесь. Источник moon.ttf здесь после загрузки вы должны скопировать их в / usr / share / fonts

Давайте теперь создадим наш скрипт под названием ~. / Startconky

gksudo gedit ~ / .startconky

внутри пустого файла вставляем следующий

#! / Bin / Баш
sleep 0 & # 0 хорошо для Xfce - используйте от 20 до 30 для Gnome
conky -c ~ / Конки / conkymain &
#sleep 0 & # 0 хорошо для Xfce - используйте 1 для Gnome
conky -c ~ / Конки / conkyforecast &
#sleep 0 & # 0 хорошо для Xfce - используйте 1 для Gnome
conky -c ~ / Conky / conkymail &

Теперь мы создаем файл conkymain в папке ~ / Conky, если у нас нет папки Conky, нам придется ее создать.

gedit ~ / Conky / conkymain

Я использую шрифт Calibri, если у вас его нет, замените на то, что хотите.

Мы придерживаемся следующего

фон нет
own_window да
own_window_transparent да
own_window_hints без декорирования, ниже, липкий, skip_taskbar, skip_pager
own_window_colour черный
double_buffer да
use_spacer слева
use_xft да
калибр шрифта: размер = 9
xftfont calibri: размер = 9
ксфтальфа 0.5
Update_Interval 5.0
uppercase no # установите значение yes, если вы хотите, чтобы весь текст был в верхнем регистре
stippled_border 3
граница_маргин 9
граница_ширина 10
default_color белый
default_outline_color черный
default_shade_color черный
цвет0 голубой
color1 светло-голубой
color2 оранжевый
color3 желтый
цвет4 пшеница
color5 белый
color6 белый
color7 белый
color8 белый
color9 белый
выравнивание top_right # или top_left, bottom_left, bottom_right
зазор_x 10
зазор_у 35
text_buffer_size 128 # использовать 1024 для прогноза
no_buffers yes # Вычесть буферы файловой системы из используемой памяти?
draw_borders нет
draw_outline yes # усиливает текст, если да
draw_shades yes # shadecolor черный

ТЕКСТ
$ {font calibri: size = 12} $ {alignc} $ {color1} $ sysname $ kernel на $ machine} $ color $ font
$ {font calibri: size = 12} $ {alignc} $ {color2} $ {exec whoami} @ $ nodename $ color $ font
$ {color0} $ {hr 1} $ color
$ {font calibri: size = 20} $ {alignc} $ {time% H:% M} $ font
$ {font calibri: size = 12} $ {color1} $ {alignc} $ {time% A,% d% b. % Y} $ color $ шрифт
$ {color3} UpTime: $ {alignr 2} $ uptime $ color
$ {color0} $ {hr 1} $ color
$ {voffset 5} $ {color2} ЦП: $ {alignc} $ color $ running_processes $ {color1} / $ color $ процессов $ {alignr 2} $ {color2} $ {cpubar cpu0 14,80} $ color
$ {color1} $ {voffset -16} $ {alignr 5} $ cpu% $ color
$ {voffset 2} $ {color1} Средняя загрузка ($ {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} $ {mbar 14,80} $ color
$ {color1} $ {voffset -16} $ {alignr 5} $ memperc% $ color
$ {voffset 2} $ {color1} Буферизованный: $ color $ {buffers} $ {alignr 2} $ {color1} Кэшированный: $ 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 Бесплатно $ {color1} - Использовано - $ {color2} Итого
$ {voffset 5} $ {color1} Корень: $ color $ {fs_free_perc /}% $ {alignr 2} $ {fs_free /} $ {color2} / $ {color1} $ {fs_used /} $ color / $ {color2} $ {fs_size /} $ цвет
$ {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} От: $ color Буэнос-Айрес, Аргентина
$ {color1} Широта: $ {color2} 34 ° 35'S $ {color1} Долгая: $ {color2} 58 ° 21'W $ {color1} Alt: $ {color2} 25 m $ color
$ {voffset 5} $ {color2} $ {font calibri: size = 12} сегодня: $ font $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = CC} $ color $ {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 $ шрифт
$ {alignc 10} $ {voffset 5} $ {color4} Wind: $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = WS} $ color
$ {color1} Влажность: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = HM} $ {alignr 2} $ {color1} Осадки: $ {color3} $ { execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = PC} $ color
$ {alignc} $ {color1} Давление: $ {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} $ цвет
$ {color1} Восход солнца: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = SR} $ {alignr 2} $ {color1} Sunset: $ {color3} $ { execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = SS} $ color
$ {voffset 15} $ {color1} Moon: $ {color4} $ {alignr 2} $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = MP} $ color
$ {voffset -20} $ {offset 80} $ {color4} $ {font фазы луны: size = 20} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = MF} $ font $ цвет
$ {color0} $ {hr} $ цвет
$ {voffset 5} $ {color2} IP: $ {alignc} $ color $ {addr eth0}
$ {color1} Вниз: $ color $ {downspeed eth0} k / s $ {alignr 2} $ {color1} Up: $ color $ {upspeed eth0} k / s
$ {color1} Итого: $ color $ {totaldown eth0} $ {alignr 2} $ {color1} Итого: $ color $ {totalup eth0}
$ {color1} Входящий: $ color $ {tcp_portmon 1 32767 count} $ {color1} Исходящий: $ color $ {tcp_portmon 32768 61000 count} $ {alignr 2} $ {color1} Итого: $ color $ {tcp_portmon 1 65535 count}
$ {voffset 5} $ {color2} Подключения: $ color $ {tcp_portmon 32768 61000 count} $ {alignr 2} $ {color2} Service / Port $ color
$ {voffset 5} $ {tcp_portmon 32768 61000 rhost 0} $ {alignr 2} $ {tcp_portmon 32768 61000 rservice 0}
$ {tcp_portmon 32768 61000 rhost 1} $ {alignr 2} $ {tcp_portmon 32768 61000 rservice 1}
$ {tcp_portmon 32768 61000 rhost 2} $ {alignr 2} $ {tcp_portmon 32768 61000 rservice 2}
$ {tcp_portmon 32768 61000 rhost 3} $ {alignr 2} $ {tcp_portmon 32768 61000 rservice 3}
$ {tcp_portmon 32768 61000 rhost 4} $ {alignr 2} $ {tcp_portmon 32768 61000 rservice 4}
$ {tcp_portmon 32768 61000 rhost 5} $ {alignr 2} $ {tcp_portmon 32768 61000 rservice 5} $ color

создаем файл ~ / Conky / conkyforecast

gedit ~ / Conky / conkyforecast

и вставляем внутрь

фон нет
own_window да
own_window_transparent да
own_window_hints без декорирования, ниже, липкий, skip_taskbar, skip_pager
own_window_colour черный
double_buffer да
use_spacer слева
use_xft да
калибр шрифта: размер = 8
xftfont calibri: размер = 8
ксфтальфа 0.5
Update_Interval 5.0
uppercase no # установите значение yes, если вы хотите, чтобы весь текст был в верхнем регистре
stippled_border 3
граница_маргин 9
граница_ширина 10
default_color белый
default_outline_color черный
default_shade_color черный
цвет0 голубой
color1 светло-голубой
color2 оранжевый
color3 желтый
цвет4 пшеница
color5 белый
color6 белый
color7 белый
color8 белый
color9 белый
выравнивание bottom_left # или top_left, bottom_left, bottom_right
зазор_x 10
зазор_у 35
text_buffer_size 1024 # использовать 1024 для прогноза
no_buffers yes # Вычесть буферы файловой системы из используемой памяти?
draw_borders нет
draw_outline yes # усиливает текст, если да
draw_shades yes # shadecolor черный

ТЕКСТ
$ {color4} $ {font calibri: size = 11} Расширенный прогноз $ font $ color
$ {color0} $ {hr} $ цвет
$ {color4} $ {font calibri: size = 9} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –template = / home / user / Conky / scripts / myweather.template} $ font $ цвет

создаем файл ~ / Conky / conkymail

gedit ~ / Conky / conkymail

вставляем в файл следующее

фон нет
own_window да
own_window_transparent да
own_window_hints без декорирования, ниже, липкий, skip_taskbar, skip_pager
own_window_colour черный
double_buffer да
use_spacer слева
use_xft да
калибр шрифта: размер = 8
xftfont calibri: размер = 8
ксфтальфа 0.5
Update_Interval 5.0
uppercase no # установите значение yes, если вы хотите, чтобы весь текст был в верхнем регистре
stippled_border 3
граница_маргин 9
граница_ширина 10
default_color белый
default_outline_color черный
default_shade_color черный
цвет0 голубой
color1 светло-голубой
color2 оранжевый
color3 желтый
цвет4 пшеница
color5 белый
color6 белый
color7 белый
color8 белый
color9 белый
выравнивание bottom_left # или top_left, bottom_left, bottom_right
зазор_x 565
зазор_у 35
text_buffer_size 128 # использовать 1024 для прогноза
no_buffers yes # Вычесть буферы файловой системы из используемой памяти?
draw_borders нет
draw_outline yes # усиливает текст, если да
draw_shades yes # shadecolor черный

ТЕКСТ
$ {font calibri: size = 11} $ {alignc} $ {color4} Gmail
$ {color0} $ {hr} $ цвет
$ {font calibri: size = 11} $ {color4} У нас есть $ {color3} $ {execi 300 python ~ / Conky / scripts / mail / conkyEmail.py} $ {color4} email (s) $ font

Создаем файл в ~ / Conky / scripts / conkyForecast.py (мы должны создать папку скриптов)

gedit ~ / Конки / скрипты / conkyForecast.py

#! / usr / bin / python
# - * - кодировка: utf-8 - * -
########################################################################## ############################
# conkyForecast.py - это (уже не такой) простой (уже) скрипт Python для сбора
# детали текущей погоды для использования в conky.
#
# Автор: Kaivalagi
# Создано: 13
# Модификации:
# 14 Разрешить дневные диапазоны для данных прогноза
# 14 Проверка подключения к сервису xoap
# 18 Разрешить установку пробелов для дальнего вывода
# 18 Разрешить вывод прогноза "День и ночь".
# 18 Поддержка локали для текста кода условия с опцией «CC», ожидается перевод на испанский язык
# 18 Используйте маринование для данных класса вместо открытия xml, это избавляет от необходимости запрашивать кэшированные данные
# 19 Добавлен текст условия на испанском языке - Спасибо, Брюс М.
# 19 Добавлена ​​проверка isnume для всего числового вывода с суффиксом единиц.
# 19 Изменено название файла pickle с добавлением кода местоположения.
# 19 Добавлена ​​конвертация дней недели для испанского языка через локаль.
# 20 Добавлен неплохой парсер аргументов команд
# 20 Добавлен параметр –shortweekday, если задан тип данных дня недели, сокращенный до 04 символов
# 21 Исправлены языковые настройки для вывода прогнозов
# 21 Добавлена ​​опция –template, позволяющая настраивать вывод с помощью одного вызова exec 🙂
# 21 Добавлена ​​опция –hideunits для удаления, например, mph и C из вывода
# 23 Удалена опция –imperial из шаблона, она ДОЛЖНА быть установлена ​​как стандартная опция при вызове скрипта и не использоваться в файле шаблона.
# 23 Считываемая опция –имперская система в шаблоне, позволяющая вводить метрические или британские значения для каждого типа данных. Учтите, что при использовании шаблонов опция командной строки работать не будет.
# 23 Добавлен вывод, уведомляющий пользователя, если указана неверная локация.
# 24 Добавлена ​​обработка отсутствия связи, теперь данные будут кэшированы (ошибка, если кеша нет). Тесты при попытке открыть xoap.weather.com
# 24 Исправлено преобразование градусов Цельсия в Фаренгейт.
# 06 Обновленный URL-адрес, использованный после обновления веб-сервиса
# 09 Получение сводных данных о текущем состоянии и прогнозе в один звонок
# 09 В типы данных добавлены восход и закат, они относятся как к текущим условиям, так и к данным прогноза.
# 09 Добавлены фаза луны, показания барометра и описание барометра к типам данных, они относятся только к текущим условиям и поэтому не присутствуют в прогнозируемых выходных данных.
# 09 Добавлен перевод единиц измерения барометра из мб в дюймы (имперские).
# 09 Обновлен текст условия на испанском языке - Спасибо, Брюс М.
# 10 Добавлены данные о французском языке - Спасибо, benpaka
# 12/05/2008 Добавлен новый тип данных BF (шрифт подшипника) для предоставления символа стрелки (используется со шрифтом Arrow.ttf) вместо вывода NSEW из WD (направление ветра).
# 12/05/2008 Обновлен вывод WD с учетом локали, в настоящее время по умолчанию поддерживаются английский и испанский - Спасибо, Брюс М.
# 18 Добавлен новый тип данных MF (шрифт луны) для обозначения символа шрифта луны (символы некорректны и выделенного шрифта пока нет).
# 21 Для текущих условий опция –datatype = LT теперь отображает температуру «по ощущениям», а не текущую температуру.
#
# ВСЕ:
# Объединить файлы pkl в один файл / класс
# Добавить шрифт погоды на основе вывода фазы луны на основе данных значка луны
# ??? Есть еще какие-то требования?

импортировать sys, os, socket, urllib2, datetime, time
из xml.dom import minidom
из импорта статистики *
из optparse import OptionParser
импортировать локаль
импортировать gettext
импортный рассол
из математического импорта *

APP = »conkyForecast.py»
DIR = os.path.dirname (__file__) + '/ locale'
gettext.bindtextdomain (APP, DIR)
gettext.textdomain (приложение)
_ = получитьтекст.получитьтекст

класс CommandLineParser:

parser = Нет

def __init __ (сам):

self.parser = OptionParser ()
self.parser.add_option («- l», »- location», dest = »location», default = »UKXX0103 ″, type =» string », metavar =» CODE », help = u» код местоположения для данных о погоде [ default:% default]. Используйте следующий URL, чтобы определить код вашего местоположения по названию города: http://xoap.weather.com/search/search?where=Norwich »)
self.parser.add_option ("- d", "- datatype", dest = "datatype", default = "HT", type = "string", metavar = "DATATYPE", help = u "[по умолчанию:% default] Возможны следующие типы данных: DW (день недели), WF (вывод погодных шрифтов), LT (прогноз: низкая температура, ток: по ощущениям температуры), HT (прогноз: высокая температура, ток: текущая температура), CC (Текущая температура). Условия), CT (текст условий), PC (вероятность осадков), HM (влажность), WD (направление ветра), WS (скорость ветра), WG (порывы ветра), CN (название города), SR (восход солнца), SS (закат), MP (фаза луны), MF (шрифт луны), BR (показание барометра), BD (описание барометра). Неприменимо в командной строке при использовании шаблонов. »)
self.parser.add_option («- s», »- startday», dest = »startday», type = »int», metavar = »NUMBER», help = u »определить номер начального дня, если не указано, выводятся текущие условия . Неприменимо в командной строке при использовании шаблонов. »)
self.parser.add_option ("- e", "- endday", dest = "endday", type = "int", metavar = "NUMBER", help = u "определяет номер конечного дня, если опущен, только данные начального дня выводится. Неприменимо в командной строке при использовании шаблонов. »)
self.parser.add_option («- S», »- пробелы», dest = »пробелы», type = »int», default = 1, metavar = »NUMBER», help = u »[default:% default] Определяет количество пробелов между ранжированным выводом. Неприменимо в командной строке при использовании шаблонов. »)
self.parser.add_option («- t», »- template», dest = »template», type = »string», metavar = »FILE», help = u »определяет файл шаблона для генерации вывода за один вызов. A отображаемый элемент в файле имеет форму {–datatype = HT –startday = 1}. Для каждого элемента возможны следующие варианты: –datatype, –startday, –endday, –night, –shortweekday, –imperial, –hideunits, –Spaces. Обратите внимание, что краткие формы параметров в настоящее время не поддерживаются! Ни один из этих параметров не применяется в командной строке при использовании шаблонов. »)
self.parser.add_option («- L», »- locale», dest = »locale», type = »string», help = u »переопределить системный языковой стандарт для языкового вывода (en = english, es = spanish, fr = французский, еще впереди) »)
self.parser.add_option ("- i", "- imperial", dest = "imperial", default = False, action = "store_true", help = u "запрашивает имперские единицы измерения, если опущено, вывод в метрической системе. командная строка при использовании шаблонов. »)
self.parser.add_option («- n», »- night», dest = »night», default = False, action = »store_true», help = u »переключить вывод на ночные данные, если не указано, выводится дневной вывод. Неприменимо в командной строке при использовании шаблонов. »)
self.parser.add_option («- w», »- shortweekday», dest = »shortweekday», default = False, action = »store_true», help = u »Сократить тип данных дня недели до 3 символов. Неприменимо в командная строка при использовании шаблонов. »)
self.parser.add_option («- u», »- hideunits», dest = »hideunits», default = False, action = »store_true», help = u »Скрыть единицы измерения, такие как миль / ч или C, символы градуса (°) все еще отображается. Неприменимо в командной строке при использовании шаблонов. »)
self.parser.add_option ("- v", "- verbose", dest = "verbose", default = False, action = "store_true", help = u "запрашивать подробный вывод, плохая идея при запуске через conky!" )
self.parser.add_option ("- r", "- refetch", dest = "refetch", default = False, action = "store_true", help = u "получать данные независимо от истечения срока действия данных")

def parse_args (сам):
(параметры, аргументы) = self.parser.parse_args ()
возврат (параметры, аргументы)

def print_help (сам):
вернуть self.parser.print_help ()

класс WeatherData:
def __init __ (self, day_of_week, low, high, condition_code, condition_text, dry, wind_dir, wind_speed, wind_gusts, city, sunrise, sunset, moon_phase, moon_icon, bar_read, bar_desc):
self.day_of_week = u »» + day_of_week
self.low = u »» + low
self.high = u »» + высокий
self.condition_code = u »» + condition_code
self.condition_text = u »» + condition_text
self.precip = u »» + осадки
self.humidity = u »» + влажность
self.wind_dir = u »» + wind_dir
self.wind_speed = u »» + wind_speed
self.wind_gusts = u »» + wind_gusts
self.city = u »» + город
self.sunrise = u »» + восход
self.sunset = u »» + закат
self.moon_phase = u »» + moon_phase
self.moon_icon = u »» + moon_icon
self.bar_read = u »» + bar_read
self.bar_desc = u »» + bar_desc

класс WeatherText:

условия_текст = {
«0»: _ (u »Торнадо»),
«1»: _ (u »Тропический шторм»),
«2»: _ (u »Ураган»),
«3»: _ (u «Сильная гроза»),
«4»: _ (u »Грозы»),
«5»: _ (u »Смешанный дождь и снег»),
«6»: _ (u »Смешанный дождь и мокрый снег»),
«7»: _ (u »Смешанные осадки»),
«8»: _ (u »Леденящая морось»),
«9»: _ (u »Морось»),
«10»: _ (u »Ледяной дождь»),
«11»: _ (u »душевые»),
«12»: _ (u »душевые»),
«13»: _ (u »снежные бури»),
«14»: _ (u »слабый снегопад»),
«15»: _ (u »метель»),
«16»: _ (u »Снег»),
«17»: _ (u »Славься»),
«18»: _ (u »Sleet»),
«19»: _ (u »Пыль»),
«20»: _ (у »туман»),
«21»: _ (u »Haze»),
«22»: _ (u »Smoke»),
«23»: _ (u »Blustery»),
«24»: _ (u »Винди»),
«25»: _ (u »Холодный»),
«26»: _ (u »пасмурно»),
«27»: _ (u «Облачно»),
«28»: _ (u «Облачно»),
«29»: _ (u »переменная облачность»),
«30»: _ (u »переменная облачность»),
«31»: _ (u »Очистить»),
«32»: _ (u »Очистить»),
«33»: _ (u »Ярмарка»),
«34»: _ (u »Ярмарка»),
«35»: _ (u »Смешанный дождь и град»),
«36»: _ (u »Hot»),
«37»: _ (u »Изолированные грозы»),
«38»: _ (u »Разрозненные грозы»),
«39»: _ (u »Разрозненные грозы»),
«40»: _ (u »Рассеянные ливни»),
«41»: _ (u »Heavy Snow»),
«42»: _ (u »Снежный дождь»),
«43»: _ (u »Heavy Snow»),
«44»: _ (u »переменная облачность»),
«45»: _ (u »Грозовые ливни»),
«46»: _ (u »Снежный дождь»),
«47»: _ (u »Изолированные грозы»),
«Na»: _ (u »N / A»),
"-": _ (а ")
}

условия_текст_es = {
«0»: _ (u »Торнадо»),
«1»: _ (u »Тропический шторм»),
«2»: _ (u »Huracá¡n»),
«3»: _ (u »Сильные штормы»),
«4»: _ (u »Штормы»),
«5»: _ (u »Смешанный дождь и снег»),
«6»: _ (u »Смешанный дождь и мокрый снег»),
«7»: _ (u »Sleet»),
«8»: _ (u »Леденящая морось»),
«9»: _ (u »Морось»),
«10»: _ (u »ледяной дождь»), # или ледяной дождь
«11»: _ (u »душевые»),
«12»: _ (u »душевые»),
«13»: _ (u »Легкий снег»),
«14»: _ (u »Легкий снег»),
«15»: _ (u »Снежная метель»),
«16»: _ (u »Снег»),
«17»: _ (u »Славься»),
«18»: _ (u »Sleet»),
«19»: _ (u »Пудра»),
«20»: _ (у »туман»),
«21»: _ (u »Haze»),
«22»: _ (u »Smoke»),
«23»: _ (u »Буря»),
«24»: _ (u »Винди»),
«25»: _ (u »Fráo»),
«26»: _ (u »очень облачно»),
«27»: _ (u «Облачно»),
«28»: _ (u «Облачно»),
«29»: _ (u »переменная облачность»),
«30»: _ (u »переменная облачность»),
«31»: _ (u »Очистить»),
«32»: _ (u »Очистить»),
«33»: _ (u »Облачно»),
«34»: _ (u »Облачно»),
«35»: _ (u «Дождь с градом»),
«36»: _ (u »Жара»),
«37»: _ (u »Изолированные бури»),
«38»: _ (u »Рассеянные бури»),
«39»: _ (u »Рассеянные бури»),
«40»: _ (u »Рассеянные ливни»),
«41»: _ (u »Heavy Snow»),
«42»: _ (u «Слабые и рассеянные снегопады»),
«43»: _ (u »Intense Nevada»),
«44»: _ (u »Рассеянные облака»),
«45»: _ (u »Штормы»),
«46»: _ (u »Рассеянные снегопады»),
«47»: _ (u »Изолированные бури»),
«Na»: _ (u »N / A»),
"-": _ (а ")
}

условия_текст_fr = {
«0»: _ (u »Tornade»),
«1»: _ (u »Tempête Tropicale»),
«2»: _ (или »Ураган»),
«3»: _ (или »Orages Violents»),
«4»: _ (или »Orageux»),
«5»: _ (u »Pluie et Neige»),
«6»: _ (u »Pluie et Neige Mouillée»),
«7»: _ (u »переменная avec averses»),
«8»: _ (u »Bruine Givrante»),
«9»: _ (u »Bruine»),
«10»: _ (u »Pluie Glacante»),
«11»: _ (u »отвергает»),
«12»: _ (u »отвергает»),
«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 »Бруйяр»),
«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»: _ (или »Orages Isolés»),
«38»: _ (или »Orages Localisés»),
«39»: _ (или »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»: _ (или »Орейдж»),
«46»: _ (u »Tempête de Neige»),
«47»: _ (или »Orages Isolés»),
«Na»: _ (u »N / A»),
"-": _ (а ")
}

условия_погоды_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 »»),
"-": _(или же"")
}

условия_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 »»),
"-": _(или же"")
}

день_недели = {
«Сегодня»: _ (или «Сегодня»),
«Понедельник»: _ (u »Понедельник»),
«Вторник»: _ (u «Вторник»),
«Среда»: _ (u «Среда»),
«Четверг»: _ (u «Четверг»),
«Пятница»: _ (u «Пятница»),
«Суббота»: _ (u «Суббота»),
«Воскресенье»: _ (u «Воскресенье»)
}

day_of_week_short = {
«Сегодня»: _ (u «Сейчас»),
«Понедельник»: _ (u »пн»),
«Вторник»: _ (u »Вт»),
«Среда»: _ (u »ср»),
«Четверг»: _ (у »чт»),
«Пятница»: _ (u »пт»),
«Суббота»: _ (u «Сб»),
«Воскресенье»: _ (u «Солнце»)
}

day_of_week_en = {
«Сегодня»: _ (u «сегодня»),
«Понедельник»: _ (u «Понедельник»),
«Вторник»: _ (или »вторник»),
«Среда»: _ (u «Среда»),
«Четверг»: _ (u «Четверг»),
«Пятница»: _ (u «Пятница»),
«Суббота»: _ (u «Суббота»),
«Воскресенье»: _ (u «Воскресенье»)
}

day_of_week_short_en = {
«Сегодня»: _ (u «сегодня»),
«Понедельник»: _ (u «пн»),
«Вторник»: _ (у »море»),
«Среда»: _ (u »ср»),
«Четверг»: _ (u »чт»),
«Пятница»: _ (u «пт»),
«Суббота»: _ (u «сидел»),
«Воскресенье»: _ (u «дом»)
}

day_of_week_fr = {
«Сегодня»: _ (u »Aujourd'hui»),
«Понедельник»: _ (у »Лунди»),
«Вторник»: _ (у »Марди»),
«Среда»: _ (u »Mercredi»),
«Четверг»: _ (u »Jeudi»),
«Пятница»: _ (у »Вендреди»),
«Суббота»: _ (у «Самеди»),
«Воскресенье»: _ (u «Диманче»)
}

day_of_week_short_fr = {
«Сегодня»: _ (u »Auj»),
«Понедельник»: _ (u «Пн»),
«Вторник»: _ (u »мар»),
«Среда»: _ (у «Мер»),
«Четверг»: _ (u »Jeu»),
«Пятница»: _ (u »приходи»),
«Суббота»: _ (u «Сэм»),
«Воскресенье»: _ (u «Тусклый»)
}

Bear_arrow_font = {
«N»: _ (u »i»),
«NNE»: _ (u »j»),
«NE»: _ (u »k»),
«ВСЭ»: _ (у »л»),
«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"),
«СЗ»: _ (u »g»),
«ССЗ»: _ (u »h»),
«Н / Д»: _ (u »«)
}

Bear_text_es = {
«N»: _ (u »N»),
«NNE»: _ (u »NNE»),
«NE»: _ (u »NE»),
«ВСВ»: _ (у »ВСЭ»),
«E»: _ (u »E»),
«ESE»: _ (u »ESE»),
«SE»: _ (u »SE»),
"SSE": _ (u "SSE"),
"Их"),
"SSW": _ (u "SSO"),
«SW»: _ (u »SO»),
"WSW": _ (u "ВАУ"),
«W»: _ (u »O»),
«WNW»: _ (u »ONO»),
«NW»: _ (u »NO»),
«СЗЗ»: _ (у »ННО»),
«N / A»: _ (u »N \ A»)
}

Bear_text_fr = {
«N»: _ (u »N»),
«NNE»: _ (u »NNE»),
«NE»: _ (u »NE»),
«ВСВ»: _ (у »ВСЭ»),
«E»: _ (u »E»),
«ESE»: _ (u »ESE»),
«SE»: _ (u »SE»),
"SSE": _ (u "SSE"),
"Их"),
"SSW": _ (u "SSO"),
«SW»: _ (u »SO»),
"WSW": _ (u "ВАУ"),
«W»: _ (u »O»),
«WNW»: _ (u »ONO»),
«NW»: _ (u »NO»),
«СЗЗ»: _ (у »ННО»),
«N / A»: _ (u »N \ A»)
}

класс GlobalWeather:

текущие_условия = []
день_прогноз = []
ночной_прогноз = []

locale = "в"

options = Нет
погодаxmldoc = «»

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.locale == None:
попробовать:
# self.locale = locale.getdefaultlocale () [0] [0: 2]
self.locale = «es» # раскомментируйте эту строку, чтобы заставить испанский язык
# self.locale = "fr" # раскомментируйте эту строку, чтобы принудительно использовать французский язык
Кроме:
напечатать "языковой стандарт не установлен"
еще:
# self.locale = self.options.locale
self.locale = «es» # раскомментируйте эту строку, чтобы заставить испанский язык
# self.locale = "fr" # раскомментируйте эту строку, чтобы принудительно использовать французский язык

если self.options.verbose == True:
print >> sys.stdout, "locale set to", self.locale

def getText (self, список узлов):
рс = «»
для узла в нодлисте:
если node.nodeType == node.TEXT_NODE:
rc = rc + node.data
вернуть rc

def getSpaces (self, пробелы):
строка = u »»
если пробелы == Нет:
строка = self.DEFAULT_SPACING
еще:
для i в диапазоне (0, пробелы + 1):
строка = строка + u »«
строка возврата

def isNumeric (self, строка):
попробовать:
dummy = float (строка)
вернуть True
Кроме:
вернуть ложь

def isConnectionAvailable (сам):
# убедитесь, что мы можем получить доступ к серверу weather.com, открыв URL
попробовать:
Usock = urllib2.urlopen ('http://xoap.weather.com')
Usock.close ()
вернуть True
Кроме:
вернуть ложь

def getBearingText (себя, подшипник):
подшипник = поплавок (подшипник)
если подшипник <11.25:
вернуть u »N»
подшипник elif <33.75:
return u »NNE»
подшипник elif <56.25:
вернуть u »NE»
подшипник elif <78.75:
вернуть u »ЯНВАРЬ»
подшипник elif <101.25:
вернуть u »E»
подшипник elif <123.75:
return u »ESE»
подшипник elif <146.25:
вернуть u »SE»
подшипник elif <168.75:
вернуть u »SSE»
подшипник elif <191.25:
вернуть u »S»
подшипник elif <213.75:
вернуть u »SSW»
подшипник elif <236.25:
вернуть u »SW»
подшипник elif <258.75:
return u »WSW»
подшипник elif <281.25:
вернуть u »W»
подшипник elif <303.75:
return u »WNW»
подшипник elif <326.25:
return u »NW»
подшипник elif <348.75:
return u »NNW»
еще:
вернуть «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 (этаж (float (mb) /33.8582)))

def getTemplateList (сам, шаблон):

список шаблонов = []

для template_part в template.split («{«):
если template_part! = «»:
для template_part в template_part.split ("}"):
если template_part! = «»:
templatelist.append (u »» + template_part)

список шаблонов возврата

def getOutputText (self, datatype, startday, endday, night, shortweekday, imperial, hideunits, пробелы):
#пытаться:
output = u »»

# определить текущие единицы для вывода
если hideunits == False:
если имперская система == False:
tempunit = u »° C»
speedunit = u »км / ч»
Единица давления = u »mb»
еще:
tempunit = u »° F»
speedunit = u »миль / ч»
pressureunit = u »дюйм»
еще:
tempunit = u »°»
speedunit = u »»
pressureunit = u »»

if startday == None: # текущие условия

если тип данных == "DW":
если self.locale == "is":
если shortweekday == True:
output = WeatherText.day_of_week_short_es [self.current_conditions [0] .day_of_week]
еще:
output = WeatherText.day_of_week_es [self.current_conditions [0] .day_of_week]
elif self.locale == "fr":
если shortweekday == True:
output = WeatherText.day_of_week_short_fr [self.current_conditions [0] .day_of_week]
еще:
output = WeatherText.day_of_week_fr [self.current_conditions [0] .day_of_week]
еще:
если shortweekday == True:
output = WeatherText.day_of_week_short [self.current_conditions [0] .day_of_week]
еще:
output = WeatherText.day_of_week [self.current_conditions [0] .day_of_week]
elif datatype == "WF": # погодный шрифт
output = WeatherText.conditions_weather_font [self.current_conditions [0] .condition_code]
elif datatype == "LT":
строка = self.current_conditions [0] .low
если self.isNumeric (string) == True:
если имперский == Истина:
строка = self.convertCelsiusToFahrenheit (строка)
строка = строка + временная единица
output = строка
elif datatype == "HT":
строка = self.current_conditions [0] .high
если self.isNumeric (string) == True:
если имперский == Истина:
строка = self.convertCelsiusToFahrenheit (строка)
строка = строка + временная единица
output = строка
elif datatype == "CC":
если 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]
еще:
output = WeatherText.conditions_text [self.current_conditions [0] .condition_code]
elif datatype == "CT":
output = self.current_conditions [0] .condition_text
elif datatype == "ПК":
строка = self.current_conditions [0] .precip
если self.isNumeric (string) == True:
строка = строка + u »%»
output = строка
elif datatype == "HM":
строка = self.current_conditions [0]. влажность
если self.isNumeric (string) == True:
строка = строка + u »%»
output = строка
elif datatype == "WD":
строка = self.current_conditions [0] .wind_dir
если self.isNumeric (string) == True:
строка = self.getBearingText (строка)

если self.locale == "is":
output = WeatherText.bearing_text_es [строка]
elif self.locale == "fr":
output = WeatherText.bearing_text_fr [строка]
еще:
output = строка

elif datatype == "BF":
строка = self.current_conditions [0] .wind_dir
если self.isNumeric (string) == True:
строка = WeatherText.bearing_arrow_font [self.getBearingText (строка)]
output = строка
elif datatype == "WS":
строка = self.current_conditions [0] .wind_speed
если self.isNumeric (string) == True:
если имперский == Истина:
строка = self.convertKilometresToMiles (строка)
строка = строка + скорость
output = строка
elif datatype == "WG":
строка = self.current_conditions [0] .wind_gusts
если self.isNumeric (string) == True:
если имперский == Истина:
строка = self.convertKilometresToMiles (строка)
строка = строка + скорость
output = строка
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":
строка = self.current_conditions [0] .bar_read
если self.isNumeric (string) == True:
если имперский == Истина:
строка = self.convertMillibarsToInches (строка)
строка = строка + единица давления
output = строка
elif datatype == "BD":
output = self.current_conditions [0] .bar_desc
еще:
output = "\ nОШИБКА: запрошен неизвестный тип данных"

else: # данные прогноза

if endday == None: # если конечный день не был установлен, используйте startday
endday = день начала

if night == True: требуется # ночной прогноз

для day_number в диапазоне (startday, endday + 1):

если тип данных == "DW":
если self.locale == "is":
если shortweekday == True:
output = output + self.getSpaces (пробелы) + WeatherText.day_of_week_short_es [self.night_forecast [day_number] .day_of_week]
еще:
output = output + self.getSpaces (пробелы) + WeatherText.day_of_week_es [self.night_forecast [day_number] .day_of_week]
elif self.locale == "fr":
если shortweekday == True:
output = output + self.getSpaces (пробелы) + WeatherText.day_of_week_short_fr [self.night_forecast [day_number] .day_of_week]
еще:
output = output + self.getSpaces (пробелы) + WeatherText.day_of_week_fr [self.night_forecast [day_number] .day_of_week]
еще:
если shortweekday == True:
output = output + self.getSpaces (пробелы) + WeatherText.day_of_week_short [self.night_forecast [day_number] .day_of_week]
еще:
output = output + self.getSpaces (пробелы) + WeatherText.day_of_week [self.night_forecast [day_number] .day_of_week]
elif datatype == "WF": # погодный шрифт
output = output + self.getSpaces (пробелы) + WeatherText.conditions_weather_font [self.night_forecast [номер_дня]. код_условия]
elif datatype == "LT":
строка = self.night_forecast [номер_дня] .low
если self.isNumeric (string) == True:
если имперский == Истина:
строка = self.convertCelsiusToFahrenheit (строка)
строка = строка + временная единица
output = output + self.getSpaces (пробелы) + строка

elif datatype == "HT":
string = self.night_forecast [номер_дня] .high
если self.isNumeric (string) == True:
если имперский == Истина:
строка = self.convertCelsiusToFahrenheit (строка)
строка = строка + временная единица
output = output + self.getSpaces (пробелы) + строка
elif datatype == "CC":
если self.locale == "is":
output = output + self.getSpaces (пробелы) + WeatherText.conditions_text_es [self.night_forecast [day_number] .condition_code]
elif self.locale == "fr":
output = output + self.getSpaces (пробелы) + WeatherText.conditions_text_fr [self.night_forecast [day_number] .condition_code]
еще:
output = output + self.getSpaces (пробелы) + WeatherText.conditions_text [self.night_forecast [day_number] .condition_code]
elif datatype == "CT":
output = output + self.getSpaces (пробелы) + self.night_forecast [day_number] .condition_text
elif datatype == "ПК":
строка = self.night_forecast [номер_дня] .precip
если self.isNumeric (string) == True:
строка = строка + u »%»
output = output + self.getSpaces (пробелы) + строка
elif datatype == "HM":
строка = self.night_forecast [номер_дня]. влажность
если self.isNumeric (string) == True:
строка = строка + u »%»
output = output + self.getSpaces (пробелы) + строка
elif datatype == "WD":
string = self.night_forecast [day_number] .wind_dir
если self.locale == "is":
output = output + self.getSpaces (пробелы) + WeatherText.bearing_text_es [строка]
elif self.locale == "fr":
output = output + self.getSpaces (пробелы) + WeatherText.bearing_text_fr [строка]
еще:
output = output + self.getSpaces (пробелы) + строка

elif datatype == "BF":
output = output + self.getSpaces (пробелы) + WeatherText.bearing_arrow_font [self.night_forecast [day_number] .wind_dir]
elif datatype == "WS":
string = self.night_forecast [day_number] .wind_speed
если self.isNumeric (string) == True:
если имперский == Истина:
строка = self.convertKilometresToMiles (строка)
строка = строка + скорость
output = output + self.getSpaces (пробелы) + строка
elif datatype == "WG":
string = self.night_forecast [day_number] .wind_gusts
если self.isNumeric (string) == True:
если имперский == Истина:
строка = self.convertKilometresToMiles (строка)
строка = строка + скорость
output = output + self.getSpaces (пробелы) + строка
elif datatype == "CN":
output = output + self.getSpaces (пробелы) + self.night_forecast [day_number] .city
elif datatype == "SR":
output = output + self.getSpaces (пробелы) + self.night_forecast [day_number] .sunrise
elif datatype == "SS":
output = output + self.getSpaces (пробелы) + self.night_forecast [day_number] .sunset
elif datatype == "MP":
output = output + self.getSpaces (пробелы) + self.night_forecast [номер_дня] .moon_phase
elif datatype == "MF":
output = output + self.getSpaces (пробелы) + WeatherText.conditions_moon_font [self.night_forecast [day_number] .moon_icon]
elif datatype == "BR":
output = output + self.getSpaces (пробелы) + self.night_forecast [day_number] .bar_read
elif datatype == "BD":
output = output + self.getSpaces (пробелы) + self.night_forecast [day_number] .bar_desc
еще:
output = "\ nОШИБКА: запрошен неизвестный тип данных"
перерыв

else: Требуется прогноз на # день

для day_number в диапазоне (startday, endday + 1):

если тип данных == "DW":
если self.locale == "is":
если shortweekday == True:
output = output + self.getSpaces (пробелы) + WeatherText.day_of_week_short_es [self.day_forecast [day_number] .day_of_week]
еще:
output = output + self.getSpaces (пробелы) + WeatherText.day_of_week_es [self.day_forecast [day_number] .day_of_week]
elif self.locale == "fr":
если shortweekday == True:
output = output + self.getSpaces (пробелы) + WeatherText.day_of_week_short_fr [self.day_forecast [day_number] .day_of_week]
еще:
output = output + self.getSpaces (пробелы) + WeatherText.day_of_week_fr [self.day_forecast [day_number] .day_of_week]
еще:
если shortweekday == True:
output = output + self.getSpaces (пробелы) + WeatherText.day_of_week_short [self.day_forecast [day_number] .day_of_week]
еще:
output = output + self.getSpaces (пробелы) + WeatherText.day_of_week [self.day_forecast [day_number] .day_of_week]
elif datatype == "WF": # погодный шрифт
output = output + self.getSpaces (пробелы) + WeatherText.conditions_weather_font [self.day_forecast [day_number] .condition_code]
elif datatype == "LT":
строка = self.day_forecast [day_number] .low
если self.isNumeric (string) == True:
если имперский == Истина:
строка = self.convertCelsiusToFahrenheit (строка)
строка = строка + временная единица
output = output + self.getSpaces (пробелы) + строка
elif datatype == "HT":
string = self.day_forecast [day_number] .high
если self.isNumeric (string) == True:
если имперский == Истина:
строка = self.convertCelsiusToFahrenheit (строка)
строка = строка + временная единица
output = output + self.getSpaces (пробелы) + строка
elif datatype == "CC":
если self.locale == "is":
output = output + self.getSpaces (пробелы) + WeatherText.conditions_text_es [self.day_forecast [day_number] .condition_code]
elif self.locale == "fr":
output = output + self.getSpaces (пробелы) + WeatherText.conditions_text_fr [self.day_forecast [day_number] .condition_code]
еще:
output = output + self.getSpaces (пробелы) + WeatherText.conditions_text [self.day_forecast [day_number] .condition_code]
elif datatype == "CT":
output = output + self.getSpaces (пробелы) + self.day_forecast [day_number] .condition_text
elif datatype == "ПК":
строка = self.day_forecast [номер_дня] .precip
если self.isNumeric (string) == True:
строка = строка + u »%»
output = output + self.getSpaces (пробелы) + строка
elif datatype == "HM":
string = self.day_forecast [day_number]. влажность
если self.isNumeric (string) == True:
строка = строка + u »%»
output = output + self.getSpaces (пробелы) + строка
elif datatype == "WD":
string = self.day_forecast [day_number] .wind_dir

если self.locale == "is":
output = output + self.getSpaces (пробелы) + WeatherText.bearing_text_es [строка]
elif self.locale == "fr":
output = output + self.getSpaces (пробелы) + WeatherText.bearing_text_fr [строка]
еще:
output = output + self.getSpaces (пробелы) + строка

elif datatype == "BF":
output = output + self.getSpaces (пробелы) + WeatherText.bearing_arrow_font [self.day_forecast [day_number] .wind_dir]
elif datatype == "WS":
string = self.day_forecast [day_number] .wind_speed
если self.isNumeric (string) == True:
если имперский == Истина:
строка = self.convertKilometresToMiles (строка)
строка = строка + скорость
output = output + self.getSpaces (пробелы) + строка
elif datatype == "WG":
string = self.day_forecast [day_number] .wind_gusts
если self.isNumeric (string) == True:
если имперский == Истина:
строка = self.convertKilometresToMiles (строка)
строка = строка + скорость
output = output + self.getSpaces (пробелы) + строка
elif datatype == "CN":
output = output + self.getSpaces (пробелы) + self.day_forecast [day_number] .city
elif datatype == "SR":
output = output + self.getSpaces (пробелы) + self.day_forecast [day_number] .sunrise
elif datatype == "SS":
output = output + self.getSpaces (пробелы) + self.day_forecast [day_number] .sunset
elif datatype == "MP":
output = output + self.getSpaces (пробелы) + self.day_forecast [day_number] .moon_phase
elif datatype == "MF":
output = output + self.getSpaces (пробелы) + WeatherText.conditions_moon_font [self.day_forecast [day_number] .moon_icon]
elif datatype == "BR":
output = output + self.getSpaces (пробелы) + self.day_forecast [day_number] .bar_read
elif datatype == "BD":
output = output + self.getSpaces (пробелы) + self.day_forecast [day_number] .bar_desc
еще:
output = u »\ nОШИБКА: запрошен неизвестный тип данных»
перерыв

output = u »» + output.strip (u »«) # теряем начальные / конечные пробелы
возвратный вывод

#Кроме:
#print "getOutputText: Неожиданная ошибка:", sys.exc_info () [0]

def getOutputTextFromTemplate (self, template):
#пытаться:

# ключей к данным шаблона
DATATYPE_KEY = "–datatype ="
STARTDAY_KEY = "–startday ="
ENDDAY_KEY = "–endday ="
NIGHT_KEY = "–ночь"
SHORTWEEKDAY_KEY = "–shortweekday"
IMPERIAL_KEY = "–имперская система"
HIDEUNITS_KEY = "–hideunits"
SPACES_KEY = "–spaces ="

output = u »»

optionfound = Ложь

# загрузить файл
попробовать:
fileinput = open (self.options.template)
template = fileinput.read ()
fileinput.close ()
Кроме:
output = u »Файл шаблона не найден!»

templatelist = self.getTemplateList (шаблон)

# давайте пройдемся по списку шаблонов и определим вывод для каждого найденного элемента
для i в диапазоне (0, len (список шаблонов) -1):

pos = templatelist [i] .find (DATATYPE_KEY)
если pos! = -1:
optionfound = Истина
pos = pos + len (DATATYPE_KEY)
datatype = templatelist [i] [pos: pos + 4] .strip ("}"). strip ("{"). strip ("-"). strip ("")
еще:
тип данных = Нет

pos = templatelist [i] .find (STARTDAY_KEY)
если pos! = -1:
optionfound = Истина
pos = pos + len (STARTDAY_KEY)
startday = int (templatelist [i] [pos: pos + 4] .strip ("}"). strip ("{"). strip ("-"). strip (""))
еще:
startday = Нет

pos = список шаблонов [i] .find (ENDDAY_KEY)
если pos! = -1:
optionfound = Истина
pos = pos + len (ENDDAY_KEY)
endday = int (templatelist [i] [pos: pos + 4] .strip ("}"). strip ("{"). strip ("-"). strip (""))
еще:
endday = Нет

pos = список шаблонов [i] .find (NIGHT_KEY)
если pos! = -1:
optionfound = Истина
ночь = Правда
еще:
ночь = Ложь

pos = templatelist [i] .find (SHORTWEEKDAY_KEY)
если pos! = -1:
optionfound = Истина
shortweekday = Верно
еще:
shortweekday = Ложь

pos = templatelist [i] .find (IMPERIAL_KEY)
если pos! = -1:
optionfound = Истина
имперский = True
еще:
имперский = Ложь

pos = templatelist [i] .find (HIDEUNITS_KEY)
если pos! = -1:
optionfound = Истина
hideunits = Истина
еще:
hideunits = Ложь

pos = список шаблонов [i] .find (SPACES_KEY)
если pos! = -1:
optionfound = Истина
pos = pos + len (ПРОБЕЛ_КЛЮЧ)
пробелы = int (templatelist [i] [pos: pos + 4] .strip («}»). strip («{«). strip («-«). strip (»«))
еще:
пробелы = 1

если optionfound == True:
templatelist [i] = self.getOutputText (тип данных, начальный день, конечный день, ночь, короткая неделя, имперская система, укрытия, пробелы)
optionfound = Ложь

# пройтись по списку, объединяя вывод теперь, когда он заполнен
для элемента в списке шаблонов:
вывод = вывод + элемент

возвратный вывод

#Кроме:
#print "getOutputTextFromTemplate: Неожиданная ошибка:", sys.exc_info () [0]

def fetchData (сам):

# всегда получать метрические данные, использовать функции диалога с этими данными
file_path_current = self.TEMP_FILEPATH_CURRENT.replace («МЕСТОПОЛОЖЕНИЕ», self.options.location)
file_path_dayforecast = self.TEMP_FILEPATH_DAYFORECAST.replace («МЕСТОПОЛОЖЕНИЕ», self.options.location)
file_path_nightforecast = self.TEMP_FILEPATH_NIGHTFORECAST.replace ("МЕСТОПОЛОЖЕНИЕ", self.options.location)

если self.isConnectionAvailable () == False:
если os.path.exists (file_path_current):
ОбновитьДанные = Ложь
else: # нет связи, нет кеша, бац!
print «Нет подключения к Интернету и нет кешированных данных о погоде».
elif self.options.refetch == Истина:
ОбновитьДанные = Истина
еще:
# нужно ли снова получать данные?
если os.path.exists (file_path_current):
lastmodDate = time.localtime (os.stat (file_path_current) [ST_MTIME])
expiryDate = (datetime.datetime.today () - datetime.timedelta (minutes = self.EXPIRY_MINUTES)). timetuple ()

если expiryDate> lastmodDate:
ОбновитьДанные = Истина
еще:
ОбновитьДанные = Ложь
еще:
ОбновитьДанные = Истина

# получить данные о текущих условиях либо с веб-сайта, либо путем "распаковки"
если RefetchData == True:

# получить данные о текущих условиях из службы xoap
попробовать:

# 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 & unit = m '
если self.options.verbose == True:
print >> sys.stdout, «получение данных о погоде из«, url

Usock = urllib2.urlopen (url)
xml = usock.read ()
Usock.close ()
self.weatherxmldoc = minidom.parseString (xml)
Кроме:
print «fetchData: неожиданная ошибка:», sys.exc_info () [0]
print "Невозможно связаться с источником погоды для текущих условий"

# сообщить пользователю, что местоположение плохое…
found = xml.find ("Указано неверное местоположение")
если найден! = -1:
print "Указано неверное местоположение"

# запросить данные о погоде, загрузить в структуру классов и обработать их
попробовать:

# подготовить списки данных о погоде
self.current_conditions = []
self.day_forecast = []
self.night_forecast = []

# собираем общие данные
погода_n = self.weatherxmldoc.documentElement
location_n = weather_n.getElementsByTagName ('loc') [0]
city_n = location_n.getElementsByTagName ('dnam') [0]
city ​​= self.getText (city_n.childNodes)

# собираем данные о текущих условиях
day_of_week = u »Сегодня»
осадка = u »Н / Д»
восход_n = location_n.getElementsByTagName ('sunr') [0]
восход = self.getText (восход_n.childNodes)
sunset_n = location_n.getElementsByTagName ('солнца') [0]
закат = 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 ('значок') [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 ('ветер') [0]
wind_speed_n = wind_n.getElementsByTagName ('s') [0]
wind_speed = self.getText (wind_speed_n.childNodes)
wind_gust_n = wind_n.getElementsByTagName ('порыв') [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)
влажность_n = текущее_условие_n.getElementsByTagName ('hmid') [0]
влажность = self.getText (влажность_n.childNodes)
moon_n = current_condition_n.getElementsByTagName ('луна') [0]
moon_icon_n = moon_n.getElementsByTagName ('значок') [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, Осадки, влажность, wind_direction, wind_speed, wind_gusts, город, восход, закат, moon_phase, moon_icon, bar_read, bar_desc)
self.current_conditions.append (текущие_условия_данные)

# собрать данные прогноза
bar_read = u »Недоступно»
bar_desc = u »Недоступно»
moon_phase = u »Н / Д»
moon_icon = u »na»
прогноз_n = weather_n.getElementsByTagName ('dayf') [0]
day_nodes = прогноз_n.getElementsByTagName ('день')

за день в day_nodes:
day_of_week = day.getAttribute ('т')
day_of_year = day.getAttribute ('dt')
high_temp_n = day.getElementsByTagName ('привет') [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]
восход = self.getText (восход_n.childNodes)
sunset_n = day.getElementsByTagName ('солнца') [0]
закат = self.getText (sunset_n.childNodes)

Данные прогноза на # день
daytime_n = day.getElementsByTagName ('part') [0] # день
condition_code_n = daytime_n.getElementsByTagName ('значок') [0]
condition_code = self.getText (condition_code_n.childNodes)
condition_n = daytime_n.getElementsByTagName ('t') [0]
condition = self.getText (condition_n.childNodes)
осадка_n = daytime_n.getElementsByTagName ('ppcp') [0]
осадка = self.getText (осадка_n.childNodes)
влажность_n = daytime_n.getElementsByTagName ('hmid') [0]
влажность = self.getText (влажность_n.childNodes)
wind_n = daytime_n.getElementsByTagName ('ветер') [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 ('порыв') [0]
wind_gusts = self.getText (wind_gusts_n.childNodes)
day_forecast_data = WeatherData (day_of_week, low_temp, high_temp, condition_code, condition, облачность, влажность, wind_direction, wind_speed, wind_gusts, город, восход, закат, moon_phase, moon_icon, bar_read, bar_desc)
self.day_forecast.append (day_forecast_data)

# конкретные данные ночного прогноза
daytime_n = day.getElementsByTagName ('part') [1] # ночь
condition_code_n = daytime_n.getElementsByTagName ('значок') [0]
condition_code = self.getText (condition_code_n.childNodes)
condition_n = daytime_n.getElementsByTagName ('t') [0]
condition = self.getText (condition_n.childNodes)
осадка_n = daytime_n.getElementsByTagName ('ppcp') [0]
осадка = self.getText (осадка_n.childNodes)
влажность_n = daytime_n.getElementsByTagName ('hmid') [0]
влажность = self.getText (влажность_n.childNodes)
wind_n = daytime_n.getElementsByTagName ('ветер') [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 ('порыв') [0]
wind_gusts = self.getText (wind_gusts_n.childNodes)
night_forecast_data = WeatherData (day_of_week, low_temp, high_temp, condition_code, condition, облачность, влажность, wind_direction, wind_speed, wind_gusts, город, восход, закат, moon_phase, moon_icon, bar_read, bar_desc)
self.night_forecast.append (night_forecast_data)

# скопируйте данные в следующий раз!
fileoutput = open (путь_к_файлу_текущий, 'w')
pickle.dump (self.current_conditions, вывод файла)
fileoutput.close ()

fileoutput = open (file_path_dayforecast, 'w')
pickle.dump (self.day_forecast, вывод файла)
fileoutput.close ()

fileoutput = open (file_path_nightforecast, 'w')
pickle.dump (self.night_forecast, вывод файла)
fileoutput.close ()

Кроме:
print «fetchData: неожиданная ошибка:», sys.exc_info () [0]
печать "Невозможно запросить данные о погоде"

else: # получить данные о погоде из файлов классов
если self.options.verbose == True:
print >> sys.stdout, «получение данных о погоде из файла:«, file_path_current

fileinput = open (путь_к_файлу_текущий, 'r')
self.current_conditions = pickle.load (ввод файла)
fileinput.close ()

если self.options.verbose == True:
print >> sys.stdout, "получение данных дневного прогноза из файлов:", file_path_dayforecast, file_path_nightforecast

fileinput = open (file_path_dayforecast, 'r')
self.day_forecast = pickle.load (ввод файла)
fileinput.close ()

если self.options.verbose == True:
print >> sys.stdout, "получение данных дневного прогноза из файлов:", file_path_nightforecast, file_path_nightforecast

fileinput = open (file_path_nightforecast, 'r')
self.night_forecast = pickle.load (ввод файла)
fileinput.close ()

def outputData (self):
#пытаться:

если self.options.template! = Нет:

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

еще:

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)

печать output.encode ("utf-8")

#Кроме:
#print «outputData: Неожиданная ошибка:«, sys.exc_info () [0]

если __name__ == "__main__":

parser = CommandLineParser ()
(параметры, аргументы) = parser.parse_args ()

если options.verbose == True:
печать >> sys.stdout, "местоположение:", options.location
печать >> sys.stdout, "имперские:", options.imperial
печать >> sys.stdout, "тип данных:", options.datatype
печать >> sys.stdout, "ночь:", options.night
печать >> sys.stdout, "день начала:", options.startday
печать >> sys.stdout, "конец дня:", options.endday
печать >> sys.stdout, "пробелы:", options.spaces
печать >> sys.stdout, "подробный:", options.verbose
печать >> sys.stdout, "refetch:", options.refetch

# создать новый глобальный объект погоды
weather = GlobalWeather (параметры)
weather.fetchData ()
weather.outputData ()

Создаем файл ~ / Conky / scripts / myweather.template

gedit ~ / Conky / scripts / myweather.template

вставляем внутрь:

{–Datatype = DW –startday = 1}: {–datatype = CC –startday = 1}
{–Datatype = HT –startday = 1} / {–datatype = LT –startday = 1} Ветер с {–datatype = WD –startday = 1} на {–datatype = WS –startday = 1}
Влажность: {–datatype = HM –startday = 1} Осадки: {–datatype = PC –startday = 1}
Восход: {–datatype = SR –startday = 1} Закат: {–datatype = SS –startday = 1}
----------------
{–Datatype = DW –startday = 2}: {–datatype = CC –startday = 2}
{–Datatype = HT –startday = 2} / {–datatype = LT –startday = 2} Ветер с {–datatype = WD –startday = 2} на {–datatype = WS –startday = 2}
Влажность: {–datatype = HM –startday = 2} Осадки: {–datatype = PC –startday = 2}
Восход: {–datatype = SR –startday = 2} Закат: {–datatype = SS –startday = 2}
----------------
{–Datatype = DW –startday = 3}: {–datatype = CC –startday = 3}
{–Datatype = HT –startday = 3} / {–datatype = LT –startday = 3} Ветер с {–datatype = WD –startday = 3} на {–datatype = WS –startday = 3}
Влажность: {–datatype = HM –startday = 3} Осадки: {–datatype = PC –startday = 3}
Восход: {–datatype = SR –startday = 3} Закат: {–datatype = SS –startday = 3}
----------------
{–Datatype = DW –startday = 4}: {–datatype = CC –startday = 4}
{–Datatype = HT –startday = 4} / {–datatype = LT –startday = 4} Ветер с {–datatype = WD –startday = 4} на {–datatype = WS –startday = 4}
Влажность: {–datatype = HM –startday = 4} Осадки: {–datatype = PC –startday = 4}
Восход: {–datatype = SR –startday = 4} Закат: {–datatype = SS –startday = 4}

Создаем файл ~ / Conky / scripts / mail / conkyEmail.py (мы должны создать почтовую папку)

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

и вставьте внутрь следующее:

импорт ОС
строка импорта

# Введите свое имя пользователя и пароль ниже в двойных кавычках
# например. имя пользователя = »имя пользователя» и пароль = »пароль»
имя пользователя = »YOUR_USUARIO_SINARROBA«
пароль = »ТВОЙ КЛЮЧ«

com = »wget -O - https: //» + имя пользователя + »:» + пароль + »@ 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 [индекс + 11: индекс2])

если fc == 0:
распечатать "0 новых"
еще:
print str (fc) + »новое»

Итак, теперь у вас есть 7 файлов:

В папке: ~
-> .startconky << - сделать исполняемый файл

В папке: ~ / Conky
-> conkymain
-> conkyforecast
-> conkymail

и в папке: ~ / Conky / scripts
-> conkyForecast.py << - сделать исполняемый файл
-> myweather.template

и в папке: ~ / Conky / scripts / mail
conkyEmail.py << - сделать исполняемый файл

И это все, пояснения, где написано / home / user / ... ваше имя пользователя, а в той части, где идут данные Gmail, я выделил цветами, где вы должны поместить свои данные.

чтобы убить conky процесс, напишите в консоль

Killall Conky

запустить conky write в консоль

./.startconky

как только вы все настроите, если вы хотите, чтобы Conky начинал каждую сессию

Система -> Настройки -> Сеансы и в программах запуска добавляем его

В Name мы можем написать Conky, в Order ./.startconky, чтобы он запускался каждый раз, когда вы включаете компьютер.

Вот и все, я надеюсь, это вам поможет.


Оставьте свой комментарий

Ваш электронный адрес не будет опубликован. Обязательные для заполнения поля помечены *

*

*

  1. Ответственный за данные: Мигель Анхель Гатон
  2. Назначение данных: контроль спама, управление комментариями.
  3. Легитимация: ваше согласие
  4. Передача данных: данные не будут переданы третьим лицам, кроме как по закону.
  5. Хранение данных: база данных, размещенная в Occentus Networks (ЕС)
  6. Права: в любое время вы можете ограничить, восстановить и удалить свою информацию.