Conky，我的设置

Fecfactor昨天要求我发布以下屏幕快照中显示的conky的配置

如您所见，大约有3个conky，通过脚本执行，其配置基于 这篇文章 由用户Bruce M.发表在的论坛中 Ubuntu-Ar 在邮件conky中进行了一些修改，在我的案例中，这是针对Gmail的。

在参考文章中，Bruce对其进行了很好的解释，但作为对我的记忆帮助，我将复制遵循的步骤以及对于谁的conkys代码。

好吧，当然，我们需要安装conky，curl和python，因此我们在控制台中输入：

须藤apt-get install conky curl python

weather.ttf和arrow.ttf的来源 在这儿。 moon.ttf的来源 在这儿 下载后，您必须将它们复制到/ usr / share / fonts

现在让我们创建一个名为〜。/ Startconky的脚本。

gksudo gedit〜/ .startconky

在空文件中，我们粘贴以下内容

＃！/斌/庆典
sleep 0＆＃0对Xfce有好处-Gnome使用20到30
conky -c〜/ Conky / conkymain和
#sleep 0＆＃0对Xfce有用-对Gnome使用1
conky -c〜/ Conky / conkyforecast＆
#sleep 0＆＃0对Xfce有用-对Gnome使用1
conky -c〜/ Conky / conkymail和

现在，我们在〜/ Conky文件夹中创建conkymain文件，如果没有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
xftalpha 0.5
更新间隔 5.0
如果您希望所有文本都使用大写字母，则将＃设置为yes
点画的边界3
边界边距 9
边框宽度 10
default_color白色
default_outline_color黑色
default_shade_color黑色
颜色0青色
color1浅蓝色
color2橙色
颜色3黄色
color4小麦
颜色5白色
颜色6白色
颜色7白色
颜色8白色
颜色9白色
对齐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 $ $计算机上的内核} $ 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}正常运行时间：$ {alignr 2} $正常运行时间$ color
$ {color0} $ {hr 1} $ color
$ {voffset 5} $ {color2} CPU：$ {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 $ {aligner 2} $ {color2} $ {membar 14,80} $ color
$ {color1} $ {voffset -16} $ {alignr 5} $ memperc％$ color
$ {voffset 2} $ {color1}缓冲：$ color $ {buffers} $ {alignr 2} $ {color1}缓存：$ color $ {cached}
$ {voffset 5} $ {color2}交换：$ 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信息$ {color1}-$ color Free $ {color1}-二手-$ {color2}合计
$ {voffset 5} $ {color1}根：$ color $ {fs_free_perc /}％$ {alignr 2} $ {fs_free /} $ {color2} / $ {color1} $ {fs_used /} $ color / $ {color2} $ {fs_size /} $ color
$ {color1}主页：$ color $ {fs_free_perc /家庭/用户}％$ {alignr 2} $ {fs_free /家庭/用户} $ {color2} / $ {color1} $ {fs_used /家庭/用户} $ color / $ {color2} $ {fs_size /家庭/用户} $ 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 /脚本/ conkyForecast.py –位置= ARBA0009 –数据类型= LT}
$ {color3} $ {font Weather：size = 50} $ {execi 3600 python〜/ Conky /脚本/ conkyForecast.py –位置= ARBA0009 –数据类型= WF} $ font $ color
$ {alignr 50} $ {voffset -55} $ {font calibri：size = 25} $ {execi 3600 python〜/ Conky /脚本/ conkyForecast.py –位置= ARBA0009 –数据类型= HT} $字体
$ {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}风：$ {execi 3600 python〜/ Conky /脚本/ conkyForecast.py –位置= ARBA0009 –数据类型= WS} $ color
$ {color1}湿度：$ {color3} $ {execi 3600 python〜/ Conky /脚本/ conkyForecast.py –位置= ARBA0009 –数据类型= HM} $ {alignr 2} $ {color1}降水：$ {color3} $ { execi 3600 python〜/ Conky /脚本/ conkyForecast.py –位置= ARBA0009 –数据类型= PC} $ color
$ {alignc} $ {color1}压力：$ {color3} $ {execi 3600 python〜/ Conky /脚本/ conkyForecast.py –位置= ARBA0009 –数据类型= BR}-$ {color3} $ {execi 3600 python〜/ Conky /scripts/conkyForecast.py –位置= ARBA0009 –数据类型= BD} $ color
$ {color4} $ {hr} $ color
$ {color1}日出：$ {color3} $ {execi 3600 python〜/ Conky /脚本/ conkyForecast.py –位置= ARBA0009 –数据类型= SR} $ {alignr 2} $ {color1}日落：$ {color3} $ { execi 3600 python〜/ Conky /脚本/ conkyForecast.py –位置= ARBA0009 –数据类型= SS} $ color
$ {voffset 15} $ {color1}月亮：$ {color4} $ {alignr 2} $ {color3} $ {execi 3600 python〜/ Conky /脚本/ conkyForecast.py –位置= ARBA0009 –数据类型= MP} $ color
$ {voffset -20} $ {offset 80} $ {color4} $ {font moon phases：size = 20} $ {execi 3600 python〜/ Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = MF} $ font颜色
$ {color0} $ {hr} $ color
$ {voffset 5} $ {color2} IP：$ {alignc} $ color $ {addr eth0}
$ {color1}下降：$ color $ {下降速度eth0} k / s $ {aligner 2} $ {color1}上升：$ color $ {upspeed eth0} k / s
$ {color1}合计：$ color $ {totaldown eth0} $ {alignr 2} $ {color1}合计：$ color $ {totalup eth0}
$ {color1}入站：$ color $ {tcp_portmon 1 32767计数} $ {color1}出站：$ color $ {tcp_portmon 32768 61000计数} $ {alignr 2} $ {color1}总计：$ color $ {tcp_portmon 1 65535计数}
$ {voffset 5} $ {color2}连接：$ color $ {tcp_portmon 32768 61000 count} $ {alignr 2} $ {color2}服务/端口$ 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} $颜色

我们创建文件〜/ 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
xftalpha 0.5
更新间隔 5.0
如果您希望所有文本都使用大写字母，则将＃设置为yes
点画的边界3
边界边距 9
边框宽度 10
default_color白色
default_outline_color黑色
default_shade_color黑色
颜色0青色
color1浅蓝色
color2橙色
颜色3黄色
color4小麦
颜色5白色
颜色6白色
颜色7白色
颜色8白色
颜色9白色
对齐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} $ color
$ {color4} $ {font calibri：size = 9} $ {execi 3600 python〜/ Conky /脚本/ conkyForecast.py –位置= ARBA0009 –template = /家庭/用户/ Conky /脚本/ 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
xftalpha 0.5
更新间隔 5.0
如果您希望所有文本都使用大写字母，则将＃设置为yes
点画的边界3
边界边距 9
边框宽度 10
default_color白色
default_outline_color黑色
default_shade_color黑色
颜色0青色
color1浅蓝色
color2橙色
颜色3黄色
color4小麦
颜色5白色
颜色6白色
颜色7白色
颜色8白色
颜色9白色
对齐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} $ color
$ {font calibri：size = 11} $ {color4}我们有$ {color3} $ {execi 300 python〜/ Conky /脚本/ mail / conkyEmail.py} $ {color4}电子邮件$字体

