Conky, mein Setup

Ubunlog

37 Minuten

Fecfactor hat mich gestern gebeten, die Konfiguration des Conky zu veröffentlichen, die ich im folgenden Screenshot zeige

Wie Sie sehen, gibt es 3 Conkys, die mittels eines Skripts ausgeführt werden, dessen Konfiguration darauf basiert Diesen Beitrag Gepostet von Benutzer Bruce M. in den Foren von Ubuntu-Ar mit einigen modifikationen im mail conky, der in meinem fall für gmail ist.

Im Referenzbeitrag wird es von Bruce sehr gut erklärt, aber auch als Erinnerungshilfe für mich werde ich die folgenden Schritte und den Code meiner Conkys für jeden kopieren, der es hat.

Natürlich müssen Conky, Curl und Python installiert sein, damit wir eine Konsole eingeben können:

sudo apt-get installiere conky curl python

Die Quelle von weather.ttf und arrows.ttf ist hier. Die Quelle von moon.ttf ist hier Nach dem Herunterladen müssen Sie sie nach / usr / share / fonts kopieren

Lassen Sie uns nun unser Skript mit dem Namen ~. / Startconky erstellen

gksudo gedit ~ / .startconky

In die leere Datei fügen wir Folgendes ein

#! / Bin / bash
Schlaf 0 & # 0 gut für Xfce - benutze 20 bis 30 für Gnome
conky -c ~ / Conky / conkymain &
#sleep 0 & # 0 gut für Xfce - benutze 1 für Gnome
conky -c ~ / Conky / conkyforecast &
#sleep 0 & # 0 gut für Xfce - benutze 1 für Gnome
conky -c ~ / Conky / conkymail &

Jetzt erstellen wir die Conkymain-Datei im Ordner ~ / Conky. Wenn wir den Conky-Ordner nicht haben, müssen wir ihn erstellen.

gedit ~ / Conky / conkymain

Ich verwende die Schriftart Calibri. Wenn Sie sie nicht haben, ersetzen Sie sie durch das, was Sie wollen.

Wir bleiben im Folgenden

Hintergrund Nr
own_window ja
own_window_transparent ja
own_window_hints undecorated, unten, sticky, skip_taskbar, skip_pager
own_window_colour schwarz
double_buffer ja
use_spacer links
use_xft ja
Schriftkalibrierung: Größe = 9
xftfont kalibri: Größe = 9
xftalpha 0.5
update_interval 5.0
Nein in Großbuchstaben # wird auf Ja gesetzt, wenn der gesamte Text in Großbuchstaben geschrieben werden soll
getüpfelter_rand 3
Rand_Rand 9
border_width 10
default_color weiß
default_outline_color schwarz
default_shade_color schwarz
Farbe0 Cyan
color1 hellblau
Farbe2 Orange
Farbe3 gelb
color4 Weizen
color5 weiß
color6 weiß
color7 weiß
color8 weiß
color9 weiß
Ausrichtung top_right # oder top_left, bottom_left, bottom_right
Lücke_x 10
Lücke_y 35
text_buffer_size 128 # Verwenden Sie 1024 für die Prognose
no_buffers yes # Dateisystempuffer vom verwendeten Speicher subtrahieren?
draw_borders nein
draw_outline yes # verstärkt den Text, wenn ja
draw_shades yes # shadowcolor schwarz

TEXT
$ {font kalibri: size = 12} $ {alignc} $ {color1} $ sysname $ kernel auf $ machine} $ color $ font
$ {font kalibri: size = 12} $ {alignc} $ {color2} $ {exec whoami} @ $ nodename $ color $ font
$ {color0} $ {hr 1} $ color
$ {font kalibri: size = 20} $ {alignc} $ {time% H:% M} $ font
$ {font kalibri: size = 12} $ {color1} $ {alignc} $ {Zeit% A,% d% b. % Y} $ color $ font
$ {color3} UpTime: $ {alignr 2} $ uptime $ color
$ {color0} $ {hr 1} $ color
$ {voffset 5} $ {color2} CPU: $ {alignc} $ color $ running_processes $ {color1} / $ color $ verarbeitet $ {alignr 2} $ {color2} $ {cpubar cpu0 14,80} $ color
$ {color1} $ {voffset -16} $ {alignr 5} $ cpu% $ color
$ {voffset 2} $ {color1} Load Avg ($ {color3} Min $ {color1}): $ {alignr 2} $ {color3} 1: $ color $ {loadavg 1} $ {color3} 5: $ color $ {loadavg 2} $ {color3} 15: $ color $ {loadavg 3}
$ {voffset 5} $ {color2} RAM: $ color $ mem $ {color2} / $ color $ memmax $ {alignr 2} $ {color2} $ {membar 14,80} $ color
$ {color1} $ {voffset -16} $ {alignr 5} $ memperc% $ color
$ {voffset 2} $ {color1} Gepuffert: $ color $ {Puffer} $ {alignr 2} $ {color1} Zwischengespeichert: $ color $ {zwischengespeichert}
$ {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 Free $ {color1} - Gebraucht - $ {color2} Gesamt
$ {voffset 5} $ {color1} Root: $ color $ {fs_free_perc /}% $ {alignr 2} $ {fs_free /} $ {color2} / $ {color1} $ {fs_used /} $ color / $ {color2} $ {fs_size /} $ color
$ {color1} Home: $ color $ {fs_free_perc / home / user}% $ {alignr 2} $ {fs_free / home / user} $ {color2} / $ {color1} $ {fs_used / home / user} $ color / $ {color2} $ {fs_size / home / user} $ color
$ {color0} $ {hr 1} $ color
$ {color1} Von: $ color Buenos Aires, Argentinien
$ {color1} Lat: $ {color2} 34 ° 35'S $ {color1} Long: $ {color2} 58 ° 21'W $ {color1} Alt: $ {color2} 25 m $ Farbe
$ {voffset 5} $ {color2} $ {font kalibri: size = 12} heute: $ 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 Wetter: Größe = 50} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = WF} $ font $ color
$ {alignr 50} $ {voffset -55} $ {font kalibri: 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 $ Schriftart
$ {alignc 10} $ {voffset 5} $ {color4} Wind: $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = WS} $ color
$ {color1} Luftfeuchtigkeit: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = HM} $ {alignr 2} $ {color1} Niederschlag: $ {color3} $ { execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = PC} $ color
$ {alignc} $ {color1} Druck: $ {color3} $ {execi 3600 Python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = BR} - $ {color3} $ {execi 3600 Python ~ / Conky /scripts/conkyForecast.py –location = ARBA0009 –datatype = BD} $ color
$ {color4} $ {hr} $ color
$ {color1} Sunrise: $ {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 moon phase: size = 20} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = MF} $ font $ Farbe
$ {color0} $ {hr} $ color
$ {voffset 5} $ {color2} IP: $ {alignc} $ color $ {addr eth0}
$ {color1} Down: $ color $ {downspeed eth0} k / s $ {alignr 2} $ {color1} Up: $ color $ {upspeed eth0} k / s
$ {color1} Gesamt: $ color $ {totaldown eth0} $ {alignr 2} $ {color1} Gesamt: $ color $ {totalup eth0}
$ {color1} Eingehend: $ color $ {tcp_portmon 1 32767 count} $ {color1} Outbound: $ color $ {tcp_portmon 32768 61000 count} $ {alignr 2} $ {color1} Gesamt: $ color $ {tcp_portmon 1 65535 count}
$ {voffset 5} $ {color2} Verbindungen: $ 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

Wir erstellen die Datei ~ / Conky / conkyforecast

gedit ~ / Conky / conkyforecast

und wir fügen das Folgende ein

Hintergrund Nr
own_window ja
own_window_transparent ja
own_window_hints undecorated, unten, sticky, skip_taskbar, skip_pager
own_window_colour schwarz
double_buffer ja
use_spacer links
use_xft ja
Schriftkalibrierung: Größe = 8
xftfont kalibri: Größe = 8
xftalpha 0.5
update_interval 5.0
Nein in Großbuchstaben # wird auf Ja gesetzt, wenn der gesamte Text in Großbuchstaben geschrieben werden soll
getüpfelter_rand 3
Rand_Rand 9
border_width 10
default_color weiß
default_outline_color schwarz
default_shade_color schwarz
Farbe0 Cyan
color1 hellblau
Farbe2 Orange
Farbe3 gelb
color4 Weizen
color5 weiß
color6 weiß
color7 weiß
color8 weiß
color9 weiß
Ausrichtung bottom_left # oder top_left, bottom_left, bottom_right
Lücke_x 10
Lücke_y 35
text_buffer_size 1024 # Verwenden Sie 1024 für die Prognose
no_buffers yes # Dateisystempuffer vom verwendeten Speicher subtrahieren?
draw_borders nein
draw_outline yes # verstärkt den Text, wenn ja
draw_shades yes # shadowcolor schwarz

TEXT
$ {color4} $ {font kalibri: size = 11} Erweiterte Prognose $ font $ color
$ {color0} $ {hr} $ color
$ {color4} $ {font kalibri: size = 9} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –template = / home / user / Conky / scripts / myweather.template} $ font $ Farbe

Wir erstellen die Datei ~ / Conky / conkymail

gedit ~ / Conky / conkymail

Wir fügen Folgendes in die Datei ein

Hintergrund Nr
own_window ja
own_window_transparent ja
own_window_hints undecorated, unten, sticky, skip_taskbar, skip_pager
own_window_colour schwarz
double_buffer ja
use_spacer links
use_xft ja
Schriftkalibrierung: Größe = 8
xftfont kalibri: Größe = 8
xftalpha 0.5
update_interval 5.0
Nein in Großbuchstaben # wird auf Ja gesetzt, wenn der gesamte Text in Großbuchstaben geschrieben werden soll
getüpfelter_rand 3
Rand_Rand 9
border_width 10
default_color weiß
default_outline_color schwarz
default_shade_color schwarz
Farbe0 Cyan
color1 hellblau
Farbe2 Orange
Farbe3 gelb
color4 Weizen
color5 weiß
color6 weiß
color7 weiß
color8 weiß
color9 weiß
Ausrichtung bottom_left # oder top_left, bottom_left, bottom_right
Lücke_x 565
Lücke_y 35
text_buffer_size 128 # Verwenden Sie 1024 für die Prognose
no_buffers yes # Dateisystempuffer vom verwendeten Speicher subtrahieren?
draw_borders nein
draw_outline yes # verstärkt den Text, wenn ja
draw_shades yes # shadowcolor schwarz

TEXT
$ {font kalibri: size = 11} $ {alignc} $ {color4} Google Mail
$ {color0} $ {hr} $ color
$ {font kalibri: size = 11} $ {color4} Wir haben $ {color3} $ {execi 300 python ~ / Conky / scripts / mail / conkyEmail.py} $ {color4} E-Mail (s) $ font

Wir erstellen eine Datei in ~ / Conky / scripts / conkyForecast.py (wir müssen den Skriptordner erstellen)

gedit ~ / Conky / scripts / conkyForecast.py

#! / usr / bin / python
# - * - Codierung: utf-8 - * -
#################################################### ################################
# conkyForecast.py ist ein (nicht mehr so) einfaches (nicht mehr) zu erstellendes Python-Skript
# Details des aktuellen Wetters zur Verwendung in Conky.
#
# Autor: Kaivalagi
# Erstellt: 13
# Änderungen:
# 14 Tagesbereiche für Prognosedaten zulassen
# 14 Überprüfen Sie die Verbindung zum xoap-Dienst
# 18 Ermöglicht die Einstellung von Leerzeichen für die Fernausgabe
# 18 Ausgabe von Tag- und Nachtvorhersagen zulassen
# 18 Unterstützt das Gebietsschema für die Option «CC» des Bedingungscode-Textes und wartet auf die Übersetzung der spanischen Sprache
# 18 Verwenden Sie das Beizen für Klassendaten, anstatt XML zu öffnen. Dadurch wird die Notwendigkeit umgangen, zwischengespeicherte Daten abzufragen
# 19/04/2008 Spanischer Bedingungstext hinzugefügt - Danke Bruce M.
# 19 Isnumerische Prüfung aller numerischen Ausgaben mit Suffix Einheiten hinzugefügt
# 19 Die Benennung der Pickle-Datei wurde geändert, um den Standortcode einzuschließen
# 19 Konvertierung von spanischen Wochentagen über das Gebietsschema hinzugefügt
# 20 Parser für anständige Befehlsargumente hinzugefügt
# 20/04/2008 Option –shortweekday hinzugefügt, wenn der Datentyp Wochentag auf 3 Zeichen gekürzt wird
# 21 Feste Gebietsschemaoptionen für die Prognoseausgabe
# 21 Option –template hinzugefügt, um benutzerdefinierte Ausgabe mit einem einzigen Exec-Aufruf zu ermöglichen 🙂
# 21 Option –hideunits hinzugefügt, um beispielsweise mph und C aus der Ausgabe zu entfernen
# 23 - Die Option –imperial wurde aus der Vorlage entfernt. Diese Option MUSS als Standardoption für den Skriptaufruf festgelegt und nicht in der Vorlagendatei verwendet werden.
# 23/04/2008 Readded - imperiale Option zur Vorlage, die metrische oder imperiale Werte pro Datentyp aktiviert. Hinweis: Wenn Sie die Befehlszeilenoption für Vorlagen verwenden, funktioniert dies nicht.
# 23 Es wurde eine Ausgabe hinzugefügt, die den Benutzer benachrichtigt, wenn der angegebene Speicherort schlecht ist
# 24 Behandlung für keine Konnektivität hinzugefügt, wird jetzt auf zwischengespeicherte Daten zurückgesetzt (Fehler, wenn kein Cache vorhanden ist). Tests durch Versuch, xoap.weather.com zu öffnen
# 24 Die Umrechnung von Celsius in Fahrenheit wurde korrigiert
# 06/05/2008 Aktualisierte URL, die verwendet wurde, nachdem der Webservice aktualisiert wurde
# 09/05/2008 Konsolidierter aktueller Zustand und Prognosedaten werden in einem Anruf abgerufen
# 09/05/2008 Den Datentypen wurden Sonnenaufgang und Sonnenuntergang hinzugefügt. Diese sind sowohl für die aktuellen Bedingungen als auch für die Prognosedaten spezifisch
# 09/05/2008 Den Datentypen wurden Mondphase, Barometerablesung und Barometerbeschreibung hinzugefügt. Diese sind nur für die aktuellen Bedingungen spezifisch, ebenso wie N / A in der prognostizierten Ausgabe
# 09/05/2008 Einheitenumrechnungen für Barometer von mb in Zoll (imperial) hinzugefügt
# 09/05/2008 Aktualisierter spanischer Zustandstext - Danke Bruce M.
# 10/05/2008 Französische Gebietsschemadaten hinzugefügt - Danke benpaka
# 12/05/2008 Neuer BF-Datentyp (Peilungsschrift) hinzugefügt, um anstelle der NSEW-Ausgabe von WD (Windrichtung) ein Pfeilzeichen (Verwendung mit der Schriftart Arrow.ttf) bereitzustellen.
# 12/05/2008 Die WD-Ausgabe wurde länderspezifisch aktualisiert und unterstützt derzeit Standard-Englisch und Spanisch - Danke Bruce M.
# 18 Neuer MF-Datentyp (Mondschrift) hinzugefügt, um ein Mondschriftzeichen bereitzustellen (Zeichen falsch und noch keine dedizierte Schriftart).
# 21 Unter den aktuellen Bedingungen zeigt die Option –datatype = LT jetzt die Temperatur «fühlt sich an wie» an und nicht die aktuelle Temperatur
#
# ALLES:
# Konsolidieren Sie pkl-Dateien in einer Datei / Klasse
# Fügen Sie eine Wetterschrift hinzu, die auf der Mondphasenausgabe basierend auf den Mondikonendaten basiert
# ??? Gibt es noch weitere Anforderungen?

Importieren Sie sys, os, socket, urllib2, datetime, time
aus xml.dom Minidom importieren
vom stat import *
aus optparse importieren OptionParser
Gebietsschema importieren
gettext importieren
Gurke importieren
aus Mathe importieren *

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

Klasse CommandLineParser:

Parser = Keine

def __init __ (self):