我们在〜/ Conky / scripts / conkyForecast.py中创建一个文件（我们必须创建scripts文件夹）

gedit〜/ Conky /脚本/ conkyForecast.py

＃！/ usr / bin / python
＃-*-编码：utf-8-*-
################################################ #############################
＃conkyForecast.py是一个（不再是）简单的（不再是）Python脚本来收集
＃当前天气在conky中使用的详细信息。
#
＃作者：Kaivalagi
＃创建时间：13/04/2008
＃修改：
＃14/04/2008允许预报数据的日期范围
＃14/04/2008检查与xoap服务的连接
＃18/04/2008允许为远程输出设置空格
＃18/04/2008允许日夜预报输出
＃18/04/2008支持条件代码文本“ CC”选项的语言环境，等待西班牙语翻译
＃18/04/2008对类数据使用酸洗而不是打开xml，这样就无需询问缓存的数据
＃19/04/2008添加了西班牙语条件文本-谢谢Bruce M
＃19/04/2008在所有后缀为单位的数字输出上添加了等数字检查
＃19/04/2008修改了泡菜文件的命名，以包含位置代码
＃19/04/2008添加了通过语言环境的西班牙语工作日转换
＃20/04/2008添加了体面的命令参数解析器
＃20/04/2008添加了–shortweekday选项，如果给定的是星期几，则数据类型缩短为3个字符
＃21/04/2008固定的区域设置选项，用于预测输出
＃21/04/2008添加了–template选项，以允许使用单个exec调用自定义输出🙂
＃21/04/2008添加了–hideunits选项，可从输出中删除例如mph和C
＃23/04/2008从模板中删除了–imperial选项，该选项必须在脚本调用中设置为标准选项，并且不能在模板文件中使用。
＃23/04/2008读取-模板的英制选项，启用每个数据类型的公制或英制值。 请注意，在使用模板时，命令行选项将不起作用。
＃23/04/2008添加了输出，通知用户指定的位置是否错误
＃24/04/2008增加了对不连​​接的处理，现在将恢复为缓存的数据（如果不存在缓存，则会出错）。 通过尝试打开xoap.weather.com进行测试
＃24/04/2008固定将摄氏温度转换为华氏度
＃06/05/2008更新Web服务后使用的更新URL
＃09/05/2008将当前状态和预测数据整合到一个调用中
＃09/05/2008为数据类型添加了日出和日落，这些特定于当前条件和预测数据
＃09/05/2008在数据类型中添加了月相，气压计读数和气压计说明，这些仅特定于当前条件，因此预测输出中的N / A也是如此
＃09/05/2008增加了气压计的单位转换，从mb到英寸（英制）
＃09/05/2008更新了西班牙文条件文本-谢谢Bruce M
＃10/05/2008添加了法语语言环境数据-谢谢benpaka
＃12/05/2008添加了新的BF（轴承字体）数据类型以提供箭头字符（与Arrow.ttf字体一起使用），而不是WD的NSEW输出（风向）
＃12/05/2008将WD输出更新为特定于语言环境，当前支持默认的英语和西班牙语-感谢Bruce M
＃18/05/2008添加了新的MF（月亮字体）数据类型以提供月亮字体字符（字符不正确，尚无专用字体）。
＃21/05/2008对于当前条件，–datatype = LT选项现在显示“感觉类似”温度，而不是当前温度
#
＃ 一切：
＃将pkl文件合并为一个文件/类
＃根据月亮图标数据添加基于月亮相位输出的天气字体
＃??? 还有其他要求吗？

导入sys，os，socket，urllib2，datetime，time
从xml.dom导入minidom
来自统计信息导入*
从optparse导入OptionParser
导入语言环境
导入gettext
进口泡菜
从数学导入*

APP =»conkyForecast.py»
DIR = os.path.dirname（__file__）+'/ locale'
gettext.bindtextdomain（APP，DIR）
gettext.textdomain（APP）
_ = gettext.gettext

CommandLineParser类：

解析器=无

def __init __（个体）：

self.parser = OptionParser（）
self.parser.add_option（«-l»，»-location»，dest =»location»，默认=»UKXX0103''，类型=»字符串»，metavar =»代码»，help = u»天气数据的位置代码[默认值：％default]，请使用以下网址按城市名称确定您的位置代码：http：//xoap.weather.com/search/search？where = Norwich»）
self.parser.add_option（“-d”，“-数据类型”，dest =“数据类型”，默认=“ HT”，类型=“字符串”，metavar =“数据类型”，help = u“ [[默认：％默认]]数据类型选项包括：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»，类型=»int»，metavar =»NUMBER»，help = u»定义起始日期编号，如果省略当前条件则输出。在使用模板时不适用于命令行。»）
self.parser.add_option（“-e”，“-endday”，dest =“ endday”，type =“ int”，metavar =“ NUMBER”，help = u“定义结束日期号，如果省略，仅开始日期数据输出。在使用模板时不适用于命令行。»）
self.parser.add_option（«-S»，»-spaces，dest =»spaces，type =»int»，默认= 1，metavar =»NUMBER»，help = u»[默认：％default]范围输出之间的空格数。使用模板时不适用于命令行。»）
self.parser.add_option（«-t»，»-template»，dest =»template»，type =»string»，metavar =»FILE»，help = u»定义一个模板文件以在一次调用中生成输出。文件中的可显示项目的格式为{–datatype = HT –startday = 1}。每个项目中可能包含以下选项：–datatype，–startday，–endday，–night，–shortweekday，–imperial，–hideunits， –空格。请注意，当前不支持选项的短格式！使用模板时，这些选项均不适用于命令行。»）
self.parser.add_option（«-L»，»-locale»，dest =»locale»，type =»string»，help = u»覆盖语言输出的系统语言环境（en =英语，es =西班牙文，fr =法语，更多内容）»）
self.parser.add_option（“-i”，“-imperial”，dest =“ imperial”，默认= False，action =“ store_true”，help = u“请求英制单位，如果省略的输出是公制。不适用于使用模板时的命令行。»）
self.parser.add_option（«-n»，»-night»，dest =»night»，默认= False，action =»store_true»，help = u»将输出切换为夜间数据，如果省略则将输出日间输出。使用模板时不适用于命令行。»）
self.parser.add_option（«-w»，»-shortweekday»，dest =»shortweekday»，默认= False，action =»store_true»，help = u»将星期几数据类型缩短为3个字符。不适用于使用模板时的命令行。»）
self.parser.add_option（«-u»，»-hideunits»，dest =»hideunits»，默认= False，action =»store_true»，help = u»隐藏单位，例如mph或C，度数符号（°）是仍显示。使用模板时不适用于命令行。»）
self.parser.add_option（“ -v”，“-verbose”，dest =“ verbose”，默认= False，action =“ store_true”，help = u“请求详细输出，通过conky运行时没有好主意！ ）
self.parser.add_option（“-r”，“-refetch”，dest =“ refetch”，默认值= False，action =“ store_true”，help = u“无论数据到期如何都获取数据”）

def parse_args（个体）：
（选项，args）= self.parser.parse_args（）
返回（选项，参数）

def print_help（个体）：
返回self.parser.print_help（）

WeatherData类：
def __init __（自身，day_of_week，低，高，condition_code，condition_text，precip，湿度，wind_dir，wind_speed，wind_gusts，城市，日出，日落，moon_phase，moon_icon，bar_read，bar_desc）：
self.day_of_week = u»»+ day_of_week
self.low = u»»+低
self.high = u»»+高
self.condition_code = u»»+ condition_code
self.condition_text = u»»+ condition_text
self.precip = u»»+ precip
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»Showers»），
«12»：_（u»Showers»），
«13»：_（u»雪乱»），
«14»：_（u»小雪阵雨»），
«15»：_（u»吹雪»），
«16»：_（u»Snow»），
«17»：_（u»冰雹»），
«18»：_（u»雨夹雪»），
«19»：_（u»灰尘»），
«20»：_（u»雾»），
«21»：_（u»阴霾»），
«22»：_（u»烟雾»），
«23»：_（u»暴躁»），
«24»：_（u»Windy»），
«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»大雪»），
«42»：_（u»零星的阵雪»，
«43»：_（u»大雪»），
«44»：_（u（部分多云），），
«45»：_（u»雷阵雨»），
«46»：_（u»下雪了»），
«47»：_（u»孤立的雷暴»），
«Na»：_（u»N / A»），
“-“： _（一种”）
}

condition_text_es = {
«0»：_（u»龙卷风»），
«1»：_（u»热带风暴»），
«2»：_（u»Huracá¡n»），
«3»：_（u»强风暴»），
«4»：_（u»暴风雨»），
«5»：_（u»雨和雪混合»，
«6»：_（u»雨夹雪和雨夹雪»），
«7»：_（u»雨夹雪），
«8»：_（u»冻毛毛雨»），
«9»：_（u»毛毛雨»），
«10»：_（u»冻雨»），＃或冻雨
«11»：_（u»Showers»），
«12»：_（u»Showers»），
«13»：_（u»小雪»），
«14»：_（u»小雪»），
«15»：_（u»雪暴雪»），
«16»：_（u»雪»），
«17»：_（u»冰雹»），
«18»：_（u»雨夹雪），
«19»：_（u»粉末»），
«20»：_（u»雾»），
«21»：_（u»阴霾»），
«22»：_（u»烟雾»），
«23»：_（u»Tempest»），
«24»：_（u»Windy»），
«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»Heat»），
«37»：_（u»孤立的暴风雨»），
«38»：_（u»零星的暴风雨»），
«39»：_（u»零星的暴风雨»），
«40»：_（u»零星阵雨»），
«41»：_（u»大雪»），
«42»：_（u»弱雪和零星降雪»），
«43»：_（u»内华达州强烈»），
«44»：_（u»“零星的云”），
«45»：_（u»暴风雨»），
«46»：_（u»零星的降雪»），
«47»：_（u»孤立的暴风雨»），
«Na»：_（u»N / A»），
“-“： _（一种”）
}

condition_text_fr = {
«0»：_（u»Tornade»），
«1»：_（u»TempêteTropicale»），
«2»：_（或»Ouragan»），
«3»：_（或»暴力骚扰»），
«4»：_（或»Orageux»），
«5»：_（u»Pluie et Neige»），
«6»：_（u»Pluie et NeigeMouillée»），
«7»：_（u»变量厌恶厌恶»），
«8»：_（u»Bruine Givrante»），
«9»：_（u»Bruine»），
«10»：_（u»Pluie Glacante»），
«11»：_（u»厌恶»），
«12»：_（u»厌恶»），
«13»：_（u»LégèreNeige»），
«14»：_（u»Forte Neige»），
«15»：_（u»Tempêtede Neige»），
«16»：_（u»Neige»），
«17»：_（u»Grêle»），
«18»：_（u»Pluie / Neige»），
«19»：_（u»Nuage depoussiè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»Disséminés»），
«30»：_（u»Disséminés»），
«31»：_（u»Beau»），
«32»：_（u»Beau»），
«33»：_（u»BellesÉclaircies»），
«34»：_（u»BellesÉclaircies»），
«35»：_（u»Pluie avecGrêle»），
«36»：_（u»Chaleur»），
«37»：_（或»OragesIsolés»），
«38»：_（或»OragesLocalisés»），
«39»：_（或»OragesLocalisés»），
«40»：_（u»AlocalsLocalisées»），
«41»：_（u»Neige Lourde»），
«42»：_（u»Tempêtede NeigeLocalisées»），
«43»：_（u»Neige Lourde»），
«44»：_（u»Disséminés»），
«45»：_（或»Orages»），
«46»：_（u»Tempêtede Neige»），
«47»：_（或»OragesIsolés»），
«Na»：_（u»N / A»），
“-“： _（一种”）
}

条件_天气_字体= {
«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»»），
“-“： _（或者””）
}

condition_moon_font = {
«0»：_（u»1″），
«1»：_（u»N»），
«2»：_（u»O»），
«3»：_（u»P»），
«4»：_（u»Q»），
«5»：_（u»R»），
«6»：_（u»S»），
«7»：_（u»T»），
«8»：_（u»U»），
«9»：_（u»V»），
«10»：_（u»W»），
«11»：_（u»X»），
«12»：_（u»Y»），
«13»：_（u»Z»），
«14»：_（u»0″），
«15»：_（u»0″），
«16»：_（u»A»），
«17»：_（u»B»），
«18»：_（u»C»），
«19»：_（u»D»），
«20»：_（u»E»），
«21»：_（u»F»），
«22»：_（u»G»），
«23»：_（u»H»），
«24»：_（u»I»），
«25»：_（u»J»），
«26»：_（u»K»），
«27»：_（u»L»），
«28»：_（u»M»），
«29»：_（u»1″），
«Na»：_（u»»），
“-“： _（或者””）
}

星期几 = {
“今天”：_（或“今天”），
«星期一»：_（u»星期一»），
«星期二»：_（u»星期二»），
«星期三»：_（u»星期三»），
«星期四»：_（u»星期四»），
«星期五»：_（u»星期五»），
“ Saturday”：_（u“ Saturday”），
“周日”：_（u“周日”）
}

周内短日 = {
“今天”：_（u“ Now”），
«星期一»：_（u»星期一»），
«星期二»：_（u»星期二»），
«星期三»：_（u»星期三»），
«星期四»：_（u»Thu»），
«星期五»：_（u»星期五»），
“ Saturday”：_（u“ Sat”），
“周日”：_（u“周日”）
}

day_of_week_en = {
“今天”：_（u“ today”），
“ Monday”：_（u（“ Monday”），
«星期二»：_（u»星期二»），
«星期三»：_（u»星期三»），
«星期四»：_（u»星期四»），
«星期五»：_（u»星期五»），
“ Saturday”：_（u“ Saturday”），
“周日”：_（u“周日”）
}