self.parser = OptionParser ()
self.parser.add_option («- l», »- location», dest = »location», default = »UKXX0103 ″, type =» string », metavar =» CODE », help = u» Standortcode für Wetterdaten [ Standard:% Standard], Verwenden Sie die folgende URL, um Ihren Standortcode anhand des Städtenamens zu bestimmen: 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:% default] Die Datentypoptionen sind: DW (Wochentag), WF (Wetterschriftausgabe), LT (Vorhersage: Niedrige Temperatur, Strom: Fühlt sich wie Temperatur an), HT (Vorhersage: Hohe Temperatur, Strom: Aktuelle Temperatur), CC (Aktuell) Bedingungen), CT (Bedingungstext), PC (Niederschlagschance), HM (Luftfeuchtigkeit), WD (Windrichtung), WS (Windgeschwindigkeit), WG (Windböen), CN (Name der Stadt), SR (Sonnenaufgang), SS (Sonnenuntergang), MP (Mondphase), MF (Mondschrift), BR (Barometerablesung), BD (Barometerbeschreibung). Nicht anwendbar in der Befehlszeile bei Verwendung von Vorlagen. »)
self.parser.add_option («- s», »- startday», dest = »startday», type = »int», metavar = »NUMBER», help = u »definiere die Starttagnummer, wenn ausgelassene aktuelle Bedingungen ausgegeben werden Nicht anwendbar in der Befehlszeile bei Verwendung von Vorlagen. »)
self.parser.add_option ("- e", "- endday", dest = "endday", type = "int", metavar = "NUMBER", help = u "Definieren Sie die Nummer des Endtages, wenn nur die Daten des Starttages weggelassen werden wird ausgegeben. Gilt nicht für die Befehlszeile, wenn Vorlagen verwendet werden. »)
self.parser.add_option («- S», »- Leerzeichen», dest = »Leerzeichen», Typ = »int», Standard = 1, Metavar = »NUMBER», Hilfe = u »[Standard:% Standard] Definiert die Anzahl der Leerzeichen zwischen den Bereichsausgaben. Gilt nicht für die Befehlszeile, wenn Vorlagen verwendet werden. »)
self.parser.add_option («- t», »- Vorlage», Ziel = »Vorlage», Typ = »Zeichenfolge», Metavar = »DATEI», Hilfe = u »definiert eine Vorlagendatei, um die Ausgabe in einem Aufruf zu generieren. A. Das anzeigbare Element in der Datei hat die Form {–datatype = HT –startday = 1}. Folgende Optionen sind für jedes Element möglich: –datatype, –startday, –endday, –night, –shortweekday, –imperial, –hideunits, –Spaces. Beachten Sie, dass die Kurzformen der Optionen derzeit nicht unterstützt werden. Keine dieser Optionen ist in der Befehlszeile anwendbar, wenn Vorlagen verwendet werden. »)
self.parser.add_option («- L», »- Gebietsschema», dest = »Gebietsschema», Typ = »Zeichenfolge», help = u »überschreiben das Systemgebietsschema für die Sprachausgabe (en = Englisch, es = Spanisch, fr = Französisch, mehr zu kommen) »)
self.parser.add_option ("- i", "- imperial", dest = "imperial", default = False, action = "store_true", help = u "imperiale Einheiten anfordern, wenn die ausgelassene Ausgabe metrisch ist. Nicht anwendbar bei Befehlszeile bei Verwendung von Vorlagen. »)
self.parser.add_option («- n», »- night», dest = »night», default = False, action = »store_true», help = u »schalten Sie die Ausgabe auf Nachtdaten um, wenn die ausgelassene Tagesausgabe ausgegeben wird. Gilt nicht für die Befehlszeile, wenn Vorlagen verwendet werden. »)
self.parser.add_option («- w», »- kurzer Wochentag», dest = »kurzer Wochentag», Standard = False, action = »store_true», help = u »Verkürzen Sie den Datentyp des Wochentags auf 3 Zeichen. Nicht zutreffend bei Befehlszeile bei Verwendung von Vorlagen. »)
self.parser.add_option («- u», »- hideunits», dest = »hideunits», default = False, action = »store_true», help = u »Einheiten wie mph oder C ausblenden, Gradsymbole (°) sind wird immer noch angezeigt. Gilt nicht für die Befehlszeile, wenn Vorlagen verwendet werden. »)
self.parser.add_option ("- v", "- verbose", dest = "verbose", default = False, action = "store_true", help = u "ausführliche Ausgabe anfordern, keine gute Idee, wenn man durch conky läuft!" )
self.parser.add_option ("- r", "- refetch", dest = "refetch", default = False, action = "store_true", help = u "Daten unabhängig vom Datenablauf abrufen")

def parse_args (self):
(options, args) = self.parser.parse_args ()
return (Optionen, Argumente)

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

Klasse WeatherData:
def __init __ (self, day_of_week, low, high, condition_code, condition_text, Niederschlag, Luftfeuchtigkeit, wind_dir, wind_speed, wind_gusts, Stadt, Sonnenaufgang, Sonnenuntergang, Mondphase, Mond_icon, bar_read, bar_desc):
self.day_of_week = u »» + day_of_week
self.low = u »» + niedrig
self.high = u »» + high
self.condition_code = u »» + condition_code
self.condition_text = u »» + condition_text
self.precip = u »» + Niederschlag
Selbstfeuchtigkeit = u »» + Luftfeuchtigkeit
self.wind_dir = u »» + wind_dir
self.wind_speed = u »» + wind_speed
self.wind_gusts = u »» + wind_gusts
self.city = u »» + city
self.sunrise = u »» + Sonnenaufgang
self.sunset = u »» + sunset
self.moon_phase = u »» + moon_phase
self.moon_icon = u »» + moon_icon
self.bar_read = u »» + bar_read
self.bar_desc = u »» + bar_desc

Klasse WeatherText:

Bedingungen_text = {
«0»: _ (u »Tornado»),
«1»: _ (u »Tropensturm»),
«2»: _ (u »Hurrikan»),
«3»: _ (u »Schwere Gewitter»),
«4»: _ (u »Gewitter»),
«5»: _ (u »Gemischter Regen und Schnee»),
«6»: _ (u »Mischregen und Schneeregen»),
«7»: _ (u »Mischniederschlag»),
«8»: _ (u »Frostnieselregen»),
«9»: _ (u »Nieselregen»),
«10»: _ (u »Eisregen»),
«11»: _ (u »Duschen»),
«12»: _ (u »Duschen»),
«13»: _ (u »Schneegestöber»),
«14»: _ (u »leichte Schneeschauer»),
«15»: _ (u »Schneetreiben»),
«16»: _ (u »Schnee»),
«17»: _ (u »Hagel»),
«18»: _ (u »Schneeregen»),
«19»: _ (u »Staub»),
«20»: _ (u »Nebel»),
«21»: _ (u »Haze»),
«22»: _ (u »Rauch»),
«23»: _ (u »Blustery»),
«24»: _ (u »Windy»),
«25»: _ (u »kalt»),
«26»: _ (u »Bewölkt»),
«27»: _ (u »Meist bewölkt»),
«28»: _ (u »Meist bewölkt»),
«29»: _ (u »teilweise bewölkt»),
«30»: _ (u »teilweise bewölkt»),
«31»: _ (u »Löschen»),
«32»: _ (u »Löschen»),
«33»: _ (u »Messe»),
«34»: _ (u »Messe»),
«35»: _ (u »Gemischter Regen und Hagel»),
«36»: _ (u »Hot»),
«37»: _ (u »vereinzelte Gewitter»),
«38»: _ (u »Verstreute Gewitter»),
«39»: _ (u »Verstreute Gewitter»),
«40»: _ (u »vereinzelte Schauer»),
«41»: _ (u »Starker Schneefall»),
«42»: _ (u »vereinzelte Schneeschauer»),
«43»: _ (u »Starker Schneefall»),
«44»: _ (u »teilweise bewölkt»),
«45»: _ (u »Donnerschauer»),
«46»: _ (u »Schneeschauer»),
«47»: _ (u »vereinzelte Gewitter»),
«Na»: _ (u »N / A»),
"-": _(ein")
}

Bedingungen_text_es = {
«0»: _ (u »Tornado»),
«1»: _ (u »Tropensturm»),
«2»: _ (u »Huracá¡n»),
«3»: _ (u »Starke Stürme»),
«4»: _ (u »Stürme»),
«5»: _ (u »Gemischter Regen und Schnee»),
«6»: _ (u »Mischregen und Schneeregen»),
«7»: _ (u »Schneeregen»),
«8»: _ (u »Frostnieselregen»),
«9»: _ (u »Nieselregen»),
«10»: _ (u »Eisregen»), # oder Eisregen
«11»: _ (u »Duschen»),
«12»: _ (u »Duschen»),
«13»: _ (u »Leichter Schnee»),
«14»: _ (u »Leichter Schnee»),
«15»: _ (u »Schneesturm»),
«16»: _ (u »Schnee»),
«17»: _ (u »Hagel»),
«18»: _ (u »Schneeregen»),
«19»: _ (u »Pulver»),
«20»: _ (u »Nebel»),
«21»: _ (u »Haze»),
«22»: _ (u »Rauch»),
«23»: _ (u »Sturm»),
«24»: _ (u »Windy»),
«25»: _ (u »Fráo»),
«26»: _ (u »Sehr bewölkt»),
«27»: _ (u »Meist bewölkt»),
«28»: _ (u »Meist bewölkt»),
«29»: _ (u »teilweise bewölkt»),
«30»: _ (u »teilweise bewölkt»),
«31»: _ (u »Löschen»),
«32»: _ (u »Löschen»),
«33»: _ (u »Etwas Bewölktes»),
«34»: _ (u »Etwas Bewölktes»),
«35»: _ (u »Regen mit Hagel»),
«36»: _ (u »Hitze»),
«37»: _ (u »vereinzelte Stürme»),
«38»: _ (u »Verstreute Stürme»),
«39»: _ (u »Verstreute Stürme»),
«40»: _ (u »vereinzelte Schauer»),
«41»: _ (u »Starker Schneefall»),
«42»: _ (u »Schwache und vereinzelte Schneefälle»),
«43»: _ (u »Intense Nevada»),
«44»: _ (u »Verstreute Wolken»),
«45»: _ (u »Stürme»),
«46»: _ (u »vereinzelte Schneefälle»),
«47»: _ (u »vereinzelte Stürme»),
«Na»: _ (u »N / A»),
"-": _(ein")
}

Bedingungen_text_fr = {
«0»: _ (u »Tornade»),
«1»: _ (u »Tempête Tropicale»),
«2»: _ (oder »Ouragan»),
«3»: _ (oder »Orages Violents»),
«4»: _ (oder »Orageux»),
«5»: _ (u »Pluie et Neige»),
«6»: _ (u »Pluie et Neige Mouillée»),
«7»: _ (u »Variable avec averses»),
«8»: _ (u »Bruine Givrante»),
«9»: _ (u »Bruine»),
«10»: _ (u »Pluie Glacante»),
«11»: _ (u »Averses»),
«12»: _ (u »Averses»),
«13»: _ (u »Légère Neige»),
«14»: _ (u »Forte Neige»),
«15»: _ (u »Tempête de Neige»),
«16»: _ (u »Neige»),
«17»: _ (u »Grêle»),
«18»: _ (u »Pluie / Neige»),
«19»: _ (u »Nuage de poussière»),
«20»: _ (u »Brouillard»),
«21»: _ (u »Brume»),
«22»: _ (u »Fumée»),
«23»: _ (u »Tres Venteux»),
«24»: _ (u »Venteux»),
«25»: _ (u »Froid»),
«26»: _ (u »Nuageux»),
«27»: _ (u »Tres Nuageux»),
«28»: _ (u »Tres Nuageux»),
«29»: _ (u »Nuages ​​Disséminés»),
«30»: _ (u »Nuages ​​Disséminés»),
«31»: _ (u »Beau»),
«32»: _ (u »Beau»),
«33»: _ (u »Belles Éclaircies»),
«34»: _ (u »Belles Éclaircies»),
«35»: _ (u »Pluie avec Grêle»),
«36»: _ (u »Chaleur»),
«37»: _ (oder »Orages Isolés»),
«38»: _ (oder »Orages Localisés»),
«39»: _ (oder »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»: _ (oder »Orages»),
«46»: _ (u »Tempête de Neige»),
«47»: _ (oder »Orages Isolés»),
«Na»: _ (u »N / A»),
"-": _(ein")
}

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

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

wochentag = {
"Heute": _ (oder "Heute"),
«Montag»: _ (u »Montag»),
«Dienstag»: _ (u »Dienstag»),
«Mittwoch»: _ (u »Mittwoch»),
«Donnerstag»: _ (u »Donnerstag»),
«Freitag»: _ (u »Freitag»),
"Samstag": _ (u "Samstag"),
"Sonntag": _ (u "Sonntag")
}

day_of_week_short = {
"Heute": _ (u "Jetzt"),
«Montag»: _ (u »Mo»),
«Dienstag»: _ (u »Di»),
«Mittwoch»: _ (u »Mi»),
«Donnerstag»: _ (u »Do»),
«Freitag»: _ (u »Fr»),
"Samstag": _ (u "Sa"),
"Sonntag": _ (u "Sonne")
}

wochentag_es = {
"Heute": _ (u "heute"),
«Montag»: _ (u »Montag»),
«Dienstag»: _ (u »Dienstag»),
«Mittwoch»: _ (u »Mittwoch»),
«Donnerstag»: _ (u »Donnerstag»),
«Freitag»: _ (u »Freitag»),
"Samstag": _ (u "Samstag"),
"Sonntag": _ (u "Sonntag")
}

day_of_week_short_de = {
"Heute": _ (u "heute"),
"Montag": _ (u "mon"),
«Dienstag»: _ (u »Meer»),
«Mittwoch»: _ (u »wed»),
«Donnerstag»: _ (u »Do»),
«Freitag»: _ (u »fri»),
"Samstag": _ (u "saß"),
"Sonntag": _ (u "dom")
}

day_of_week_fr = {
«Heute»: _ (u »Aujourd'hui»),
«Montag»: _ (u »Lundi»),
«Dienstag»: _ (u »Mardi»),
«Mittwoch»: _ (u »Mercredi»),
«Donnerstag»: _ (u »Jeudi»),
«Freitag»: _ (u »Vendredi»),
"Samstag": _ (u "Samedi"),
"Sonntag": _ (u "Dimanche")
}

day_of_week_short_fr = {
«Heute»: _ (u »Auj»),
"Montag": _ (u "Mo"),
«Dienstag»: _ (u »März»),
"Mittwoch": _ (u "Mer"),
«Donnerstag»: _ (u »Jeu»),
«Freitag»: _ (u »Komm»),
"Samstag": _ (u "Sam"),
"Sonntag": _ (u "Dim")
}

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

Bearing_text_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"),
"Ihr"),
"SSW": _ (u "SSO"),
«SW»: _ (u »SO»),
"WSW": _ (u "WOW"),
«W»: _ (u »O»),
«WNW»: _ (u »ONO»),
«NW»: _ (u »NEIN»),
«NNW»: _ (u »NNO»),
«N / A»: _ (u »N \ A»)
}

Bearing_text_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"),
"Ihr"),
"SSW": _ (u "SSO"),
«SW»: _ (u »SO»),
"WSW": _ (u "WOW"),
«W»: _ (u »O»),
«WNW»: _ (u »ONO»),
«NW»: _ (u »NEIN»),
«NNW»: _ (u »NNO»),
«N / A»: _ (u »N \ A»)
}

Klasse GlobalWeather:

aktuelle_bedingungen = []
day_forecast = []
night_forecast = []

locale = "in"

Optionen = Keine
Wetterxmldoc = «»

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 __ (Selbst, Optionen):

self.options = Optionen

if self.options.locale == Keine:
Versuchen:
# self.locale = locale.getdefaultlocale () [0] [0: 2]
self.locale = «es» # Kommentieren Sie diese Zeile aus, um das spanische Gebietsschema zu erzwingen
# self.locale = "fr" # Kommentieren Sie diese Zeile aus, um das französische Gebietsschema zu erzwingen
außer:
print "Gebietsschema nicht festgelegt"
sonst:
# self.locale = self.options.locale
self.locale = «es» # Kommentieren Sie diese Zeile aus, um das spanische Gebietsschema zu erzwingen
# self.locale = "fr" # Kommentieren Sie diese Zeile aus, um das französische Gebietsschema zu erzwingen

if self.options.verbose == True:
print >> sys.stdout, "locale set to", self.locale

def getText (self, nodelist):
rc = ""
für Knoten in der Knotenliste:
wenn node.nodeType == node.TEXT_NODE:
rc = rc + node.data
zurück rc

def getSpaces (Selbst, Leerzeichen):
string = u »»
if Leerzeichen == Keine:
Zeichenfolge = self.DEFAULT_SPACING
sonst:
für i im Bereich (0, Leerzeichen + 1):
string = string + u »«
Rückgabezeichenfolge

def isNumeric (self, string):
Versuchen:
Dummy = Float (String)
true zurückgeben
außer:
falsch zurückgeben

def isConnectionAvailable (self):
# Stellen Sie sicher, dass wir auf den Server von weather.com zugreifen können, indem Sie die URL öffnen
Versuchen:
Usock = urllib2.urlopen ('http://xoap.weather.com')
Usock.close ()
true zurückgeben
außer:
falsch zurückgeben

def getBearingText (Selbst, Lager):
Lager = Schwimmer (Lager)
wenn Lager <11.25:
Rückgabe u »N»
Elif Lager <33.75:
Rückkehr u »NNE»
Elif Lager <56.25:
Rückkehr u »NE»
Elif Lager <78.75:
Rückkehr u »JAN»
Elif Lager <101.25:
Rückgabe u »E»
Elif Lager <123.75:
Rückgabe u »ESE»
Elif Lager <146.25:
Rückkehr u »SE»
Elif Lager <168.75:
Rückgabe u »SSE»
Elif Lager <191.25:
Rückgabe u »S»
Elif Lager <213.75:
Rückgabe u »SSW»
Elif Lager <236.25:
Rückgabe u »SW»
Elif Lager <258.75:
Rückkehr u »WSW»
Elif Lager <281.25:
Rückgabe u »W»
Elif Lager <303.75:
Rückkehr u »WNW»
Elif Lager <326.25:
Rückkehr u »NW»
Elif Lager <348.75:
Rückgabe u »NNW»
sonst:
Rückgabe «N / A»

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

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

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

def getTemplateList (self, template):

Templatelist = []

für template_part in template.split («{«):
if template_part! = «»:
für template_part in template_part.split ("}"):
if template_part! = «»:
templatelist.append (u »» + template_part)

Templateliste zurückgeben

def getOutputText (self, datatype, startday, endday, night, shortweekday, imperial, hideunits, Leerzeichen):
#Versuchen:
Ausgabe = u »»

# aktuelle Einheiten für die Ausgabe definieren
if hideunits == Falsch:
wenn imperial == Falsch:
Tempunit = u »° C»
speedunit = u »kph»
Druckeinheit = u »mb»
sonst:
Tempunit = u »° F»
speedunit = u »mph»
Druckeinheit = u »in»
sonst:
tempunit = u »°»
speedunit = u »»
Druckeinheit = u »»

if startday == Keine: # aktuelle Bedingungen

if datatype == "DW":
if self.locale == "is":
if shortweekday == True:
output = WeatherText.day_of_week_short_es [self.current_conditions [0] .day_of_week]
sonst:
output = WeatherText.day_of_week_es [self.current_conditions [0] .day_of_week]
elif self.locale == "fr":
if shortweekday == True:
output = WeatherText.day_of_week_short_fr [self.current_conditions [0] .day_of_week]
sonst:
output = WeatherText.day_of_week_fr [self.current_conditions [0] .day_of_week]
sonst:
if shortweekday == True:
output = WeatherText.day_of_week_short [self.current_conditions [0] .day_of_week]
sonst:
output = WeatherText.day_of_week [self.current_conditions [0] .day_of_week]
elif datatype == "WF": # Wetterschriftart
output = WeatherText.conditions_weather_font [self.current_conditions [0] .condition_code]
elif-Datentyp == "LT":
string = self.current_conditions [0] .low
if self.isNumeric (string) == True:
wenn imperial == Wahr:
string = self.convertCelsiusToFahrenheit (string)
Zeichenfolge = Zeichenfolge + Tempunit
Ausgabe = Zeichenfolge
elif-Datentyp == "HT":
string = self.current_conditions [0] .high
if self.isNumeric (string) == True:
wenn imperial == Wahr:
string = self.convertCelsiusToFahrenheit (string)
Zeichenfolge = Zeichenfolge + Tempunit
Ausgabe = Zeichenfolge
elif-Datentyp == "CC":
if self.locale == "is":
output = WeatherText.conditions_text_es [self.current_conditions [0] .condition_code]
elif self.locale == "fr":
output = WeatherText.conditions_text_fr [self.current_conditions [0] .condition_code]
sonst:
output = WeatherText.conditions_text [self.current_conditions [0] .condition_code]
elif-Datentyp == "CT":
output = self.current_conditions [0] .condition_text
elif Datentyp == "PC":
string = self.current_conditions [0] .precip
if self.isNumeric (string) == True:
string = string + u »%»
Ausgabe = Zeichenfolge
elif-Datentyp == "HM":
string = self.current_conditions [0] .humidity
if self.isNumeric (string) == True:
string = string + u »%»
Ausgabe = Zeichenfolge
elif-Datentyp == "WD":
string = self.current_conditions [0] .wind_dir
if self.isNumeric (string) == True:
string = self.getBearingText (string)

if self.locale == "is":
output = WeatherText.bearing_text_es [string]
elif self.locale == "fr":
output = WeatherText.bearing_text_fr [string]
sonst:
Ausgabe = Zeichenfolge

elif-Datentyp == "BF":
string = self.current_conditions [0] .wind_dir
if self.isNumeric (string) == True:
string = WeatherText.bearing_arrow_font [self.getBearingText (string)]
Ausgabe = Zeichenfolge
elif-Datentyp == "WS":
string = self.current_conditions [0] .wind_speed
if self.isNumeric (string) == True:
wenn imperial == Wahr:
string = self.convertKilometresToMiles (string)
Zeichenfolge = Zeichenfolge + Geschwindigkeitseinheit
Ausgabe = Zeichenfolge
elif-Datentyp == "WG":
string = self.current_conditions [0] .wind_gusts
if self.isNumeric (string) == True:
wenn imperial == Wahr:
string = self.convertKilometresToMiles (string)
Zeichenfolge = Zeichenfolge + Geschwindigkeitseinheit
Ausgabe = Zeichenfolge
elif-Datentyp == "CN":
output = self.current_conditions [0] .city
elif-Datentyp == "SR":
output = self.current_conditions [0] .sunrise
elif-Datentyp == "SS":
output = self.current_conditions [0] .sunset
elif-Datentyp == "MP":
output = self.current_conditions [0] .moon_phase
elif-Datentyp == "MF":
output = WeatherText.conditions_moon_font [self.current_conditions [0] .moon_icon]
elif-Datentyp == "BR":
string = self.current_conditions [0] .bar_read
if self.isNumeric (string) == True:
wenn imperial == Wahr:
string = self.convertMillibarsToInches (string)
string = string + druckeinheit
Ausgabe = Zeichenfolge
elif-Datentyp == "BD":
output = self.current_conditions [0] .bar_desc
sonst:
output = "\ nFEHLER: Unbekannter Datentyp angefordert"

sonst: # Prognosedaten

if endday == None: # Wenn kein Endtag festgelegt wurde, verwenden Sie startday
Endtag = Starttag

if night == True: # Nachtvorhersage erforderlich

für Tag_Nummer im Bereich (Starttag, Endtag + 1):

if datatype == "DW":
if self.locale == "is":
if shortweekday == True:
output = output + self.getSpaces (Leerzeichen) + WeatherText.day_of_week_short_es [self.night_forecast [day_number] .day_of_week]
sonst:
output = output + self.getSpaces (Leerzeichen) + WeatherText.day_of_week_es [self.night_forecast [day_number] .day_of_week]
elif self.locale == "fr":
if shortweekday == True:
output = output + self.getSpaces (Leerzeichen) + WeatherText.day_of_week_short_fr [self.night_forecast [day_number] .day_of_week]
sonst:
output = output + self.getSpaces (Leerzeichen) + WeatherText.day_of_week_fr [self.night_forecast [day_number] .day_of_week]
sonst:
if shortweekday == True:
output = output + self.getSpaces (Leerzeichen) + WeatherText.day_of_week_short [self.night_forecast [day_number] .day_of_week]
sonst:
output = output + self.getSpaces (Leerzeichen) + WeatherText.day_of_week [self.night_forecast [day_number] .day_of_week]
elif datatype == "WF": # Wetterschriftart
output = output + self.getSpaces (Leerzeichen) + WeatherText.conditions_weather_font [self.night_forecast [day_number] .condition_code]
elif-Datentyp == "LT":
string = self.night_forecast [day_number] .low
if self.isNumeric (string) == True:
wenn imperial == Wahr:
string = self.convertCelsiusToFahrenheit (string)
Zeichenfolge = Zeichenfolge + Tempunit
output = output + self.getSpaces (Leerzeichen) + string

elif-Datentyp == "HT":
string = self.night_forecast [day_number] .high
if self.isNumeric (string) == True:
wenn imperial == Wahr:
string = self.convertCelsiusToFahrenheit (string)
Zeichenfolge = Zeichenfolge + Tempunit
output = output + self.getSpaces (Leerzeichen) + string
elif-Datentyp == "CC":
if self.locale == "is":
output = output + self.getSpaces (Leerzeichen) + WeatherText.conditions_text_es [self.night_forecast [day_number] .condition_code]
elif self.locale == "fr":
output = output + self.getSpaces (Leerzeichen) + WeatherText.conditions_text_fr [self.night_forecast [day_number] .condition_code]
sonst:
output = output + self.getSpaces (Leerzeichen) + WeatherText.conditions_text [self.night_forecast [day_number] .condition_code]
elif-Datentyp == "CT":
output = output + self.getSpaces (Leerzeichen) + self.night_forecast [day_number] .condition_text
elif Datentyp == "PC":
string = self.night_forecast [day_number] .precip
if self.isNumeric (string) == True:
string = string + u »%»
output = output + self.getSpaces (Leerzeichen) + string
elif-Datentyp == "HM":
string = self.night_forecast [day_number] .humidity
if self.isNumeric (string) == True:
string = string + u »%»
output = output + self.getSpaces (Leerzeichen) + string
elif-Datentyp == "WD":
string = self.night_forecast [day_number] .wind_dir
if self.locale == "is":
output = output + self.getSpaces (Leerzeichen) + WeatherText.bearing_text_es [string]
elif self.locale == "fr":
output = output + self.getSpaces (Leerzeichen) + WeatherText.bearing_text_fr [string]
sonst:
output = output + self.getSpaces (Leerzeichen) + string

elif-Datentyp == "BF":
output = output + self.getSpaces (Leerzeichen) + WeatherText.bearing_arrow_font [self.night_forecast [day_number] .wind_dir]
elif-Datentyp == "WS":
string = self.night_forecast [day_number] .wind_speed
if self.isNumeric (string) == True:
wenn imperial == Wahr:
string = self.convertKilometresToMiles (string)
Zeichenfolge = Zeichenfolge + Geschwindigkeitseinheit
output = output + self.getSpaces (Leerzeichen) + string
elif-Datentyp == "WG":
string = self.night_forecast [day_number] .wind_gusts
if self.isNumeric (string) == True:
wenn imperial == Wahr:
string = self.convertKilometresToMiles (string)
Zeichenfolge = Zeichenfolge + Geschwindigkeitseinheit
output = output + self.getSpaces (Leerzeichen) + string
elif-Datentyp == "CN":
output = output + self.getSpaces (Leerzeichen) + self.night_forecast [day_number] .city
elif-Datentyp == "SR":
output = output + self.getSpaces (Leerzeichen) + self.night_forecast [day_number] .sunrise
elif-Datentyp == "SS":
output = output + self.getSpaces (Leerzeichen) + self.night_forecast [day_number] .sunset
elif-Datentyp == "MP":
output = output + self.getSpaces (Leerzeichen) + self.night_forecast [day_number] .moon_phase
elif-Datentyp == "MF":
output = output + self.getSpaces (Leerzeichen) + WeatherText.conditions_moon_font [self.night_forecast [day_number] .moon_icon]
elif-Datentyp == "BR":
output = output + self.getSpaces (Leerzeichen) + self.night_forecast [day_number] .bar_read
elif-Datentyp == "BD":
output = output + self.getSpaces (Leerzeichen) + self.night_forecast [day_number] .bar_desc
sonst:
output = "\ nFEHLER: Unbekannter Datentyp angefordert"
brechen

sonst: # Tagesvorhersage gesucht

für Tag_Nummer im Bereich (Starttag, Endtag + 1):

if datatype == "DW":
if self.locale == "is":
if shortweekday == True:
output = output + self.getSpaces (Leerzeichen) + WeatherText.day_of_week_short_es [self.day_forecast [day_number] .day_of_week]
sonst:
output = output + self.getSpaces (Leerzeichen) + WeatherText.day_of_week_es [self.day_forecast [day_number] .day_of_week]
elif self.locale == "fr":
if shortweekday == True:
output = output + self.getSpaces (Leerzeichen) + WeatherText.day_of_week_short_fr [self.day_forecast [day_number] .day_of_week]
sonst:
output = output + self.getSpaces (Leerzeichen) + WeatherText.day_of_week_fr [self.day_forecast [day_number] .day_of_week]
sonst:
if shortweekday == True:
output = output + self.getSpaces (Leerzeichen) + WeatherText.day_of_week_short [self.day_forecast [day_number] .day_of_week]
sonst:
output = output + self.getSpaces (Leerzeichen) + WeatherText.day_of_week [self.day_forecast [day_number] .day_of_week]
elif datatype == "WF": # Wetterschriftart
output = output + self.getSpaces (Leerzeichen) + WeatherText.conditions_weather_font [self.day_forecast [day_number] .condition_code]
elif-Datentyp == "LT":
string = self.day_forecast [day_number] .low
if self.isNumeric (string) == True:
wenn imperial == Wahr:
string = self.convertCelsiusToFahrenheit (string)
Zeichenfolge = Zeichenfolge + Tempunit
output = output + self.getSpaces (Leerzeichen) + string
elif-Datentyp == "HT":
string = self.day_forecast [day_number] .high
if self.isNumeric (string) == True:
wenn imperial == Wahr:
string = self.convertCelsiusToFahrenheit (string)
Zeichenfolge = Zeichenfolge + Tempunit
output = output + self.getSpaces (Leerzeichen) + string
elif-Datentyp == "CC":
if self.locale == "is":
output = output + self.getSpaces (Leerzeichen) + WeatherText.conditions_text_es [self.day_forecast [day_number] .condition_code]
elif self.locale == "fr":
output = output + self.getSpaces (Leerzeichen) + WeatherText.conditions_text_fr [self.day_forecast [day_number] .condition_code]
sonst:
output = output + self.getSpaces (Leerzeichen) + WeatherText.conditions_text [self.day_forecast [day_number] .condition_code]
elif-Datentyp == "CT":
output = output + self.getSpaces (Leerzeichen) + self.day_forecast [day_number] .condition_text
elif Datentyp == "PC":
string = self.day_forecast [day_number] .precip
if self.isNumeric (string) == True:
string = string + u »%»
output = output + self.getSpaces (Leerzeichen) + string
elif-Datentyp == "HM":
string = self.day_forecast [day_number] .humidity
if self.isNumeric (string) == True:
string = string + u »%»
output = output + self.getSpaces (Leerzeichen) + string
elif-Datentyp == "WD":
string = self.day_forecast [day_number] .wind_dir

if self.locale == "is":
output = output + self.getSpaces (Leerzeichen) + WeatherText.bearing_text_es [string]
elif self.locale == "fr":
output = output + self.getSpaces (Leerzeichen) + WeatherText.bearing_text_fr [string]
sonst:
output = output + self.getSpaces (Leerzeichen) + string

elif-Datentyp == "BF":
output = output + self.getSpaces (Leerzeichen) + WeatherText.bearing_arrow_font [self.day_forecast [day_number] .wind_dir]
elif-Datentyp == "WS":
string = self.day_forecast [day_number] .wind_speed
if self.isNumeric (string) == True:
wenn imperial == Wahr:
string = self.convertKilometresToMiles (string)
Zeichenfolge = Zeichenfolge + Geschwindigkeitseinheit
output = output + self.getSpaces (Leerzeichen) + string
elif-Datentyp == "WG":
string = self.day_forecast [day_number] .wind_gusts
if self.isNumeric (string) == True:
wenn imperial == Wahr:
string = self.convertKilometresToMiles (string)
Zeichenfolge = Zeichenfolge + Geschwindigkeitseinheit
output = output + self.getSpaces (Leerzeichen) + string
elif-Datentyp == "CN":
output = output + self.getSpaces (Leerzeichen) + self.day_forecast [day_number] .city
elif-Datentyp == "SR":
output = output + self.getSpaces (Leerzeichen) + self.day_forecast [day_number] .sunrise
elif-Datentyp == "SS":
output = output + self.getSpaces (Leerzeichen) + self.day_forecast [day_number] .sunset
elif-Datentyp == "MP":
output = output + self.getSpaces (Leerzeichen) + self.day_forecast [day_number] .moon_phase
elif-Datentyp == "MF":
output = output + self.getSpaces (Leerzeichen) + WeatherText.conditions_moon_font [self.day_forecast [day_number] .moon_icon]
elif-Datentyp == "BR":
output = output + self.getSpaces (Leerzeichen) + self.day_forecast [day_number] .bar_read
elif-Datentyp == "BD":
output = output + self.getSpaces (Leerzeichen) + self.day_forecast [day_number] .bar_desc
sonst:
output = u »\ nFEHLER: Unbekannter Datentyp angefordert»
brechen

output = u »» + output.strip (u »«) # verliert führende / nachfolgende Leerzeichen
Ausgabe zurückgeben

#außer:
#print "getOutputText: Unerwarteter Fehler:", sys.exc_info () [0]

def getOutputTextFromTemplate (self, template):
#Versuchen:

# Schlüssel zu Vorlagendaten
DATATYPE_KEY = "–datatype ="
STARTDAY_KEY = "–startday ="
ENDDAY_KEY = "–endday ="
NIGHT_KEY = "–Nacht"
SHORTWEEKDAY_KEY = "–kurzer Wochentag"
IMPERIAL_KEY = "–imperial"
HIDEUNITS_KEY = "–hideunits"
SPACES_KEY = "–spaces ="

Ausgabe = u »»

optionfound = Falsch

# Laden Sie die Datei
Versuchen:
fileinput = open (self.options.template)
template = fileinput.read ()
fileinput.close ()
außer:
output = u »Vorlagendatei nicht gefunden!»

templatelist = self.getTemplateList (Vorlage)

# Lassen Sie uns durch die Vorlagenliste gehen und die Ausgabe für jedes gefundene Element bestimmen
für i im Bereich (0, len (Vorlagenliste) -1):

pos = Vorlagenliste [i] .find (DATATYPE_KEY)
wenn pos! = -1:
optionfound = True
pos = pos + len (DATATYPE_KEY)
Datentyp = Vorlagenliste [i] [pos: pos + 4] .strip («}»). strip («{«). strip («-«). strip (»«)
sonst:
Datentyp = Keine

pos = Vorlagenliste [i] .find (STARTDAY_KEY)
wenn pos! = -1:
optionfound = True
pos = pos + len (STARTDAY_KEY)
startday = int (Vorlagenliste [i] [pos: pos + 4] .strip ("}"). strip ("{"). strip ("-"). strip (""))
sonst:
Starttag = Keine

pos = Vorlagenliste [i] .find (ENDDAY_KEY)
wenn pos! = -1:
optionfound = True
pos = pos + len (ENDDAY_KEY)
endday = int (Vorlagenliste [i] [pos: pos + 4] .strip ("}"). strip ("{"). strip ("-"). strip (""))
sonst:
Endtag = Keine

pos = Vorlagenliste [i] .find (NIGHT_KEY)
wenn pos! = -1:
optionfound = True
Nacht = Richtig
sonst:
Nacht = Falsch

pos = Vorlagenliste [i] .find (SHORTWEEKDAY_KEY)
wenn pos! = -1:
optionfound = True
Kurzwoche = Richtig
sonst:
Kurzwoche = Falsch

pos = Vorlagenliste [i] .find (IMPERIAL_KEY)
wenn pos! = -1:
optionfound = True
imperial = wahr
sonst:
imperial = falsch

pos = Vorlagenliste [i] .find (HIDEUNITS_KEY)
wenn pos! = -1:
optionfound = True
Hideunit = True
sonst:
Hideunit = Falsch

pos = Vorlagenliste [i] .find (SPACES_KEY)
wenn pos! = -1:
optionfound = True
pos = pos + len (SPACES_KEY)
Leerzeichen = int (Vorlagenliste [i] [pos: pos + 4] .strip («}»). strip («{«). strip («-«). strip (»«))
sonst:
Leerzeichen = 1

if optionfound == True:
templatelist [i] = self.getOutputText (Datentyp, Starttag, Endtag, Nacht, kurzer Wochentag, imperial, Verstecke, Leerzeichen)
optionfound = Falsch

# Gehen Sie die Liste durch und verketten Sie die Ausgabe, nachdem sie ausgefüllt wurde
für Artikel in der Vorlagenliste:
Ausgabe = Ausgabe + Element

Ausgabe zurückgeben

#außer:
#print "getOutputTextFromTemplate: Unerwarteter Fehler:", sys.exc_info () [0]

def fetchData (self):

# Abrufen von Metrikdaten, Verwenden von Konversationsfunktionen für diese Daten
file_path_current = self.TEMP_FILEPATH_CURRENT.replace ("LOCATION", self.options.location)
file_path_dayforecast = self.TEMP_FILEPATH_DAYFORECAST.replace ("LOCATION", self.options.location)
file_path_nightforecast = self.TEMP_FILEPATH_NIGHTFORECAST.replace ("LOCATION", self.options.location)

if self.isConnectionAvailable () == False:
wenn os.path.exists (file_path_current):
RefetchData = Falsch
sonst: # keine Verbindung, kein Cache, Knall!
print "Es ist keine Internetverbindung verfügbar und es sind keine zwischengespeicherten Wetterdaten vorhanden."
elif self.options.refetch == Wahr:
RefetchData = True
sonst:
# Müssen die Daten erneut abgerufen werden?
wenn os.path.exists (file_path_current):
lastmodDate = time.localtime (os.stat (file_path_current) [ST_MTIME])
expiryDate = (datetime.datetime.today () - datetime.timedelta (Minuten = self.EXPIRY_MINUTES)). timetuple ()

if expiryDate> lastmodDate:
RefetchData = True
sonst:
RefetchData = Falsch
sonst:
RefetchData = True

# Abrufen der aktuellen Bedingungsdaten, entweder von der Website oder durch "Aufheben der Auswahl"
wenn RefetchData == True:

# Aktuelle Zustandsdaten vom xoap-Dienst abrufen
Versuchen:

# 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 & Einheit = m '
if self.options.verbose == True:
print >> sys.stdout, «Wetterdaten abrufen von«, url

Usock = urllib2.urlopen (url)
xml = usock.read ()
Usock.close ()
self.weatherxmldoc = minidom.parseString (xml)
außer:
print "fetchData: Unerwarteter Fehler:", sys.exc_info () [0]
print "Wetterquelle kann wegen aktueller Bedingungen nicht kontaktiert werden"

# dem Benutzer mitteilen, ob der Standort schlecht ist…
found = xml.find ("Ungültiger Speicherort angegeben")
wenn gefunden! = -1:
print "Ungültiger Speicherort angegeben"

# Wetterdaten abfragen, in die Klassenstruktur laden und einlesen
Versuchen:

# Wetterdatenlisten erstellen
self.current_conditions = []
self.day_forecast = []
self.night_forecast = []

# allgemeine Daten sammeln
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)

# aktuelle Zustandsdaten sammeln
day_of_week = u »Heute»
Niederschlag = u »N / A»
sunrise_n = location_n.getElementsByTagName ('sunr') [0]
sunrise = self.getText (sunrise_n.childNodes)
sunset_n = location_n.getElementsByTagName ('suns') [0]
sunset = self.getText (sunset_n.childNodes)
current_condition_n = weather_n.getElementsByTagName ('cc') [0]
current_desc_n = current_condition_n.getElementsByTagName ('t') [0]
current_desc = self.getText (current_desc_n.childNodes)
current_code_n = current_condition_n.getElementsByTagName ('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)
Luftfeuchtigkeit_n = aktueller_Zustand_n.getElementsByTagName ('hmid') [0]
Luftfeuchtigkeit = self.getText (Luftfeuchtigkeit_n.Kindknoten)
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 = WeatherData (day_of_week, current_temp_feels, current_temp, current_code, current_desc, Niederschlag, Luftfeuchtigkeit, Windrichtung, Windgeschwindigkeit, Wind_gusts, Stadt, Sonnenaufgang, Sonnenuntergang, Mondphase, Mond_icon, bar_read, bar_desc)
self.current_conditions.append (current_conditions_data)

# Prognosedaten sammeln
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 ('Tag')

für Tag in Tag_Knoten:
day_of_week = day.getAttribute ('t')
day_of_year = day.getAttribute ('dt')
high_temp_n = day.getElementsByTagName ('hi') [0]
high_temp = self.getText (high_temp_n.childNodes)
low_temp_n = day.getElementsByTagName ('low') [0]
low_temp = self.getText (low_temp_n.childNodes)

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

# Tagesprognose spezifische Daten
daytime_n = day.getElementsByTagName ('part') [0] # day
condition_code_n = daytime_n.getElementsByTagName ('icon') [0]
condition_code = self.getText (condition_code_n.childNodes)
condition_n = daytime_n.getElementsByTagName ('t') [0]
condition = self.getText (condition_n.childNodes)
präzip_n = daytime_n.getElementsByTagName ('ppcp') [0]
Niederschlag = self.getText (Niederschlag_n.Kindknoten)
Luftfeuchtigkeit_n = Tag_n.getElementsByTagName ('hmid') [0]
Luftfeuchtigkeit = self.getText (Luftfeuchtigkeit_n.Kindknoten)
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, bedingungscode, zustand, niederschlag, feuchtigkeit, windrichtung, windgeschwindigkeit, wind_gusts, stadt, sonnenaufgang, sonnenuntergang, mondphase, mond_icon, bar_read, bar_desc)
self.day_forecast.append (day_forecast_data)

# Nachtvorhersage spezifische Daten
daytime_n = day.getElementsByTagName ('part') [1] # night
condition_code_n = daytime_n.getElementsByTagName ('icon') [0]
condition_code = self.getText (condition_code_n.childNodes)
condition_n = daytime_n.getElementsByTagName ('t') [0]
condition = self.getText (condition_n.childNodes)
präzip_n = daytime_n.getElementsByTagName ('ppcp') [0]
Niederschlag = self.getText (Niederschlag_n.Kindknoten)
Luftfeuchtigkeit_n = Tag_n.getElementsByTagName ('hmid') [0]
Luftfeuchtigkeit = self.getText (Luftfeuchtigkeit_n.Kindknoten)
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)
Nachtdaten
self.night_forecast.append (night_forecast_data)

# Die Daten für das nächste Mal auswählen!
fileoutput = open (file_path_current, 'w')
pickle.dump (self.current_conditions, Dateiausgabe)
fileoutput.close ()

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

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

außer:
print "fetchData: Unerwarteter Fehler:", sys.exc_info () [0]
print "Wetterdaten können nicht abgefragt werden"

sonst: # Wetterdaten aus eingelegten Klassendateien abrufen
if self.options.verbose == True:
print >> sys.stdout, «Wetterdaten aus Datei abrufen:«, file_path_current

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

if self.options.verbose == True:
print >> sys.stdout, "Abrufen von Tagesvorhersagedaten aus Dateien:", file_path_dayforecast, file_path_nightforecast

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

if self.options.verbose == True:
print >> sys.stdout, «Abrufen von Tagesvorhersagedaten aus Dateien:«, file_path_nightforecast, file_path_nightforecast

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

def outputData (self):
#Versuchen:

if self.options.template! = Keine:

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

sonst:

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)

print output.encode ("utf-8")

#außer:
#print «outputData: Unerwarteter Fehler:«, sys.exc_info () [0]

if __name__ == "__main__":

parser = CommandLineParser ()
(options, args) = parser.parse_args ()

if options.verbose == True:
print >> sys.stdout, "location:", options.location
print >> sys.stdout, "imperial:", options.imperial
print >> sys.stdout, "datatype:", options.datatype
print >> sys.stdout, "night:", options.night
print >> sys.stdout, "start day:", options.startday
print >> sys.stdout, "end day:", options.endday
print >> sys.stdout, "Leerzeichen:", options.spaces
print >> sys.stdout, "verbose:", options.verbose
print >> sys.stdout, "refetch:", options.refetch

# Neues globales Wetterobjekt erstellen
Wetter = GlobalWeather (Optionen)
weather.fetchData ()
weather.outputData ()

Wir erstellen die Datei ~ / Conky / scripts / myweather.template

gedit ~ / Conky / scripts / myweather.template

Wir fügen Folgendes ein:

{–Datatype = DW –startday = 1}: {–datatype = CC –startday = 1}
{–Datatype = HT –startday = 1} / {–datatype = LT –startday = 1} Wind von {–datatype = WD –startday = 1} nach {–datatype = WS –startday = 1}
Luftfeuchtigkeit: {–datatype = HM –startday = 1} Niederschlag: {–datatype = PC –startday = 1}
Sonnenaufgang: {–datatype = SR –startday = 1} Sonnenuntergang: {–datatype = SS –startday = 1}
----------------
{–Datatype = DW –startday = 2}: {–datatype = CC –startday = 2}
{–Datatype = HT –startday = 2} / {–datatype = LT –startday = 2} Wind von {–datatype = WD –startday = 2} nach {–datatype = WS –startday = 2}
Luftfeuchtigkeit: {–datatype = HM –startday = 2} Niederschlag: {–datatype = PC –startday = 2}
Sonnenaufgang: {–datatype = SR –startday = 2} Sonnenuntergang: {–datatype = SS –startday = 2}
----------------
{–Datatype = DW –startday = 3}: {–datatype = CC –startday = 3}
{–Datatype = HT –startday = 3} / {–datatype = LT –startday = 3} Wind von {–datatype = WD –startday = 3} nach {–datatype = WS –startday = 3}
Luftfeuchtigkeit: {–datatype = HM –startday = 3} Niederschlag: {–datatype = PC –startday = 3}
Sonnenaufgang: {–datatype = SR –startday = 3} Sonnenuntergang: {–datatype = SS –startday = 3}
----------------
{–Datatype = DW –startday = 4}: {–datatype = CC –startday = 4}
{–Datatype = HT –startday = 4} / {–datatype = LT –startday = 4} Wind von {–datatype = WD –startday = 4} nach {–datatype = WS –startday = 4}
Luftfeuchtigkeit: {–datatype = HM –startday = 4} Niederschlag: {–datatype = PC –startday = 4}
Sonnenaufgang: {–datatype = SR –startday = 4} Sonnenuntergang: {–datatype = SS –startday = 4}

Wir erstellen die Datei ~ / Conky / scripts / mail / conkyEmail.py (wir müssen den Mailordner erstellen)

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

und wir fügen Folgendes ein:

import os
Zeichenfolge importieren

#Geben Sie Ihren Benutzernamen und Ihr Passwort unten in doppelte Anführungszeichen ein
# z.B. Benutzername = »Benutzername» und Passwort = »Passwort»
Benutzername = »YOUR_USUARIO_SINARROBA«
Passwort = »DEIN SCHLÜSSEL«

com = »wget -O - https: //» + Benutzername + »:» + Passwort + »@ mail.google.com / mail / feed / atom –no-check-Zertifikat»

temp = os.popen (com)
msg = temp.read ()
index = string.find (msg, » »)
index2 = string.find (msg, » »)
fc = int (msg [Index + 11: Index2])

wenn fc == 0:
drucke "0 neu"
sonst:
print str (fc) + »neu»

Jetzt haben Sie also 7 Dateien:

Im Ordner: ~
-> .startconky << - ausführbar machen

Im Ordner: ~ / Conky
-> conkymain
-> conkyforecast
-> Conkymail

und im Ordner: ~ / Conky / scripts
-> conkyForecast.py << - ausführbar machen
-> myweather.template

und im Ordner: ~ / Conky / scripts / mail
conkyEmail.py << - ausführbar machen

Und das war's, Klarstellungen, wo steht / home / user / ... Ihr Benutzername steht und in dem Teil, in dem die Google Mail-Daten gespeichert sind, habe ich in Farben hervorgehoben, wo Sie Ihre Daten ablegen müssen.

Um den Conky-Prozess zu beenden, schreiben Sie in eine Konsole

Killall Conky

um conky laufen zu lassen, schreibe auf eine Konsole

./.startconky

Sobald Sie alles angepasst haben, möchten Sie, dass Conky jede Sitzung startet

System -> Einstellungen -> Sitzungen und in Startprogrammen fügen wir es hinzu

In Name können wir Conky schreiben, in der Reihenfolge ./.startconky damit, dass es jedes Mal startet, wenn Sie den PC einschalten.

Das war's, ich hoffe es hilft dir.


Hinterlasse einen Kommentar

Ihre E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind markiert mit *

*

*

  1. Verantwortlich für die Daten: Miguel Ángel Gatón
  2. Zweck der Daten: Kontrolle von SPAM, Kommentarverwaltung.
  3. Legitimation: Ihre Zustimmung
  4. Übermittlung der Daten: Die Daten werden nur durch gesetzliche Verpflichtung an Dritte weitergegeben.
  5. Datenspeicherung: Von Occentus Networks (EU) gehostete Datenbank
  6. Rechte: Sie können Ihre Informationen jederzeit einschränken, wiederherstellen und löschen.