day_of_week_short_en = {
“今天”：_（u“ today”），
“星期一”：_（u“ mon”），
«星期二»：_（u»sea»），
«星期三»：_（u»星期三»），
«星期四»：_（u»Thurs»），
«星期五»：_（u»fri»），
“ Saturday”：_（u“ sat”），
“周日”：_（u“ dom”）
}

day_of_week_fr = {
«今天»：_（u»Aujourd'hui»），
«星期一»：_（u»Lundi»），
«星期二»：_（u»Mardi»），
«星期三»：_（u»Mercredi»），
«星期四»：_（u»Jeudi»），
«星期五»：_（u»Vendredi»），
“星期六”：_（u“ Samedi”），
“周日”：_（u“ Dimanche”）
}

day_of_week_short_fr = {
«今天»：_（u»Auj»），
“星期一”：_（u“星期一”），
«星期二»：_（u»Mar»），
“星期三”：_（u“ Mer”），
«星期四»：_（u»Jeu»），
«星期五»：_（u»Come»），
“ Saturday”：_（u“ Sam”），
“周日”：_（u“昏暗”）
}

轴承箭头字体 = {
«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»«）
}

轴承_文本_es = {
«N»：_（u»N»），
«NNE»：_（u»NNE»），
«NE»：_（u»NE»），
«ENE»：_（u»ENE»），
«E»：_（u»E»），
«ESE»：_（u»ESE»），
«SE»：_（u»SE»），
“ SSE”：_（u“ SSE”），
“他们的”），
“ SSW”：_（u“ SSO”），
«SW»：_（u»SO»），
“ WSW”：_（u“ WOW”），
«W»：_（u»O»），
«WNW»：_（u»ONO»），
«NW»：_（u»NO»），
«NNW»：_（u»NNO»），
«N / A»：_（u»N \ A»）
}

轴承_文本_fr = {
«N»：_（u»N»），
«NNE»：_（u»NNE»），
«NE»：_（u»NE»），
«ENE»：_（u»ENE»），
«E»：_（u»E»），
«ESE»：_（u»ESE»），
«SE»：_（u»SE»），
“ SSE”：_（u“ SSE”），
“他们的”），
“ SSW”：_（u“ SSO”），
«SW»：_（u»SO»），
“ WSW”：_（u“ WOW”），
«W»：_（u»O»），
«WNW»：_（u»ONO»），
«NW»：_（u»NO»），
«NNW»：_（u»NNO»），
«N / A»：_（u»N \ A»）
}

GlobalWeather类：

当前条件 = []
日预测 = []
夜间预测 = []

locale =“在”

选项=无
weatherxmldoc =«»

TEMP_FILEPATH_CURRENT =“ /tmp/conkyForecast-c-LOCATION.pkl”
TEMP_FILEPATH_DAYFORECAST =“ /tmp/conkyForecast-df-LOCATION.pkl”
TEMP_FILEPATH_NIGHTFORECAST =“ /tmp/conkyForecast-nf-LOCATION.pkl”
EXPIRY_MINUTES = 30
DEFAULT_SPACING = u»«

def __init __（自身，选项）：

self.options =选项

如果self.options.locale ==无：
尝试：
＃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：
打印>> sys.stdout，“语言环境设置为”，self.locale

def getText（自身，节点列表）：
rc =«»
对于节点列表中的节点：
如果node.nodeType == node.TEXT_NODE：
rc = rc + 节点数据
返回rc

def getSpaces（自身，空格）：
字符串= u»»
如果空格==无：
字符串= self.DEFAULT_SPACING
其他：
对于范围（0，空格+ 1）中的i：
字符串=字符串+ u»«
返回字符串

def isNumeric（自身，字符串）：
尝试：
虚拟=浮点数（字符串）
返回True
除了：
返回False

def isConnectionAvailable（个体）：
＃确保我们可以通过打开url来访问weather.com的服务器
尝试：
Usock = urllib2.urlopen（'http://xoap.weather.com'）
Usock.close（）
返回True
除了：
返回False

def getBearingText（自身，方位）：
轴承=浮动（轴承）
如果轴承<11.25：
返回你»N»
Elif轴承<33.75：
返回您»NNE»
Elif轴承<56.25：
返回您»NE»
Elif轴承<78.75：
返回您»JAN»
Elif轴承<101.25：
返回您»E»
Elif轴承<123.75：
返回您»ESE»
Elif轴承<146.25：
返回您»SE»
Elif轴承<168.75：
返回您»SSE»
Elif轴承<191.25：
返回你»S»
Elif轴承<213.75：
返回您»SSW»
Elif轴承<236.25：
返回您»SW»
Elif轴承<258.75：
返回您»WSW»
Elif轴承<281.25：
返回您»W»
Elif轴承<303.75：
返回您»WNW»
Elif轴承<326.25：
返回您»NW»
Elif轴承<348.75：
返回您»NNW»
其他：
返回«N / A»

def convertCelsiusToFahrenheit（自我，临时）：
return str（int（floor（（（（float（temp）* 9.0）/5.0）+32）））

def convertKilometresToMiles（自我，dist）：
return str（int（floor（float（dist）* 0.621371192）））

def convertMillibarsToInches（自我，mb）：
return str（int（floor（float（mb）/33.8582）））

def getTemplateList（自身，模板）：

模板列表 = []

对于template.split（«{«）中的template_part：
如果template_part！=«»：
对于template_part.split（“}”）中的template_part：
如果template_part！=«»：
templatelist.append（u»»+ template_part）

返回模板列表

def getOutputText（自身，数据类型，开始日期，结束日期，夜晚，短工作日，英制，hideunits，空格）：
＃尝试：
输出= u»»

＃定义输出的当前单位
如果hideunits == False：
如果英制== False：
温度单位= u»°C»
速度单位 = u »kph»
压力单位= u»mb»
其他：
温度单位= u»°F»
速度单位= u»mph»
压力单位= u»in»
其他：
温度单位 = u »°»
速度单位 = u »»
压力单位= u»»

如果开始日期==无：＃当前条件

如果数据类型==“ DW”：
如果self.locale ==“是”：
如果shortweekday == True：
输出= WeatherText.day_of_week_short_es [self.current_conditions [0] .day_of_week]
其他：
输出= WeatherText.day_of_week_es [self.current_conditions [0] .day_of_week]
elif self.locale ==“ fr”：
如果shortweekday == True：
输出= WeatherText.day_of_week_short_fr [self.current_conditions [0] .day_of_week]
其他：
输出= WeatherText.day_of_week_fr [self.current_conditions [0] .day_of_week]
其他：
如果shortweekday == True：
输出= WeatherText.day_of_week_short [self.current_conditions [0] .day_of_week]
其他：
输出= WeatherText.day_of_week [self.current_conditions [0] .day_of_week]
elif数据类型==“ WF”：＃天气字体
输出= WeatherText.conditions_weather_font [self.current_conditions [0] .condition_code]
elif数据类型==“ LT”：
字符串= self.current_conditions [0] .low
如果self.isNumeric（string）== True：
如果英制==真：
字符串= self.convertCelsiusToFahrenheit（字符串）
字符串=字符串+温度单位
输出=字符串
elif数据类型==“ HT”：
字符串= self.current_conditions [0] .high
如果self.isNumeric（string）== True：
如果英制==真：
字符串= self.convertCelsiusToFahrenheit（字符串）
字符串=字符串+温度单位
输出=字符串
elif数据类型==“ CC”：
如果self.locale ==“是”：
输出= WeatherText.conditions_text_es [self.current_conditions [0] .condition_code]
elif self.locale ==“ fr”：
输出= WeatherText.conditions_text_fr [self.current_conditions [0] .condition_code]
其他：
输出= WeatherText.conditions_text [self.current_conditions [0] .condition_code]
elif数据类型==“ CT”：
输出= self.current_conditions [0] .condition_text
elif数据类型==“ PC”：
字符串= self.current_conditions [0] .precip
如果self.isNumeric（string）== True：
字符串=字符串+ u»％»
输出=字符串
elif数据类型==“ HM”：
字符串= self.current_conditions [0]。湿度
如果self.isNumeric（string）== True：
字符串=字符串+ u»％»
输出=字符串
elif数据类型==“ WD”：
字符串= self.current_conditions [0] .wind_dir
如果self.isNumeric（string）== True：
字符串= self.getBearingText（字符串）

如果self.locale ==“是”：
输出= WeatherText.bearing_text_es [字符串]
elif self.locale ==“ fr”：
输出= WeatherText.bearing_text_fr [string]
其他：
输出=字符串

elif数据类型==“ BF”：
字符串= self.current_conditions [0] .wind_dir
如果self.isNumeric（string）== True：
字符串= WeatherText.bearing_arrow_font [self.getBearingText（字符串）]
输出=字符串
elif数据类型==“ WS”：
字符串= self.current_conditions [0] .wind_speed
如果self.isNumeric（string）== True：
如果英制==真：
字符串= self.convertKilometresToMiles（字符串）
字符串=字符串+速度单位
输出=字符串
elif数据类型==“ WG”：
字符串= self.current_conditions [0] .wind_gusts
如果self.isNumeric（string）== True：
如果英制==真：
字符串= self.convertKilometresToMiles（字符串）
字符串=字符串+速度单位
输出=字符串
elif数据类型==“ CN”：
输出= self.current_conditions [0] .city
elif数据类型==“ SR”：
输出= self.current_conditions [0] .sunrise
elif数据类型==“ SS”：
输出= self.current_conditions [0] .sunset
elif数据类型==“ MP”：
输出= self.current_conditions [0] .moon_phase
elif数据类型==“ MF”：
输出= WeatherText.conditions_moon_font [self.current_conditions [0] .moon_icon]
elif数据类型==“ BR”：
字符串= self.current_conditions [0] .bar_read
如果self.isNumeric（string）== True：
如果英制==真：
字符串= self.convertMillibarsToInches（字符串）
字符串=字符串+压力单位
输出=字符串
elif数据类型==“ BD”：
输出= self.current_conditions [0] .bar_desc
其他：
输出=“ \ nERROR：请求的未知数据类型”

否则：＃个预测数据

如果endday == None：＃如果未设置结束日期，则使用startday
结束日=开始日

如果夜晚==真：需要＃晚间预报

对于范围内的day_number（开始日期，结束日期+ 1）：

如果数据类型==“ DW”：
如果self.locale ==“是”：
如果shortweekday == True：
输出=输出+ self.getSpaces（空格）+ WeatherText.day_of_week_short_es [self.night_forecast [day_number] .day_of_week]
其他：
输出=输出+ self.getSpaces（空格）+ WeatherText.day_of_week_es [self.night_forecast [day_number] .day_of_week]
elif self.locale ==“ fr”：
如果shortweekday == True：
输出=输出+ self.getSpaces（空格）+ WeatherText.day_of_week_short_fr [self.night_forecast [day_number] .day_of_week]
其他：
输出=输出+ self.getSpaces（空格）+ WeatherText.day_of_week_fr [self.night_forecast [day_number] .day_of_week]
其他：
如果shortweekday == True：
输出=输出+ self.getSpaces（空格）+ WeatherText.day_of_week_short [self.night_forecast [day_number] .day_of_week]
其他：
输出=输出+ self.getSpaces（空间）+ WeatherText.day_of_week [self.night_forecast [day_number] .day_of_week]
elif数据类型==“ WF”：＃天气字体
输出=输出+ self.getSpaces（空格）+ WeatherText.conditions_weather_font [self.night_forecast [day_number] .condition_code]
elif数据类型==“ LT”：
字符串= self.night_forecast [day_number] .low
如果self.isNumeric（string）== True：
如果英制==真：
字符串= self.convertCelsiusToFahrenheit（字符串）
字符串=字符串+温度单位
输出=输出+ self.getSpaces（空格）+字符串

elif数据类型==“ HT”：
字符串= self.night_forecast [day_number] .high
如果self.isNumeric（string）== True：
如果英制==真：
字符串= self.convertCelsiusToFahrenheit（字符串）
字符串=字符串+温度单位
输出=输出+ self.getSpaces（空格）+字符串
elif数据类型==“ CC”：
如果self.locale ==“是”：
输出=输出+ self.getSpaces（空格）+ WeatherText.conditions_text_es [self.night_forecast [day_number] .condition_code]
elif self.locale ==“ fr”：
输出=输出+ self.getSpaces（空格）+ WeatherText.conditions_text_fr [self.night_forecast [day_number] .condition_code]
其他：
输出=输出+ self.getSpaces（空格）+ WeatherText.conditions_text [self.night_forecast [day_number] .condition_code]
elif数据类型==“ CT”：
输出=输出+ self.getSpaces（空格）+ self.night_forecast [day_number] .condition_text
elif数据类型==“ PC”：
字符串= self.night_forecast [day_number] .precip
如果self.isNumeric（string）== True：
字符串=字符串+ u»％»
输出=输出+ self.getSpaces（空格）+字符串
elif数据类型==“ HM”：
字符串= self.night_forecast [day_number]。湿度
如果self.isNumeric（string）== True：
字符串=字符串+ u»％»
输出=输出+ self.getSpaces（空格）+字符串
elif数据类型==“ WD”：
字符串= self.night_forecast [day_number] .wind_dir
如果self.locale ==“是”：
输出=输出+ self.getSpaces（空格）+ WeatherText.bearing_text_es [字符串]
elif self.locale ==“ fr”：
输出=输出+ self.getSpaces（空格）+ WeatherText.bearing_text_fr [string]
其他：
输出=输出+ self.getSpaces（空格）+字符串

elif数据类型==“ BF”：
输出=输出+ self.getSpaces（空格）+ WeatherText.bearing_arrow_font [self.night_forecast [day_number] .wind_dir]
elif数据类型==“ WS”：
字符串= self.night_forecast [day_number] .wind_speed
如果self.isNumeric（string）== True：
如果英制==真：
字符串= self.convertKilometresToMiles（字符串）
字符串=字符串+速度单位
输出=输出+ self.getSpaces（空格）+字符串
elif数据类型==“ WG”：
字符串= self.night_forecast [day_number] .wind_gusts
如果self.isNumeric（string）== True：
如果英制==真：
字符串= self.convertKilometresToMiles（字符串）
字符串=字符串+速度单位
输出=输出+ self.getSpaces（空格）+字符串
elif数据类型==“ CN”：
输出=输出+ self.getSpaces（空格）+ self.night_forecast [day_number] .city
elif数据类型==“ SR”：
输出=输出+ self.getSpaces（空格）+ self.night_forecast [day_number] .sunrise
elif数据类型==“ SS”：
输出=输出+ self.getSpaces（空格）+ self.night_forecast [day_number] .sunset
elif数据类型==“ MP”：
输出=输出+ self.getSpaces（空格）+ self.night_forecast [day_number] .moon_phase
elif数据类型==“ MF”：
输出=输出+ self.getSpaces（空格）+ WeatherText.conditions_moon_font [self.night_forecast [day_number] .moon_icon]
elif数据类型==“ BR”：
输出=输出+ self.getSpaces（空格）+ self.night_forecast [day_number] .bar_read
elif数据类型==“ BD”：
输出=输出+ self.getSpaces（空格）+ self.night_forecast [day_number] .bar_desc
其他：
输出=“ \ nERROR：请求的未知数据类型”
打破

否则：希望＃天预报

对于范围内的day_number（开始日期，结束日期+ 1）：

如果数据类型==“ DW”：
如果self.locale ==“是”：
如果shortweekday == True：
输出=输出+ self.getSpaces（空格）+ WeatherText.day_of_week_short_es [self.day_forecast [day_number] .day_of_week]
其他：
输出=输出+ self.getSpaces（空格）+ WeatherText.day_of_week_es [self.day_forecast [day_number] .day_of_week]
elif self.locale ==“ fr”：
如果shortweekday == True：
输出=输出+ self.getSpaces（空格）+ WeatherText.day_of_week_short_fr [self.day_forecast [day_number] .day_of_week]
其他：
输出=输出+ self.getSpaces（空格）+ WeatherText.day_of_week_fr [self.day_forecast [day_number] .day_of_week]
其他：
如果shortweekday == True：
输出=输出+ self.getSpaces（空格）+ WeatherText.day_of_week_short [self.day_forecast [day_number] .day_of_week]
其他：
输出=输出+ self.getSpaces（空间）+ WeatherText.day_of_week [self.day_forecast [day_number] .day_of_week]
elif数据类型==“ WF”：＃天气字体
输出=输出+ self.getSpaces（空格）+ WeatherText.conditions_weather_font [self.day_forecast [day_number] .condition_code]
elif数据类型==“ LT”：
字符串= self.day_forecast [day_number] .low
如果self.isNumeric（string）== True：
如果英制==真：
字符串= self.convertCelsiusToFahrenheit（字符串）
字符串=字符串+温度单位
输出=输出+ self.getSpaces（空格）+字符串
elif数据类型==“ HT”：
字符串= self.day_forecast [day_number] .high
如果self.isNumeric（string）== True：
如果英制==真：
字符串= self.convertCelsiusToFahrenheit（字符串）
字符串=字符串+温度单位
输出=输出+ self.getSpaces（空格）+字符串
elif数据类型==“ CC”：
如果self.locale ==“是”：
输出=输出+ self.getSpaces（空格）+ WeatherText.conditions_text_es [self.day_forecast [day_number] .condition_code]
elif self.locale ==“ fr”：
输出=输出+ self.getSpaces（空格）+ WeatherText.conditions_text_fr [self.day_forecast [day_number] .condition_code]
其他：
输出=输出+ self.getSpaces（空格）+ WeatherText.conditions_text [self.day_forecast [day_number] .condition_code]
elif数据类型==“ CT”：
输出=输出+ self.getSpaces（空格）+ self.day_forecast [day_number] .condition_text
elif数据类型==“ PC”：
字符串= self.day_forecast [day_number] .precip
如果self.isNumeric（string）== True：
字符串=字符串+ u»％»
输出=输出+ self.getSpaces（空格）+字符串
elif数据类型==“ HM”：
字符串= self.day_forecast [day_number]。湿度
如果self.isNumeric（string）== True：
字符串=字符串+ u»％»
输出=输出+ self.getSpaces（空格）+字符串
elif数据类型==“ WD”：
字符串= self.day_forecast [day_number] .wind_dir

如果self.locale ==“是”：
输出=输出+ self.getSpaces（空格）+ WeatherText.bearing_text_es [字符串]
elif self.locale ==“ fr”：
输出=输出+ self.getSpaces（空格）+ WeatherText.bearing_text_fr [string]
其他：
输出=输出+ self.getSpaces（空格）+字符串

elif数据类型==“ BF”：
输出=输出+ self.getSpaces（空格）+ WeatherText.bearing_arrow_font [self.day_forecast [day_number] .wind_dir]
elif数据类型==“ WS”：
字符串= self.day_forecast [day_number] .wind_speed
如果self.isNumeric（string）== True：
如果英制==真：
字符串= self.convertKilometresToMiles（字符串）
字符串=字符串+速度单位
输出=输出+ self.getSpaces（空格）+字符串
elif数据类型==“ WG”：
字符串= self.day_forecast [day_number] .wind_gusts
如果self.isNumeric（string）== True：
如果英制==真：
字符串= self.convertKilometresToMiles（字符串）
字符串=字符串+速度单位
输出=输出+ self.getSpaces（空格）+字符串
elif数据类型==“ CN”：
输出=输出+ self.getSpaces（空格）+ self.day_forecast [day_number] .city
elif数据类型==“ SR”：
输出=输出+ self.getSpaces（空格）+ self.day_forecast [day_number] .sunrise
elif数据类型==“ SS”：
输出=输出+ self.getSpaces（空格）+ self.day_forecast [day_number] .sunset
elif数据类型==“ MP”：
输出=输出+ self.getSpaces（空格）+ self.day_forecast [day_number] .moon_phase
elif数据类型==“ MF”：
输出=输出+ self.getSpaces（空格）+ WeatherText.conditions_moon_font [self.day_forecast [day_number] .moon_icon]
elif数据类型==“ BR”：
输出=输出+ self.getSpaces（空格）+ self.day_forecast [day_number] .bar_read
elif数据类型==“ BD”：
输出=输出+ self.getSpaces（空格）+ self.day_forecast [day_number] .bar_desc
其他：
输出= u»\ nERROR：请求的数据类型未知»
打破

输出= u»»+ output.strip（u»«）＃丢失前导/尾随空格
返回输出

＃除了：
#print“ getOutputText：意外错误：”，sys.exc_info（）[0]

def getOutputTextFromTemplate（自身，模板）：
＃尝试：

＃模板数据键
DATATYPE_KEY =“ –datatype =”
STARTDAY_KEY =“ –startday =”
ENDDAY_KEY =“ –endday =”
NIGHT_KEY =“ –night”
SHORTWEEKDAY_KEY =“ –shortweekday”
IMPERIAL_KEY =“ –imperial”
HIDEUNITS_KEY =“ –hideunits”
SPACES_KEY =“ –spaces =”

输出= u»»

optionfound =错误

＃加载文件
尝试：
fileinput =打开（self.options.template）
模板= fileinput.read（）
fileinput.close（）
除了：
输出= u»未找到模板文件！»

templatelist = self.getTemplateList（模板）

＃让我们遍历模板列表并确定找到的每个项目的输出
对于范围（0，len（templatelist）-1）中的i：

pos = templatelist [i] .find（DATATYPE_KEY）
如果pos！= -1：
optionfound =真
pos = pos + len（DATATYPE_KEY）
数据类型= 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（模板列表[i] [pos：pos + 4] .strip（“}”）。strip（“ {”）。strip（“-”）。strip（“”））
其他：
开始日期=无

pos = templatelist [i] .find（ENDDAY_KEY）
如果pos！= -1：
optionfound =真
pos = pos + len（ENDDAY_KEY）
endday = int（模板列表[i] [pos：pos + 4] .strip（“}”）。strip（“ {”）。strip（“-”）。strip（“”））
其他：
结束日=无

pos = templatelist [i] .find（NIGHT_KEY）
如果pos！= -1：
optionfound =真
夜晚=真实
其他：
夜=假

pos = templatelist [i] .find（SHORTWEEKDAY_KEY）
如果pos！= -1：
optionfound =真
短工作日 = 真
其他：
短工作日 = 错误

pos = templatelist [i] .find（IMPERIAL_KEY）
如果pos！= -1：
optionfound =真
英制=真
其他：
帝国=假

pos = templatelist [i] .find（HIDEUNITS_KEY）
如果pos！= -1：
optionfound =真
hideunits =真
其他：
hideunits =假

pos = templatelist [i] .find（SPACES_KEY）
如果pos！= -1：
optionfound =真
pos = pos + len（SPACES_KEY）
空格=整数（模板列表[i] [pos：pos + 4] .strip（«}»）。strip（«{«）。strip（«-«）。strip（»«））
其他：
空格= 1

如果optionfound == True：
templatelist [i] = self.getOutputText（数据类型，开始日期，结束日期，夜晚，短工作日，英制，hideunits，空格）
optionfound =错误

＃遍历列表，连接输出，因为它已经被填充了
对于templatelist中的项目：
输出=输出+项目

返回输出

＃除了：
#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（“ LOCATION”，self.options.location）
file_path_nightforecast = self.TEMP_FILEPATH_NIGHTFORECAST.replace（“ LOCATION”，self.options.location）

如果self.isConnectionAvailable（）==否：
如果os.path.exists（file_path_current）：
RefetchData =假
否则：＃没有连接，没有缓存，砰！
打印“没有可用的互联网连接，并且不存在缓存的天气数据。”
elif self.options.refetch ==真：
RefetchData = 真
其他：
＃是否需要再次检索数据？
如果os.path.exists（file_path_current）：
lastmodDate = time.localtime（os.stat（file_path_current）[ST_MTIME]）
expiryDate =（datetime.datetime.today（）-datetime.timedelta（分钟= self.EXPIRY_MINUTES））。timetuple（）

如果expiryDate> lastmodDate：
RefetchData = 真
其他：
RefetchData =假
其他：
RefetchData = 真

＃从网站或通过“取消提取”获取当前状况数据
如果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＆单位= m'
如果self.options.verbose == True：
打印>> sys.stdout，«从中获取天气数据«，网址

Usock = urllib2.urlopen（URL）
xml = usock.read（）
Usock.close（）
self.weatherxmldoc = minidom.parseString（xml）
除了：
打印“ fetchData：意外错误：”，sys.exc_info（）[0]
打印“无法联系天气情况以了解当前情况”

＃告诉用户位置是否错误…
找到= xml.find（“提供的位置无效”）
如果找到！= -1：
打印“提供的位置无效”

＃询问天气数据，加载到类结构中并对其进行腌制
尝试：

＃准备天气数据列表
self.current_conditions = []
self.day_forecast = []
self.night_forecast = []

＃收集一般数据
Weather_n = self.weatherxmldoc.documentElement
location_n = weather_n.getElementsByTagName（'loc'）[0]
city_n = location_n.getElementsByTagName（'dnam'）[0]
city = self.getText（city_n.childNodes）

＃收集当前条件数据
day_of_week = u»今天»
沉淀= u»N / A»
Sunrise_n = location_n.getElementsByTagName（'sunr'）[0]
日出= self.getText（sunrise_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（'icon'）[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（'gust'）[0]
wind_gusts = self.getText（wind_gust_n.childNodes）
wind_dir_n = wind_n.getElementsByTagName（'d'）[0]
wind_direction = self.getText（wind_dir_n.childNodes）
humidity_n = current_condition_n.getElementsByTagName（'hmid'）[0]
湿度= self.getText（燥度n.childNodes）
moon_n = current_condition_n.getElementsByTagName（'moon'）[0]
moon_icon_n = moon_n.getElementsByTagName（'icon'）[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 =天气数据（day_of_week，current_temp_feels，current_temp，current_code，current_desc，降水，湿度，风向，wind_speed，wind_gusts，城市，日出，日落，月相，moon_icon，bar_read，bar_desc）
self.current_conditions.append（current_conditions_data）

＃收集预测数据
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（'day'）

对于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（“低”）[0]
low_temp = self.getText（low_temp_n.childNodes）

Sunrise_n = day.getElementsByTagName（'sunr'）[0]
日出= self.getText（sunrise_n.childNodes）
sunset_n = day.getElementsByTagName（“太阳”）[0]
日落= self.getText（sunset_n.childNodes）

＃天天气预报的具体数据
daytime_n = day.getElementsByTagName（'part'）[0]＃天
condition_code_n = daytime_n.getElementsByTagName（'icon'）[0]
condition_code = self.getText（condition_code_n.childNodes）
condition_n = daytime_n.getElementsByTagName（'t'）[0]
条件= self.getText（condition_n.childNodes）
precip_n = daytime_n.getElementsByTagName（'ppcp'）[0]
precip = self.getText（precip_n.childNodes）
humidity_n = daytime_n.getElementsByTagName（'hmid'）[0]
湿度= self.getText（燥度n.childNodes）
wind_n = daytime_n.getElementsByTagName（'wind'）[0]
wind_speed_n = wind_n.getElementsByTagName（'s'）[0]
wind_speed = self.getText（wind_speed_n.childNodes）
wind_direction_n = wind_n.getElementsByTagName（'t'）[0]
wind_direction = self.getText（wind_direction_n.childNodes）
wind_gusts_n = wind_n.getElementsByTagName（'gust'）[0]
wind_gusts = self.getText（wind_gusts_n.childNodes）
day_forecast_data = WeatherData（day_of_week，low_temp，high_temp，condition_code，condition，precip，湿度，风向，风速，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（'icon'）[0]
condition_code = self.getText（condition_code_n.childNodes）
condition_n = daytime_n.getElementsByTagName（'t'）[0]
条件= self.getText（condition_n.childNodes）
precip_n = daytime_n.getElementsByTagName（'ppcp'）[0]
precip = self.getText（precip_n.childNodes）
humidity_n = daytime_n.getElementsByTagName（'hmid'）[0]
湿度= self.getText（燥度n.childNodes）
wind_n = daytime_n.getElementsByTagName（'wind'）[0]
wind_speed_n = wind_n.getElementsByTagName（'s'）[0]
wind_speed = self.getText（wind_speed_n.childNodes）
wind_direction_n = wind_n.getElementsByTagName（'t'）[0]
wind_direction = self.getText（wind_direction_n.childNodes）
wind_gusts_n = wind_n.getElementsByTagName（'gust'）[0]
wind_gusts = self.getText（wind_gusts_n.childNodes）
night_forecast_data =天气数据（day_of_week，low_temp，high_temp，condition_code，condition，precip，湿度，风向，风速，wind_gusts，城市，日出，日落，月相，moon_icon，bar_read，bar_desc）
self.night_forecast.append（night_forecast_data）

＃下次腌制数据！
fileoutput =打开（file_path_current，“ w”）
pickle.dump（self.current_conditions，文件输出）
fileoutput.close（）

fileoutput =打开（file_path_dayforecast，“ w”）
pickle.dump（self.day_forecast，文件输出）
fileoutput.close（）

fileoutput =打开（file_path_nightforecast，“ w”）
pickle.dump（self.night_forecast，文件输出）
fileoutput.close（）

除了：
打印“ fetchData：意外错误：”，sys.exc_info（）[0]
打印“无法查询天气数据”

否则：＃从腌制的类文件中获取天气数据
如果self.options.verbose == True：
打印>> sys.stdout，«从文件中获取天气数据：«，文件路径当前

fileinput =打开（file_path_current，'r'）
self.current_conditions = pickle.load（文件输入）
fileinput.close（）

如果self.options.verbose == True：
打印>> sys.stdout，“从文件中获取日天气预报数据：”，file_path_dayforecast，file_path_nightforecast

fileinput =打开（file_path_dayforecast，“ r”）
self.day_forecast = pickle.load（文件输入）
fileinput.close（）

如果self.options.verbose == True：
打印>> sys.stdout，“从文件中获取日天气预报数据：”，file_path_nightforecast，file_path_nightforecast

fileinput =打开（file_path_nightforecast，'r'）
self.night_forecast = pickle.load（文件输入）
fileinput.close（）

def outputData（个体）：
＃尝试：

如果self.options.template！=无：

输出= self.getOutputTextFromTemplate（self.options.template）

其他：

输出= 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__”：

解析器= CommandLineParser（）
（选项，args）= parser.parse_args（）

如果options.verbose == True：
打印>> sys.stdout，“位置：”，options.location
打印>> sys.stdout，“英制：”，options.imperial
打印>> sys.stdout，“数据类型：”，options.datatype
打印>> sys.stdout，“ night：”，options.night
打印>> sys.stdout，“开始日期：”，options.startday
打印>> sys.stdout，“结束日期：”，options.endday
打印>> sys.stdout，“空格：”，options.spaces
打印>> sys.stdout，“详细：”，options.verbose
打印>> sys.stdout，“ refetch：”，options.refetch

＃创建新的全球天气对象
天气= GlobalWeather（选项）
weather.fetchData（）
weather.outputData（）

我们创建文件〜/ Conky / scripts / myweather.template

gedit〜/ Conky /脚本/ myweather.template

我们将以下内容粘贴到其中：

{–数据类型= DW –开始日期= 1}：{–数据类型= CC –开始日期= 1}
{–数据类型= HT –开始日= 1} / {–数据类型= LT –开始日= 1}从{–数据类型= WD –开始日= 1}到{–数据类型= WS –开始日= 1}
湿度：{–数据类型= HM –开始日期= 1}降水：{–数据类型= PC –开始日期= 1}
日出：{–数据类型= SR –开始日期= 1}日落：{–数据类型= SS –开始日期= 1}
----------------
{–数据类型= DW –开始日期= 2}：{–数据类型= CC –开始日期= 2}
{–数据类型= HT –开始日= 2} / {–数据类型= LT –开始日= 2}从{–数据类型= WD –开始日= 2}到{–数据类型= WS –开始日= 2}
湿度：{–数据类型= HM –开始日期= 2}降水：{–数据类型= PC –开始日期= 2}
日出：{–数据类型= SR –开始日期= 2}日落：{–数据类型= SS –开始日期= 2}
----------------
{–数据类型= DW –开始日期= 3}：{–数据类型= CC –开始日期= 3}
{–数据类型= HT –开始日= 3} / {–数据类型= LT –开始日= 3}从{–数据类型= WD –开始日= 3}到{–数据类型= WS –开始日= 3}
湿度：{–数据类型= HM –开始日期= 3}降水：{–数据类型= PC –开始日期= 3}
日出：{–数据类型= SR –开始日期= 3}日落：{–数据类型= SS –开始日期= 3}
----------------
{–数据类型= DW –开始日期= 4}：{–数据类型= CC –开始日期= 4}
{–数据类型= HT –开始日= 4} / {–数据类型= LT –开始日= 4}从{–数据类型= WD –开始日= 4}到{–数据类型= WS –开始日= 4}
湿度：{–数据类型= HM –开始日期= 4}降水：{–数据类型= PC –开始日期= 4}
日出：{–数据类型= SR –开始日期= 4}日落：{–数据类型= SS –开始日期= 4}

我们创建文件〜/ Conky / scripts / mail / conkyEmail.py（我们必须创建邮件文件夹）

gedit〜/ Conky /脚本/ mail / conkyEmail.py

然后将以下内容粘贴到其中：

导入操作系统
导入字符串

＃在双引号下方输入您的用户名和密码
＃例如。 用户名=»用户名»和密码=»密码»
用户名=»YOUR_USUARIO_SINARROBA«
密码=»YOUR_KEY«

com =»wget -O-https：//»+用户名+»：»+密码+»@ mail.google.com /邮件/ feed /原子–无检查证书»

temp = os.popen（com）
msg = temp.read（）
索引= string.find（味精，» »）
index2 = string.find（msg，» »）
fc = int（msg [index + 11：index2]）

如果fc == 0：
打印“ 0新”
其他：
打印str（fc）+»新»

因此，现在您有7个文件：

在文件夹中：〜
-> .startconky <<-使可执行

在文件夹中：〜/ Conky
-> conkymain
-> conkyforecast
-> conkymail

并在文件夹中：〜/ Conky /脚本
-> conkyForecast.py <<-使可执行
-> myweather.template

并在文件夹中：〜/ Conky /脚本/邮件
conkyEmail.py <<-使可执行

就是这样，澄清，上面写着/ home / user / ...您的用户名，在Gmail数据所在的部分，我用彩色突出显示了您必须放置数据的位置。

杀死conky进程写入控制台

基拉·康基

运行conky写入控制台

./.startconky

调整好一切之后，如果要让conky开始每个会话

系统—>首选项—>会话，并在启动程序中将其添加

在Name中，我们可以将Conky编写为Order ./.startconky，以便每次打开PC时它将启动。

就是这样，希望对您有所帮助。