Conky, min opsætning

Ubunlog

37 minutter

Fecfactor bad mig i går om at offentliggøre konfigurationen af ​​den conky, som jeg viser i skærmbilledet nedenfor

Som du kan se er der 3 conkys, der udføres ved hjælp af et script, dets konfiguration er baseret på dette indlæg indsendt af bruger Bruce M. i fora for Ubuntu-Ar med nogle ændringer i mail conky, hvilket i mit tilfælde er til Gmail.

I referenceposten forklares det meget godt af Bruce, men også som et hukommelseshjælpemiddel for mig, vil jeg kopiere de trin, der skal følges, og koden til mine conkys for den, der har det.

Nå, selvfølgelig skal vi have conky, curl og python installeret, så vi skriver en konsol:

sudo apt-get install conky curl python

Kilden til vejret.ttf og pile.ttf er her. Månens kilde .ttf er her når du er downloadet, skal du kopiere dem til / usr / share / fonts

Lad os nu oprette vores script kaldet ~. / Startconky

gksudo gedit ~ / .startconky

inde i den tomme fil indsætter vi følgende

#! / Bin / bash
sove 0 & # 0 godt for Xfce - brug 20 til 30 til Gnome
conky -c ~ / Conky / conkymain &
#sleep 0 & # 0 god til Xfce - brug 1 til Gnome
conky -c ~ / Conky / conkyforecast &
#sleep 0 & # 0 god til Xfce - brug 1 til Gnome
conky -c ~ / Conky / conkymail &

Nu opretter vi conkymain-filen i ~ / Conky-mappen, hvis vi ikke har Conky-mappen, bliver vi nødt til at oprette den.

gedit ~ / Conky / conkymain

Jeg bruger Calibri-skrifttypen. Hvis du ikke har den, skal du udskifte den med hvad du vil.

Vi holder inde i det, der følger

baggrund nr
own_window ja
eget_vindue_transparent ja
own_window_hints undecorated, below, sticky, skip_taskbar, skip_pager
eget_vindue_farve sort
dobbelt_buffer ja
brug_spacer tilbage
use_xft ja
skrifttype calibri: størrelse = 9
xftfont calibri: størrelse = 9
xftalpha 0.5
opdateringsinterval 5.0
store bogstaver nr. er indstillet til ja, hvis du vil have, at al tekst skal være med store bogstaver
stippled_border 3
grænse_margin 9
grænse_bredde 10
standard_farve hvid
standard_outline_farve sort
standard_skærmfarve sort
farve0 cyan
farve1 lyseblå
farve2 orange
farve3 gul
farve4 hvede
farve5 hvid
farve6 hvid
farve7 hvid
farve8 hvid
farve9 hvid
justering øverst til højre # eller øverst til venstre, nederst til venstre, nederst til højre
hul_x 10
kløft_y 35
text_buffer_size 128 # brug 1024 til prognosen
nej_buffere ja # Træk filsystembuffere fra brugt hukommelse?
trækbord nr
draw_outline ja # forstærker tekst, hvis ja
draw_shades ja # shadecolor sort

TEKST
$ {font calibri: size = 12} $ {alignc} $ {color1} $ sysname $ kernel på $ machine} $ color $ font
$ {font calibri: size = 12} $ {alignc} $ {color2} $ {exec whoami} @ $ nodenavn $ color $ font
$ {color0} $ {hr 1} $ farve
$ {font calibri: size = 20} $ {alignc} $ {time% H:% M} $ font
$ {font calibri: size = 12} $ {color1} $ {alignc} $ {time% A,% d% b. % Y} $ farve $ skrifttype
$ {color3} UpTime: $ {alignr 2} $ uptime $ color
$ {color0} $ {hr 1} $ farve
$ {voffset 5} $ {color2} CPU: $ {alignc} $ color $ running_processes $ {color1} / $ color $ processer $ {alignr 2} $ {color2} $ {cpubar cpu0 14,80} $ farve
$ {color1} $ {voffset -16} $ {alignr 5} $ cpu% $ farve
$ {voffset 2} $ {color1} Load Gns ($ {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} $ farve
$ {color1} $ {voffset -16} $ {alignr 5} $ memperc% $ farve
$ {voffset 2} $ {color1} Buffer: $ color $ {buffere} $ {alignr 2} $ {color1} Cache: $ color $ {cached}
$ {voffset 5} $ {color2} SWAP: $ color $ swap $ {color2} / $ color $ {swapmax} $ {alignr 2} $ {color2} $ {swapbar 14,80} $ color
$ {color1} $ {voffset -16} $ {alignr 5} $ swapperc%
$ {color0} $ {hr 1} $ farve
$ {voffset 5} $ {color2} HD-info $ {color1} - $ color Gratis $ {color1} - Brugt - $ {color2} I alt
$ {voffset 5} $ {color1} Root: $ color $ {fs_free_perc /}% $ {alignr 2} $ {fs_free /} $ {color2} / $ {color1} $ {fs_used /} $ color / $ {color2} $ {fs_size /} $ farve
$ {color1} Startside: $ color $ {fs_free_perc / home / user}% $ {alignr 2} $ {fs_free / home / user} $ {color2} / $ {color1} $ {fs_used / home / user} $ color / $ {color2} $ {fs_size / home / user} $ farve
$ {color0} $ {hr 1} $ farve
$ {color1} Fra: $ color Buenos Aires, Argentina
$ {color1} Bredde: $ {color2} 34 ° 35'S $ {color1} Lang: $ {color2} 58 ° 21'W $ {color1} Alt: $ {color2} 25 m $ farve
$ {voffset 5} $ {color2} $ {font calibri: size = 12} i dag: $ font $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = CC} $ farve $ {alignr 2} $ {color1} ST: $ {color2} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = LT}
$ {color3} $ {font Weather: size = 50} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = WF} $ font $ color
$ {alignr 50} $ {voffset -55} $ {font calibri: size = 25} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = HT} $ font
$ {alignc 20} $ {voffset -30} $ {font Pile: størrelse = 20} $ {color4} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –placering = ARBA0009 –datatype = BF} $ farve $ skrifttype
$ {alignc 10} $ {voffset 5} $ {color4} Vind: $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –placering = ARBA0009 –datatype = WS} $ farve
$ {color1} Fugtighed: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = HM} $ {alignr 2} $ {color1} Nedbør: $ {color3} $ { execi 3600 python ~ / Conky / scripts / conkyForecast.py –placering = ARBA0009 –datatype = PC} $ farve
$ {alignc} $ {color1} Tryk: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = BR} - $ {color3} $ {execi 3600 python ~ / Conky /scripts/conkyForecast.py –location = ARBA0009 –datatype = BD} $ farve
$ {color4} $ {hr} $ farve
$ {color1} Solopgang: $ {color3} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = SR} $ {alignr 2} $ {color1} Solnedgang: $ {color3} $ { execi 3600 python ~ / Conky / scripts / conkyForecast.py –placering = ARBA0009 –datatype = SS} $ farve
$ {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 phases: size = 20} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –datatype = MF} $ font $ farve
$ {color0} $ {hr} $ farve
$ {voffset 5} $ {color2} IP: $ {alignc} $ color $ {addr eth0}
$ {color1} Ned: $ color $ {downspeed eth0} k / s $ {alignr 2} $ {color1} Op: $ color $ {upspeed eth0} k / s
$ {color1} I alt: $ color $ {totaldown eth0} $ {alignr 2} $ {color1} I alt: $ color $ {totalup eth0}
$ {color1} Indgående: $ color $ {tcp_portmon 1 32767 count} $ {color1} Udgående: $ color $ {tcp_portmon 32768 61000 count} $ {alignr 2} $ {color1} I alt: $ color $ {tcp_portmon 1 65535 count}
$ {voffset 5} $ {color2} Forbindelser: $ 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} $ farve

vi opretter filen ~ / Conky / conkyforecast

gedit ~ / Conky / conkyforecast

og vi indsætter følgende indeni

baggrund nr
own_window ja
eget_vindue_transparent ja
own_window_hints undecorated, below, sticky, skip_taskbar, skip_pager
eget_vindue_farve sort
dobbelt_buffer ja
brug_spacer tilbage
use_xft ja
skrifttype calibri: størrelse = 8
xftfont calibri: størrelse = 8
xftalpha 0.5
opdateringsinterval 5.0
store bogstaver nr. er indstillet til ja, hvis du vil have, at al tekst skal være med store bogstaver
stippled_border 3
grænse_margin 9
grænse_bredde 10
standard_farve hvid
standard_outline_farve sort
standard_skærmfarve sort
farve0 cyan
farve1 lyseblå
farve2 orange
farve3 gul
farve4 hvede
farve5 hvid
farve6 hvid
farve7 hvid
farve8 hvid
farve9 hvid
justering nederste venstre # eller øverste venstre, nederste venstre, nederste højre
hul_x 10
kløft_y 35
text_buffer_size 1024 # brug 1024 til prognosen
nej_buffere ja # Træk filsystembuffere fra brugt hukommelse?
trækbord nr
draw_outline ja # forstærker tekst, hvis ja
draw_shades ja # shadecolor sort

TEKST
$ {color4} $ {font calibri: size = 11} Udvidet prognose $ font $ color
$ {color0} $ {hr} $ farve
$ {color4} $ {font calibri: size = 9} $ {execi 3600 python ~ / Conky / scripts / conkyForecast.py –location = ARBA0009 –template = / home / user / Conky / scripts / myweather.template} $ font $ farve

vi opretter filen ~ / Conky / conkymail

gedit ~ / Conky / conkymail

vi indsætter følgende i filen

baggrund nr
own_window ja
eget_vindue_transparent ja
own_window_hints undecorated, below, sticky, skip_taskbar, skip_pager
eget_vindue_farve sort
dobbelt_buffer ja
brug_spacer tilbage
use_xft ja
skrifttype calibri: størrelse = 8
xftfont calibri: størrelse = 8
xftalpha 0.5
opdateringsinterval 5.0
store bogstaver nr. er indstillet til ja, hvis du vil have, at al tekst skal være med store bogstaver
stippled_border 3
grænse_margin 9
grænse_bredde 10
standard_farve hvid
standard_outline_farve sort
standard_skærmfarve sort
farve0 cyan
farve1 lyseblå
farve2 orange
farve3 gul
farve4 hvede
farve5 hvid
farve6 hvid
farve7 hvid
farve8 hvid
farve9 hvid
justering nederste venstre # eller øverste venstre, nederste venstre, nederste højre
hul_x 565
kløft_y 35
text_buffer_size 128 # brug 1024 til prognosen
nej_buffere ja # Træk filsystembuffere fra brugt hukommelse?
trækbord nr
draw_outline ja # forstærker tekst, hvis ja
draw_shades ja # shadecolor sort

TEKST
$ {font calibri: size = 11} $ {alignc} $ {color4} Gmail
$ {color0} $ {hr} $ farve
$ {font calibri: size = 11} $ {color4} Vi har $ {color3} $ {execi 300 python ~ / Conky / scripts / mail / conkyEmail.py} $ {color4} e-mail (r) $ font

Vi opretter en fil i ~ / Conky / scripts / conkyForecast.py (vi skal oprette scriptsmappen)

gedit ~ / Conky / scripts / conkyForecast.py

#! / Usr / bin / python
# - * - kodning: utf-8 - * -
Nr. #####################################
# conkyForecast.py er et (ikke så) simpelt (længere) python-script at samle
# detaljer om det aktuelle vejr til brug i conky.
#
# Forfatter: Kaivalagi
# Oprettet: 13/04/2008
# Ændringer:
# 14/04/2008 Tillad dagsintervaller for prognosedata
# 14/04/2008 Kontroller, om der er forbindelse til xoap-tjenesten
# 18/04/2008 Tillad indstillingen af ​​mellemrum for output i området
# 18/04/2008 Tillad output fra nat og dag
# 18/04/2008 Supportsprog for tilstandskodetekst «CC» mulighed, afventer spansk oversættelse
# 18/04/2008 Brug betning til klassedata i stedet for at åbne xml, dette omgår behovet for at forhøre cachelagrede data
# 19/04/2008 Tilføjet spansk tilstandstekst - Tak Bruce M
# 19/04/2008 Tilføjet isnumerisk kontrol af al numerisk output med suffiks for enheder
# 19/04/2008 Ændret navngivning af pickle-fil, så den inkluderer placeringskode
# 19/04/2008 Tilføjet spansk ugedagskonvertering via landestandard
# 20/04/2008 Tilføjet anstændigt kommando argument parser
# 20/04/2008 Tilføjet - valgmulighed for kort ugedag, hvis datatiden er ugentligt forkortet til 3 tegn
# 21/04/2008 Faste landestandardindstillinger for prognoseproduktion
# 21/04/2008 Tilføjet - skabelonindstilling for at tillade brugerdefineret output ved hjælp af et enkelt exec-opkald 🙂
# 21/04/2008 Tilføjet –hideunits option for at fjerne f.eks. Mph og C fra output
# 23/04/2008 Fjernet –imperial indstilling fra skabelonen, SKAL denne indstilles som en standardindstilling på scriptopkaldet og ikke bruges i skabelonfilen.
# 23/04/2008 Readded –imperial mulighed for at skabelon, der muliggør metriske eller imperiale værdier pr. Datatype. Bemærk, når du bruger skabeloner, fungerer kommandolinjemulighed ikke.
# 23/04/2008 Tilføjet output, der underretter brugeren, hvis den givne placering er dårlig
# 24/04/2008 Tilføjet håndtering uden forbindelse, vender tilbage til cachelagrede data nu (med fejl, hvis der ikke findes nogen cache). Test ved at prøve at åbne xoap.weather.com
# 24/04/2008 Fast Celsius til fahrenheit konvertering
# 06/05/2008 Opdateret url, der blev brugt efter opdatering af webservice
# 09/05/2008 Konsolideret nuværende tilstand og prognosedata hentes i et opkald
# 09/05/2008 Tilføjet solopgang og solnedgang til datatyper, disse er specifikke for både aktuelle forhold og prognosedata
# 09/05/2008 Tilføjet månefase, barometeraflæsning og barometerbeskrivelse til datatyper, disse er kun specifikke for aktuelle forhold, og det samme gælder N / A i forventet output
# 09/05/2008 Tilføjede enhedskonverteringer for barometer fra mb til tommer (imperial)
# 09/05/2008 Opdateret spansk tilstandstekst - Tak Bruce M
# 10/05/2008 Tilføjede franske sprogdata - Tak benpaka
# 12/05/2008 Tilføjet ny BF (bærende skrifttype) datatype for at give et pilekarakter (brug med Arrow.ttf skrifttype) i stedet for NSEW-output fra WD (vindretning)
# 12/05/2008 Opdateret WD-output til at være landespecifik, understøtter i øjeblikket standard engelsk og spansk - tak Bruce M
# 18/05/2008 Tilføjet ny MF (måneskrifttype) datatype for at give et måneskrifttegn (forkert tegn og endnu ikke dedikeret skrifttype).
# 21/05/2008 For aktuelle forhold viser indstillingen –datatype = LT nu «føles som» temperatur snarere end den aktuelle temperatur
#
# ALT:
# Konsolider pkl-filer i en fil / klasse
# Tilføj en vejrskrifttype baseret på månefaseoutput baseret på måneikondata
# ??? Flere krav derude?

importer sys, os, socket, urllib2, datetime, tid
fra xml.dom import minidom
fra stat import *
fra optparse import OptionParser
import landestandard
importer gettext
importere lage
fra matematisk import *

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

klasse CommandLineParser:

parser = Ingen

def __init __ (selv):

self.parser = OptionParser ()
self.parser.add_option («- l», »- placering», dest = »placering», standard = »UKXX0103 ″, type =» streng », metavar =» KODE », hjælp = u» placeringskode til vejrdata [ standard:% standard], Brug følgende url til at bestemme din placeringskode efter bynavn: http://xoap.weather.com/search/search?where=Norwich »)
self.parser.add_option ("- d", "- datatype", dest = "datatype", standard = "HT", type = "streng", metavar = "DATATYPE", hjælp = u "[standard:% standard] Datatypemulighederne er: DW (Ugedag), WF (Weather Font Output), LT (Prognose: Lav Temp, Aktuel: Føles som Temp), HT (Prognose: High Temp, Aktuel: Nuværende Temp), CC (Aktuel Betingelser), CT (betingelser tekst), pc (nedbørsmulighed), HM (fugtighed), WD (vindretning), WS (vindhastighed), WG (vindstød), CN (bynavn), SR (solopgang), SS (solnedgang), MP (månefase), MF (måneskrift), BR (barometeraflæsning), BD (barometerbeskrivelse). Gælder ikke ved kommandolinjen, når du bruger skabeloner. »)
self.parser.add_option («- s», »- startdag», dest = »startdag», type = »int», metavar = »NUMMER», hjælp = u »definer startnummerets startdag, hvis de aktuelle forhold udelades Ikke relevant på kommandolinjen, når du bruger skabeloner. »)
self.parser.add_option ("- e", "- endday", dest = "endday", type = "int", metavar = "NUMBER", help = u "definerer slutdagens nummer, hvis kun startdatagedata udelades er output. Ikke relevant på kommandolinjen, når du bruger skabeloner. »)
self.parser.add_option («- S», »- mellemrum», dest = »mellemrum», type = »int», standard = 1, metavar = »NUMMER», hjælp = u »[standard:% standard] Definerer antal mellemrum mellem output fra rækkevidde. Ikke relevant på kommandolinjen, når du bruger skabeloner. »)
self.parser.add_option («- t», »- skabelon», dest = »skabelon», type = »streng», metavar = »FIL», hjælp = u »definer en skabelonfil til generering af output i et opkald. A element, der kan vises i filen, har formen {–datatype = HT –startdag = 1}. Følgende er mulige muligheder inden for hvert element: –datatype, –startdag, –enddag, –nat, –kort ugedag, –imperial, –hideenheder, –Rum. Bemærk, at de korte former for indstillingerne ikke understøttes i øjeblikket! Ingen af ​​disse indstillinger er anvendelige på kommandolinjen, når du bruger skabeloner. »)
self.parser.add_option («- L», »- lokalitet», dest = »lokalitet», type = »streng», hjælp = u »tilsidesætter systemets lokalitet til sprogoutput (en = engelsk, es = spansk, fr = fransk, mere at komme) »)
self.parser.add_option ("- i", "- imperial", dest = "imperial", default = False, action = "store_true", help = u "anmoder imperiale enheder, hvis udeladt output er i metrisk. Ikke relevant ved kommandolinje, når du bruger skabeloner. »)
self.parser.add_option («- n», »- night», dest = »night», default = False, action = »store_true», help = u »skift output til natdata, hvis udeladt dagsoutput vil blive output. Ikke relevant på kommandolinjen, når du bruger skabeloner. »)
self.parser.add_option («- w», »- shortweekday», dest = »shortweekday», default = False, action = »store_true», help = u »Forkort datatypen ugedag til 3 tegn. Gælder ikke ved kommandolinje, når du bruger skabeloner. »)
self.parser.add_option («- u», »- hideunits», dest = »hideunits», default = False, action = »store_true», help = u »Skjul enheder som mph eller C, gradssymboler (°) er stadig vist. Ikke relevant på kommandolinjen, når du bruger skabeloner. »)
self.parser.add_option ("- v", "- verbose", dest = "verbose", default = False, action = "store_true", help = u "anmod om detaljeret output, ingen god idé, når du løber gennem conky!" )
self.parser.add_option ("- r", "- refetch", dest = "refetch", default = False, action = "store_true", hjælp = u "hent data uanset datatidens udløb")

def parse_args (selv):
(optioner, args) = self.parser.parse_args ()
return (optioner, args)

def print_help (selv):
returner self.parser.print_help ()

klasse WeatherData:
def __init __ (selv, dag_of-uge, lav, høj, tilstand_kode, tilstand_tekst, nedbør, fugtighed, vind_dir, vind_hastighed, vindstød, by, solopgang, solnedgang, månefase, måne-ikon, bar_læs, bar_desc):
self.day_of_week = u »» + day_of_week
self.low = u »» + lav
self.high = u »» + høj
self.condition_code = u »» + condition_code
self.condition_text = u »» + condition_text
self.precip = u »» + nedbør
selvfugtighed = u »» + fugtighed
self.wind_dir = u »» + vind_dir
self.wind_speed = u »» + vindhastighed
self.wind_gusts = u »» + vindstød
self.city = u »» + by
self.sunrise = u »» + solopgang
self.sunset = u »» + solnedgang
self.moon_phase = u »» + månefase
self.moon_icon = u »» + moon_icon
self.bar_read = u »» + bar_read
self.bar_desc = u »» + bar_desc

klasse WeatherText:

betingelser_tekst = {
«0»: _ (u »Tornado»),
«1»: _ (u »Tropisk storm»),
«2»: _ (u »Orkanen»),
«3»: _ (u »Alvorlige tordenvejr»),
«4»: _ (u »Tordenvejr»),
«5»: _ (u »Blandet regn og sne»),
«6»: _ (u »Mixed Rain and Sleet»),
«7»: _ (u »Blandet nedbør»),
«8»: _ (u »Frysende dryp»),
«9»: _ (u »Drizzle»),
«10»: _ (u »Frysende regn»),
«11»: _ (u »Brusere»),
«12»: _ (u »Brusere»),
«13»: _ (u »Snow Flurries»),
«14»: _ (u »Let snebyger»),
«15»: _ (u »Blæser sne»),
«16»: _ (u »Sne»),
«17»: _ (u »Hail»),
«18»: _ (u »Sleet»),
«19»: _ (u »Støv»),
«20»: _ (u »Tåge»),
«21»: _ (u »Haze»),
«22»: _ (u »Røg»),
«23»: _ (u »Blustery»),
«24»: _ (u »Windy»),
«25»: _ (u »Kold»),
«26»: _ (u »Overskyet»),
«27»: _ (u »Overskyet»),
«28»: _ (u »Overskyet»),
«29»: _ (u »Delvis overskyet»),
«30»: _ (u »Delvis overskyet»),
«31»: _ (u »Ryd»),
«32»: _ (u »Ryd»),
«33»: _ (u »Fair»),
«34»: _ (u »Fair»),
«35»: _ (u »Blandet regn og hagl»),
«36»: _ (u »Hot»),
«37»: _ (u »Isolerede tordenvejr»),
«38»: _ (u »Spredte tordenvejr»),
«39»: _ (u »Spredte tordenvejr»),
«40»: _ (u »Spredte byger»),
«41»: _ (u »Heavy Snow»),
«42»: _ (u »Spredte snebyger»),
«43»: _ (u »Heavy Snow»),
«44»: _ (u »Delvis overskyet»),
«45»: _ (u »Thunder Showers»),
«46»: _ (u »Sne byger»),
«47»: _ (u »Isolerede tordenvejr»),
«Na»: _ (u »N / A»),
"-": _ (a ")
}

conditions_text_en = {
«0»: _ (u »Tornado»),
«1»: _ (u »Tropisk storm»),
«2»: _ (u »Huracá¡n»),
«3»: _ (u »Stærke storme»),
«4»: _ (u »Storme»),
«5»: _ (u »Blandet regn og sne»),
«6»: _ (u »Mixed Rain and Sleet»),
«7»: _ (u »Sleet»),
«8»: _ (u »Frysende dryp»),
«9»: _ (u »Drizzle»),
«10»: _ (u »Frysende regn»), # eller frysende regn
«11»: _ (u »Brusere»),
«12»: _ (u »Brusere»),
«13»: _ (u »Let sne»),
«14»: _ (u »Let sne»),
«15»: _ (u »Snow Blizzard»),
«16»: _ (u »Sne»),
«17»: _ (u »Hail»),
«18»: _ (u »Sleet»),
«19»: _ (u »Pulver»),
«20»: _ (u »Tåge»),
«21»: _ (u »Haze»),
«22»: _ (u »Røg»),
«23»: _ (u »Tempest»),
«24»: _ (u »Windy»),
«25»: _ (u »Fráo»),
«26»: _ (u »Meget overskyet»),
«27»: _ (u »Overskyet»),
«28»: _ (u »Overskyet»),
«29»: _ (u »Delvis overskyet»),
«30»: _ (u »Delvis overskyet»),
«31»: _ (u »Ryd»),
«32»: _ (u »Ryd»),
«33»: _ (u »Noget overskyet»),
«34»: _ (u »Noget overskyet»),
«35»: _ (u »Regn med hagl»),
«36»: _ (u »Heat»),
«37»: _ (u »Isolerede storme»),
«38»: _ (u »Spredte storme»),
«39»: _ (u »Spredte storme»),
«40»: _ (u »Spredte byger»),
«41»: _ (u »Heavy Snow»),
«42»: _ (u »Svage og spredte snefald»),
«43»: _ (u »Intens Nevada»),
«44»: _ (u »Spredte skyer»),
«45»: _ (u »Storme»),
«46»: _ (eller »Spredte snefald»),
«47»: _ (u »Isolerede storme»),
«Na»: _ (u »N / A»),
"-": _ (a ")
}

conditions_text_fr = {
«0»: _ (u »Tornade»),
«1»: _ (u »Tempête Tropicale»),
«2»: _ (eller »Ouragan»),
«3»: _ (eller »Orages Violents»),
«4»: _ (eller »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»: _ (eller »Orages Isolés»),
«38»: _ (eller »Orages Localisés»),
«39»: _ (eller »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»: _ (eller »Orages»),
«46»: _ (u »Tempête de Neige»),
«47»: _ (eller »Orages Isolés»),
«Na»: _ (u »N / A»),
"-": _ (a ")
}

conditions_weather_font = {
«0»: _ (u »W»),
«1»: _ (u »V»),
«2»: _ (u »W»),
«3»: _ (u »s»),
«4»: _ (u »p»),
«5»: _ (u »k»),
«6»: _ (u »k»),
«7»: _ (u »g»),
«8»: _ (u »g»),
«9»: _ (u »g»),
«10»: _ (u »h»),
«11»: _ (u »g»),
«12»: _ (u »g»),
«13»: _ (u »k»),
«14»: _ (u »k»),
«15»: _ (u »k»),
«16»: _ (u »k»),
«17»: _ (u »k»),
«18»: _ (u »k»),
«19»: _ (u »e»),
«20»: _ (u »e»),
«21»: _ (u »a»),
«22»: _ (u »d»),
«23»: _ (u »d»),
«24»: _ (u »d»),
«25»: _ (u »d»),
«26»: _ (u »e»),
«27»: _ (u »e»),
«28»: _ (u »e»),
«29»: _ (u »c»),
«30»: _ (u »c»),
«31»: _ (u »a»),
«32»: _ (u »a»),
«33»: _ (u »b»),
«34»: _ (u »b»),
«35»: _ (u »k»),
«36»: _ (u »a»),
«37»: _ (u »f»),
«38»: _ (u »f»),
«39»: _ (u »f»),
«40»: _ (u »g»),
«41»: _ (u »k»),
«42»: _ (u »k»),
«43»: _ (u »k»),
«44»: _ (u »b»),
«45»: _ (u »g»),
«46»: _ (u »k»),
«47»: _ (u »f»),
«Na»: _ (u »»),
"-": _ (eller "")
}

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

dag_af_uge = {
"I dag": _ (eller "I dag"),
«Mandag»: _ (u »Mandag»),
«Tirsdag»: _ (u »Tirsdag»),
«Onsdag»: _ (u »onsdag»),
«Torsdag»: _ (u »Torsdag»),
«Fredag»: _ (u »fredag»),
"Lørdag": _ (u "lørdag"),
"Søndag": _ (u "Søndag")
}

dag_i_uge_kort = {
"I dag": _ (u "Nu"),
«Mandag»: _ (u »man»),
«Tirsdag»: _ (u »Tir"),
«Onsdag»: _ (u »ons»),
«Torsdag»: _ (u »Tor»),
«Fredag»: _ (u »fre»),
"Lørdag": _ (u "lør"),
"Søndag": _ (u "Sol")
}

day_of_week_da = {
"I dag": _ (u "i dag"),
«Mandag»: _ (u »Mandag»),
«Tirsdag»: _ (eller »Tirsdag»),
«Onsdag»: _ (u »onsdag»),
«Torsdag»: _ (u »Torsdag»),
«Fredag»: _ (u »fredag»),
"Lørdag": _ (u "lørdag"),
"Søndag": _ (u "Søndag")
}

day_of_week_short_en = {
"I dag": _ (u "i dag"),
"Mandag": _ (u "mon"),
«Tirsdag»: _ (u »hav»),
«Onsdag»: _ (u »ons»),
«Torsdag»: _ (u »torsdag»),
«Fredag»: _ (u »vie»),
"Lørdag": _ (u "sat"),
"Søndag": _ (u "dom")
}

day_of_week_fr = {
«I dag»: _ (u »Aujourd'hui»),
«Mandag»: _ (u »Lundi»),
«Tirsdag»: _ (u »Mardi»),
«Onsdag»: _ (u »Mercredi»),
«Torsdag»: _ (u »Jeudi»),
«Fredag»: _ (u »Vendredi»),
"Lørdag": _ (u "Samedi"),
"Søndag": _ (u "Dimanche")
}

day_of_week_short_fr = {
«I dag»: _ (u »Auj»),
"Mandag": _ (u "man"),
«Tirsdag»: _ (u »Mar»),
«Onsdag»: _ (u »Mer»),
«Torsdag»: _ (u »Jeu»),
«Fredag»: _ (u »Kom»),
"Lørdag": _ (u "Sam"),
"Søndag": _ (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»),
«Ikke relevant»: _ (u »«)
}

bearing_text_en = {
«N»: _ (u »N»),
«NNE»: _ (u »NNE»),
«NE»: _ (u »NE»),
«ENE»: _ (u »ENE»),
«E»: _ (u »E»),
«ESE»: _ (u »ESE»),
«SE»: _ (u »SE»),
"SSE": _ (u "SSE"),
"Deres"),
"SSW": _ (u "SSO"),
«SW»: _ (u »SO»),
"WSW": _ (u "WOW"),
«W»: _ (u »O»),
«WNW»: _ (u »ONO»),
«NW»: _ (u »NO»),
«NNW»: _ (u »NNO»),
«Ikke relevant»: _ (u »Ikke godkendt»)
}

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"),
"Deres"),
"SSW": _ (u "SSO"),
«SW»: _ (u »SO»),
"WSW": _ (u "WOW"),
«W»: _ (u »O»),
«WNW»: _ (u »ONO»),
«NW»: _ (u »NO»),
«NNW»: _ (u »NNO»),
«Ikke relevant»: _ (u »Ikke godkendt»)
}

klasse GlobalWeather:

nuværende_betingelser = []
day_forecast = []
nat_forecast = []

locale = "in"

optioner = Ingen
vejrxmldoc = «»

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 __ (selv, valgmuligheder):

self.options = muligheder

hvis self.options.locale == Ingen:
prøve:
# self.locale = locale.getdefaultlocale () [0] [0: 2]
self.locale = «es» # bemærk denne linje til at tvinge spansk lokalitet
# self.locale = "fr" # bemærk denne linje til at tvinge fransk landestandard
undtagen:
udskriv "landestandard ikke indstillet"
andet:
# self.locale = self.options.locale
self.locale = «es» # bemærk denne linje til at tvinge spansk lokalitet
# self.locale = "fr" # bemærk denne linje til at tvinge fransk landestandard

hvis self.options.verbose == Sandt:
udskriv >> sys.stdout, "locale set to", self.locale

def getText (selv, nodeliste):
rc = ""
til node i nodeliste:
hvis node.nodeType == node.TEXT_NODE:
rc = rc + node.data
returner rc

def getSpaces (selv, mellemrum):
streng = u »»
hvis mellemrum == Ingen:
streng = selv.DEFAULT_SPACING
andet:
for jeg inden for rækkevidde (0, mellemrum + 1):
streng = streng + u »«
returstreng

def erNumerisk (selv, streng):
prøve:
dummy = float (streng)
returner sandt
undtagen:
returner Falsk

def isConnectionAvailable (selv):
# sikre, at vi kan få adgang til weather.com's server ved at åbne url
prøve:
Usock = urllib2.urlopen ('http://xoap.weather.com')
Usock.close ()
returner sandt
undtagen:
returner Falsk

def getBearingText (selvbærende):
leje = flyde (leje)
hvis pejling <11.25:
returnere u »N»
elif pejling <33.75:
returnere u »NNE»
elif pejling <56.25:
returnere u »NE»
elif pejling <78.75:
returner u »JAN»
elif pejling <101.25:
returnere u »E»
elif pejling <123.75:
return u »ESE»
elif pejling <146.25:
returnere u »SE»
elif pejling <168.75:
returner u »SSE»
elif pejling <191.25:
returner u »S»
elif pejling <213.75:
returnere u »SSW»
elif pejling <236.25:
returner u »SW»
elif pejling <258.75:
returner u »WSW»
elif pejling <281.25:
returner u »W»
elif pejling <303.75:
returner u »WNW»
elif pejling <326.25:
returnere u »NW»
elif pejling <348.75:
returnere u »NNW»
andet:
returner «N / A»

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

def convertKilometresToMiles (selv, dist):
return str (int (gulv (float (dist) * 0.621371192)))

def convertMillibarsToInches (selv, mb):
returstr (int (gulv (float (mb) /33.8582)))

def getTemplateList (selv, skabelon):

skemaoversigt = []

til template_part i template.split («{«):
hvis template_part! = «»:
for template_part i template_part.split ("}"):
hvis template_part! = «»:
templatelist.append (u »» + template_part)

returner skabelonliste

def getOutputText (selv, datatype, startdag, slutdag, nat, kort ugedag, kejserlig, skjuleenheder, mellemrum):
#prøve:
output = u »»

# definer aktuelle enheder til output
hvis skjuleenheder == Falsk:
hvis imperial == Falsk:
tempunit = u »° C»
speedunit = u »km / t»
trykenhed = u »mb»
andet:
tempunit = u »° F»
speedunit = u »mph»
trykenhed = u »i»
andet:
tempunit = u »°»
speedunit = u »»
trykenhed = u »»

hvis startdag == Ingen: # aktuelle forhold

hvis datatype == "DW":
hvis self.locale == "er":
hvis kort ugedag == Sandt:
output = WeatherText.day_of_week_short_es [self.current_conditions [0] .day_of_week]
andet:
output = WeatherText.day_of_week_es [self.current_conditions [0] .day_of_week]
elif self.locale == "fr":
hvis kort ugedag == Sandt:
output = WeatherText.day_of_week_short_fr [self.current_conditions [0] .day_of_week]
andet:
output = WeatherText.day_of_week_fr [self.current_conditions [0] .day_of_week]
andet:
hvis kort ugedag == Sandt:
output = WeatherText.day_of_week_short [self.current_conditions [0] .day_of_week]
andet:
output = WeatherText.day_of_week [self.current_conditions [0] .day_of_week]
elif datatype == "WF": # vejr skrifttype
output = WeatherText.conditions_weather_font [self.current_conditions [0] .condition_code]
elif datatype == "LT":
string = self.current_conditions [0] .low
hvis self.isNumeric (string) == True:
hvis imperial == True:
streng = self.convertCelsiusToFahrenheit (streng)
streng = streng + tempunit
output = streng
elif datatype == "HT":
string = self.current_conditions [0] .høj
hvis self.isNumeric (string) == True:
hvis imperial == True:
streng = self.convertCelsiusToFahrenheit (streng)
streng = streng + tempunit
output = streng
elif datatype == "CC":
hvis self.locale == "er":
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]
andet:
output = WeatherText.conditions_text [self.current_conditions [0] .condition_code]
elif datatype == "CT":
output = self.current_conditions [0] .condition_text
elif datatype == "PC":
string = self.current_conditions [0] .precip
hvis self.isNumeric (string) == True:
streng = streng + u »%»
output = streng
elif datatype == "HM":
string = self.current_conditions [0] .fugtighed
hvis self.isNumeric (string) == True:
streng = streng + u »%»
output = streng
elif datatype == "WD":
string = self.current_conditions [0] .wind_dir
hvis self.isNumeric (string) == True:
string = self.getBearingText (string)

hvis self.locale == "er":
output = WeatherText.bearing_text_es [string]
elif self.locale == "fr":
output = WeatherText.bearing_text_fr [string]
andet:
output = streng

elif datatype == "BF":
string = self.current_conditions [0] .wind_dir
hvis self.isNumeric (string) == True:
string = WeatherText.bearing_arrow_font [self.getBearingText (string)]
output = streng
elif datatype == "WS":
string = self.current_conditions [0] .vind_hastighed
hvis self.isNumeric (string) == True:
hvis imperial == True:
string = self.convertKilometresToMiles (string)
streng = streng + hastighedsenhed
output = streng
elif datatype == "WG":
string = self.current_conditions [0] .wind_gusts
hvis self.isNumeric (string) == True:
hvis imperial == True:
string = self.convertKilometresToMiles (string)
streng = streng + hastighedsenhed
output = streng
elif datatype == "CN":
output = self.current_conditions [0] .city
elif datatype == "SR":
output = self.current_conditions [0] .sunrise
elif datatype == "SS":
output = self.current_conditions [0] .sunset
elif datatype == "MP":
output = self.current_conditions [0] .månefase
elif datatype == "MF":
output = WeatherText.conditions_moon_font [self.current_conditions [0] .moon_icon]
elif datatype == "BR":
string = self.current_conditions [0] .bar_read
hvis self.isNumeric (string) == True:
hvis imperial == True:
string = self.convertMillibarsToInches (string)
streng = streng + trykenhed
output = streng
elif datatype == "BD":
output = self.current_conditions [0] .bar_desc
andet:
output = "\ nFejl: Ukendt datatype anmodet om"

andet: # prognosedata

hvis slutdag == Ingen: # hvis ingen slutdag er indstillet, skal du bruge startdag
slutdag = startdag

hvis nat == Sandt: # natprognose kræves

for dagnummer inden for rækkevidde (startdag, slutdag + 1):

hvis datatype == "DW":
hvis self.locale == "er":
hvis kort ugedag == Sandt:
output = output + self.getSpaces (mellemrum) + WeatherText.day_of_week_short_es [self.night_forecast [day_number] .day_of_week]
andet:
output = output + self.getSpaces (mellemrum) + WeatherText.day_of_week_es [self.night_forecast [day_number] .day_of_week]
elif self.locale == "fr":
hvis kort ugedag == Sandt:
output = output + self.getSpaces (mellemrum) + WeatherText.day_of_week_short_fr [self.night_forecast [day_number] .day_of_week]
andet:
output = output + self.getSpaces (mellemrum) + WeatherText.day_of_week_fr [self.night_forecast [day_number] .day_of_week]
andet:
hvis kort ugedag == Sandt:
output = output + self.getSpaces (mellemrum) + WeatherText.day_of_week_short [self.night_forecast [day_number] .day_of_week]
andet:
output = output + self.getSpaces (mellemrum) + WeatherText.day_of_week [self.night_forecast [day_number] .day_of_week]
elif datatype == "WF": # vejr skrifttype
output = output + self.getSpaces (mellemrum) + WeatherText.conditions_weather_font [self.night_forecast [day_number] .condition_code]
elif datatype == "LT":
string = self.night_forecast [day_number] .low
hvis self.isNumeric (string) == True:
hvis imperial == True:
streng = self.convertCelsiusToFahrenheit (streng)
streng = streng + tempunit
output = output + self.getSpaces (mellemrum) + streng

elif datatype == "HT":
string = self.night_forecast [day_number] .high
hvis self.isNumeric (string) == True:
hvis imperial == True:
streng = self.convertCelsiusToFahrenheit (streng)
streng = streng + tempunit
output = output + self.getSpaces (mellemrum) + streng
elif datatype == "CC":
hvis self.locale == "er":
output = output + self.getSpaces (mellemrum) + WeatherText.conditions_text_es [self.night_forecast [day_number] .condition_code]
elif self.locale == "fr":
output = output + self.getSpaces (mellemrum) + WeatherText.conditions_text_fr [self.night_forecast [day_number] .condition_code]
andet:
output = output + self.getSpaces (mellemrum) + WeatherText.conditions_text [self.night_forecast [day_number] .condition_code]
elif datatype == "CT":
output = output + self.getSpaces (mellemrum) + self.night_forecast [day_number] .condition_text
elif datatype == "PC":
string = self.night_forecast [day_number] .precip
hvis self.isNumeric (string) == True:
streng = streng + u »%»
output = output + self.getSpaces (mellemrum) + streng
elif datatype == "HM":
string = self.night_forecast [day_number] .fugtighed
hvis self.isNumeric (string) == True:
streng = streng + u »%»
output = output + self.getSpaces (mellemrum) + streng
elif datatype == "WD":
string = self.night_forecast [day_number] .wind_dir
hvis self.locale == "er":
output = output + self.getSpaces (mellemrum) + WeatherText.bearing_text_es [streng]
elif self.locale == "fr":
output = output + self.getSpaces (mellemrum) + WeatherText.bearing_text_fr [streng]
andet:
output = output + self.getSpaces (mellemrum) + streng

elif datatype == "BF":
output = output + self.getSpaces (mellemrum) + WeatherText.bearing_arrow_font [self.night_forecast [day_number] .wind_dir]
elif datatype == "WS":
string = self.night_forecast [day_number] .wind_speed
hvis self.isNumeric (string) == True:
hvis imperial == True:
string = self.convertKilometresToMiles (string)
streng = streng + hastighedsenhed
output = output + self.getSpaces (mellemrum) + streng
elif datatype == "WG":
string = self.night_forecast [day_number] .wind_gusts
hvis self.isNumeric (string) == True:
hvis imperial == True:
string = self.convertKilometresToMiles (string)
streng = streng + hastighedsenhed
output = output + self.getSpaces (mellemrum) + streng
elif datatype == "CN":
output = output + self.getSpaces (mellemrum) + self.night_forecast [dagnummer] .city
elif datatype == "SR":
output = output + self.getSpaces (mellemrum) + self.night_forecast [dagnummer]. solopgang
elif datatype == "SS":
output = output + self.getSpaces (mellemrum) + self.night_forecast [dag_nummer]. solnedgang
elif datatype == "MP":
output = output + self.getSpaces (mellemrum) + self.night_forecast [dagnummer] .månefase
elif datatype == "MF":
output = output + self.getSpaces (mellemrum) + WeatherText.conditions_moon_font [self.night_forecast [day_number] .moon_icon]
elif datatype == "BR":
output = output + self.getSpaces (mellemrum) + self.night_forecast [dagnummer]. bar_read
elif datatype == "BD":
output = output + self.getSpaces (mellemrum) + self.night_forecast [dag_nummer]. bar_desc
andet:
output = "\ nFejl: Ukendt datatype anmodet om"
bryde

andet: # dages prognose ønsket

for dagnummer inden for rækkevidde (startdag, slutdag + 1):

hvis datatype == "DW":
hvis self.locale == "er":
hvis kort ugedag == Sandt:
output = output + self.getSpaces (mellemrum) + WeatherText.day_of_week_short_es [self.day_forecast [day_number] .day_of_week]
andet:
output = output + self.getSpaces (mellemrum) + WeatherText.day_of_week_es [self.day_forecast [day_number] .day_of_week]
elif self.locale == "fr":
hvis kort ugedag == Sandt:
output = output + self.getSpaces (mellemrum) + WeatherText.day_of_week_short_fr [self.day_forecast [day_number] .day_of_week]
andet:
output = output + self.getSpaces (mellemrum) + WeatherText.day_of_week_fr [self.day_forecast [day_number] .day_of_week]
andet:
hvis kort ugedag == Sandt:
output = output + self.getSpaces (mellemrum) + WeatherText.day_of_week_short [self.day_forecast [day_number] .day_of_week]
andet:
output = output + self.getSpaces (mellemrum) + WeatherText.day_of_week [self.day_forecast [day_number] .day_of_week]
elif datatype == "WF": # vejr skrifttype
output = output + self.getSpaces (mellemrum) + WeatherText.conditions_weather_font [self.day_forecast [day_number] .condition_code]
elif datatype == "LT":
string = self.day_forecast [day_number] .low
hvis self.isNumeric (string) == True:
hvis imperial == True:
streng = self.convertCelsiusToFahrenheit (streng)
streng = streng + tempunit
output = output + self.getSpaces (mellemrum) + streng
elif datatype == "HT":
string = self.day_forecast [day_number] .high
hvis self.isNumeric (string) == True:
hvis imperial == True:
streng = self.convertCelsiusToFahrenheit (streng)
streng = streng + tempunit
output = output + self.getSpaces (mellemrum) + streng
elif datatype == "CC":
hvis self.locale == "er":
output = output + self.getSpaces (mellemrum) + WeatherText.conditions_text_es [self.day_forecast [day_number] .condition_code]
elif self.locale == "fr":
output = output + self.getSpaces (mellemrum) + WeatherText.conditions_text_fr [self.day_forecast [day_number] .condition_code]
andet:
output = output + self.getSpaces (mellemrum) + WeatherText.conditions_text [self.day_forecast [day_number] .condition_code]
elif datatype == "CT":
output = output + self.getSpaces (mellemrum) + self.day_forecast [day_number] .condition_text
elif datatype == "PC":
string = self.day_forecast [day_number] .precip
hvis self.isNumeric (string) == True:
streng = streng + u »%»
output = output + self.getSpaces (mellemrum) + streng
elif datatype == "HM":
string = self.day_forecast [day_number] .fugtighed
hvis self.isNumeric (string) == True:
streng = streng + u »%»
output = output + self.getSpaces (mellemrum) + streng
elif datatype == "WD":
string = self.day_forecast [day_number] .wind_dir

hvis self.locale == "er":
output = output + self.getSpaces (mellemrum) + WeatherText.bearing_text_es [streng]
elif self.locale == "fr":
output = output + self.getSpaces (mellemrum) + WeatherText.bearing_text_fr [streng]
andet:
output = output + self.getSpaces (mellemrum) + streng

elif datatype == "BF":
output = output + self.getSpaces (mellemrum) + WeatherText.bearing_arrow_font [self.day_forecast [day_number] .wind_dir]
elif datatype == "WS":
string = self.day_forecast [day_number] .wind_speed
hvis self.isNumeric (string) == True:
hvis imperial == True:
string = self.convertKilometresToMiles (string)
streng = streng + hastighedsenhed
output = output + self.getSpaces (mellemrum) + streng
elif datatype == "WG":
string = self.day_forecast [day_number] .wind_gusts
hvis self.isNumeric (string) == True:
hvis imperial == True:
string = self.convertKilometresToMiles (string)
streng = streng + hastighedsenhed
output = output + self.getSpaces (mellemrum) + streng
elif datatype == "CN":
output = output + self.getSpaces (mellemrum) + self.day_forecast [day_number] .city
elif datatype == "SR":
output = output + self.getSpaces (mellemrum) + self.day_forecast [day_number] .sunrise
elif datatype == "SS":
output = output + self.getSpaces (mellemrum) + self.day_forecast [day_number] .sunset
elif datatype == "MP":
output = output + self.getSpaces (mellemrum) + self.day_forecast [day_number] .moon_phase
elif datatype == "MF":
output = output + self.getSpaces (mellemrum) + WeatherText.conditions_moon_font [self.day_forecast [day_number] .moon_icon]
elif datatype == "BR":
output = output + self.getSpaces (mellemrum) + self.day_forecast [day_number] .bar_read
elif datatype == "BD":
output = output + self.getSpaces (mellemrum) + self.day_forecast [day_number] .bar_desc
andet:
output = u »\ nFejl: Der kræves ukendt datatype»
bryde

output = u »» + output.strip (u »«) # mister ledende / bageste mellemrum
returnere output

#undtagen:
#print "getOutputText: Uventet fejl:", sys.exc_info () [0]

def getOutputTextFromTemplate (selv, skabelon):
#prøve:

# nøgler til skabelondata
DATATYPE_KEY = "–datatype ="
STARTDAY_KEY = "–startdag ="
ENDDAY_KEY = "–endday ="
NIGHT_KEY = "–nat"
SHORTWEEKDAY_KEY = "–kort ugedag"
IMPERIAL_KEY = "–imperial"
HIDEUNITS_KEY = "–hideenheder"
SPACES_KEY = "–spaces ="

output = u »»

optionfound = Falsk

# indlæs filen
prøve:
fileinput = åben (self.options.template)
skabelon = fileinput.read ()
fileinput.close ()
undtagen:
output = u »Skabelonfil ikke fundet!»

skabelonliste = self.getTemplateList (skabelon)

# lader os gennem skabelonlisten og bestemme output for hvert fundet element
for i inden for rækkevidde (0, len (skabelonliste) -1):

pos = skabelonliste [i]. find (DATATYPE_KEY)
hvis pos! = -1:
optionfound = Sandt
pos = pos + len (DATATYPE_KEY)
datatype = skabelonliste [i] [pos: pos + 4]. strip («}»). strip («{«). strip («-«). strip (»«)
andet:
datatype = Ingen

pos = skabelonliste [i]. find (STARTDAY_KEY)
hvis pos! = -1:
optionfound = Sandt
pos = pos + len (STARTDAY_KEY)
startdag = int (skabelonliste [i] [pos: pos + 4]. strip ("}"). strip ("{"). strip ("-"). strip (""))
andet:
startdag = Ingen

pos = skabelonliste [i]. find (ENDDAY_KEY)
hvis pos! = -1:
optionfound = Sandt
pos = pos + len (ENDDAY_KEY)
slutdag = int (skabelonliste [i] [pos: pos + 4]. strip ("}"). strip ("{"). strip ("-"). strip (""))
andet:
slutdag = Ingen

pos = skabelonliste [i]. find (NIGHT_KEY)
hvis pos! = -1:
optionfound = Sandt
nat = Sandt
andet:
nat = falsk

pos = skabelonliste [i]. find (SHORTWEEKDAY_KEY)
hvis pos! = -1:
optionfound = Sandt
kort ugedag = Sandt
andet:
kort ugedag = Falsk

pos = skabelonliste [i] .find (IMPERIAL_KEY)
hvis pos! = -1:
optionfound = Sandt
imperial = sandt
andet:
imperial = Falsk

pos = skabelonliste [i]. find (HIDEUNITS_KEY)
hvis pos! = -1:
optionfound = Sandt
skjuleenheder = Sandt
andet:
skjuleenheder = falsk

pos = skabelonliste [i] .find (SPACES_KEY)
hvis pos! = -1:
optionfound = Sandt
pos = pos + len (SPACES_KEY)
mellemrum = int (skabelonliste [i] [pos: pos + 4]. strip («}»). strip («{«). strip («-«). strip (»«))
andet:
mellemrum = 1

hvis optionfound == True:
templatelist [i] = self.getOutputText (datatype, startdag, slutdag, nat, kort ugedag, kejserlig, skjuleenheder, mellemrum)
optionfound = Falsk

# gå gennem listen, der sammenkæder output nu, hvor det er befolket
for vare i skabelonliste:
output = output + vare

returnere output

#undtagen:
#print "getOutputTextFromTemplate: Uventet fejl:", sys.exc_info () [0]

def fetchData (selv):

# hent altid metriske data, brug samtalefunktioner på disse data
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)

hvis self.isConnectionAvailable () == Falsk:
hvis os.path.exists (file_path_current):
RefetchData = Falsk
andet: # ingen forbindelse, ingen cache, bang!
udskrive "Ingen internetforbindelse er tilgængelig, og der findes ingen cachede vejrdata."
elif self.options.refetch == Sandt:
RefetchData = Sandt
andet:
# skal dataene hentes igen?
hvis os.path.exists (file_path_current):
lastmodDate = time.localtime (os.stat (file_path_current) [ST_MTIME])
expiryDate = (datetime.datetime.today () - datetime.timedelta (minutter = self.EXPIRY_MINUTES)). tidsplan ()

hvis expiryDate> lastmodDate:
RefetchData = Sandt
andet:
RefetchData = Falsk
andet:
RefetchData = Sandt

# hent de aktuelle forholdsdata, enten fra hjemmesiden eller ved at 'fjerne markeringen'
hvis RefetchData == True:

# få aktuelle forholdsdata fra xoap-tjenesten
prøve:

# 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 & enhed = m '
hvis self.options.verbose == Sandt:
udskriv >> sys.stdout, «henter vejrdata fra«, url

Usock = urllib2.urlopen (url)
xml = usock.read ()
Usock.close ()
self.weatherxmldoc = minidom.parseString (xml)
undtagen:
udskriv "fetchData: Uventet fejl:", sys.exc_info () [0]
print "Kan ikke kontakte vejrkilde for aktuelle forhold"

# fortæl brugeren, hvis placeringen er dårlig ...
fundet = xml.find ("Ugyldig placering angivet")
hvis fundet! = -1:
udskriv "Ugyldig placering leveret"

# forhør vejrdata, indlæs i klassestrukturen og sylt dem
prøve:

# forbered lister over vejrdata
self.current_conditions = []
self.day_forecast = []
self.night_forecast = []

# indsamle generelle data
weather_n = self.weatherxmldoc.documentElement
location_n = weather_n.getElementsByTagName ('loc') [0]
city_n = location_n.getElementsByTagName ('dnam') [0]
by = self.getText (city_n.childNodes)

# indsamle aktuelle forholdsdata
day_of_week = u »I dag»
nedbør = u »Ikke relevant»
sunrise_n = location_n.getElementsByTagName ('sunr') [0]
solopgang = self.getText (sunrise_n.childNodes)
sunset_n = location_n.getElementsByTagName ('suns') [0]
solnedgang = 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 ('ikon') [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 ('vind') [0]
wind_speed_n = wind_n.getElementsByTagName (s) [0]
wind_speed = self.getText (wind_speed_n.childNodes)
wind_gust_n = wind_n.getElementsByTagName ('vindstød') [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)
fugtighed_n = nuværende_betingelse_n.getElementsByTagName ('hmid') [0]
fugtighed = self.getText (fugtighed_n.childNodes)
moon_n = current_condition_n.getElementsByTagName ('moon') [0]
moon_icon_n = moon_n.getElementsByTagName ('ikon') [0]
moon_icon = self.getText (moon_icon_n.childNodes)
moon_phase_n = moon_n.getElementsByTagName ('t') [0]
moon_phase = self.getText (moon_phase_n.childNodes)
current_conditions_data = WeatherData (day_of_week, current_temp_feels, current_temp, current_code, current_desc, precip, fugtighed, vindretning, vindhastighed, vindstød, by, solopgang, solnedgang, månefase, moon_icon, bar_read, bar_desc)
self.current_conditions.append (aktuelle_conditions_data)

# indsaml prognosedata
bar_read = u »Ikke relevant»
bar_desc = u »Ikke relevant»
moon_phase = u »Ikke relevant»
moon_icon = u »na»
forecast_n = weather_n.getElementsByTagName ('dayf') [0]
day_nodes = forecast_n.getElementsByTagName ('dag')

for dag i dag_noder:
day_of_week = day.getAttribute ('t')
day_of_year = day.getAttribute ('dt')
high_temp_n = day.getElementsByTagName ('hej') [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]
solopgang = self.getText (sunrise_n.childNodes)
sunset_n = day.getElementsByTagName ('suns') [0]
solnedgang = self.getText (sunset_n.childNodes)

# dages prognosespecifikke data
daytime_n = day.getElementsByTagName ('del') [0] # dag
condition_code_n = daytime_n.getElementsByTagName ('ikon') [0]
condition_code = self.getText (condition_code_n.childNodes)
condition_n = daytime_n.getElementsByTagName ('t') [0]
betingelse = self.getText (condition_n.childNodes)
precip_n = daytime_n.getElementsByTagName ('ppcp') [0]
udfældning = self.getText (udfældning_n.barndnoder)
fugtighed_n = dagtid_n.getElementsByTagnavn ('hmid') [0]
fugtighed = self.getText (fugtighed_n.childNodes)
wind_n = daytime_n.getElementsByTagName ('vind') [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 (dag_of_uge, lav_temp, høj_temp, tilstand_kode, tilstand, nedbør, fugtighed, vindretning, vindhastighed, vindstød, by, solopgang, solnedgang, månefase, måne_ikon, bar_læs, bar_desc)
self.day_forecast.append (day_forecast_data)

# nat prognose specifikke data
daytime_n = day.getElementsByTagName ('del') [1] # nat
condition_code_n = daytime_n.getElementsByTagName ('ikon') [0]
condition_code = self.getText (condition_code_n.childNodes)
condition_n = daytime_n.getElementsByTagName ('t') [0]
betingelse = self.getText (condition_n.childNodes)
precip_n = daytime_n.getElementsByTagName ('ppcp') [0]
udfældning = self.getText (udfældning_n.barndnoder)
fugtighed_n = dagtid_n.getElementsByTagnavn ('hmid') [0]
fugtighed = self.getText (fugtighed_n.childNodes)
wind_n = daytime_n.getElementsByTagName ('vind') [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 = WeatherData (dag_of_uge, lav_temp, høj_temp, tilstand_kode, tilstand, nedbør, fugtighed, vindretning, vindhastighed, vindstød, by, solopgang, solnedgang, månefase, måne_ikon, bar_læs, bar_desc)
self.night_forecast.append (night_forecast_data)

# pick dataene til næste gang!
fileoutput = åben (file_path_current, 'w')
pickle.dump (self.current_conditions, fileoutput)
fileoutput.close ()

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

fileoutput = åben (file_path_nightforecast, 'w')
pickle.dump (self.night_forecast, filoutput)
fileoutput.close ()

undtagen:
udskriv "fetchData: Uventet fejl:", sys.exc_info () [0]
udskrive "Kan ikke forhøre vejrdataene"

andet: # hent vejrdata fra syltede klassefiler
hvis self.options.verbose == Sandt:
udskriv >> sys.stdout, «henter vejrdata fra fil:«, file_path_current

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

hvis self.options.verbose == Sandt:
udskriv >> sys.stdout, "hentning af dagsforudsigelsesdata fra filer:", file_path_dayforecast, file_path_nightforecast

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

hvis self.options.verbose == Sandt:
udskriv >> sys.stdout, "henter dags prognosedata fra filer:", file_path_nightforecast, file_path_nightforecast

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

def outputData (selv):
#prøve:

hvis self.options.template! = Ingen:

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

andet:

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")

#undtagen:
#print «outputData: Uventet fejl:«, sys.exc_info () [0]

hvis __name__ == "__main__":

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

hvis option.verbose == True:
udskriv >> sys.stdout, "location:", options.location
udskriv >> sys.stdout, "imperial:", options.imperial
udskriv >> sys.stdout, "datatype:", options.datatype
udskriv >> sys.stdout, "night:", options.night
udskriv >> sys.stdout, "startdag:", optioner. startdag
udskriv >> sys.stdout, "end day:", options.endday
udskriv >> sys.stdout, "mellemrum:", valgmuligheder. rum
udskriv >> sys.stdout, "verbose:", options.verbose
udskriv >> sys.stdout, "refetch:", options.refetch

# Opret nyt globalt vejrobjekt
vejr = GlobalWeather (optioner)
weather.fetchData ()
weather.outputData ()

Vi opretter filen ~ / Conky / scripts / myweather.template

gedit ~ / Conky / scripts / myweather.template

vi indsætter følgende indeni:

{–Datatype = DW –startdag = 1}: {–datatype = CC – startdag = 1}
{–Datatype = HT –startdag = 1} / {–datatype = LT – startdag = 1} Vind fra {–datatype = WD – startdag = 1} til {–datatype = WS – startdag = 1}
Fugtighed: {–datatype = HM –startdag = 1} Nedbør: {–datatype = PC – startdag = 1}
Solopgang: {–datatype = SR –startdag = 1} Solnedgang: {–datatype = SS – startdag = 1}
----------------
{–Datatype = DW –startdag = 2}: {–datatype = CC – startdag = 2}
{–Datatype = HT –startdag = 2} / {–datatype = LT – startdag = 2} Vind fra {–datatype = WD – startdag = 2} til {–datatype = WS – startdag = 2}
Fugtighed: {–datatype = HM –startdag = 2} Nedbør: {–datatype = PC – startdag = 2}
Solopgang: {–datatype = SR –startdag = 2} Solnedgang: {–datatype = SS – startdag = 2}
----------------
{–Datatype = DW –startdag = 3}: {–datatype = CC – startdag = 3}
{–Datatype = HT –startdag = 3} / {–datatype = LT – startdag = 3} Vind fra {–datatype = WD – startdag = 3} til {–datatype = WS – startdag = 3}
Fugtighed: {–datatype = HM –startdag = 3} Nedbør: {–datatype = PC – startdag = 3}
Solopgang: {–datatype = SR –startdag = 3} Solnedgang: {–datatype = SS – startdag = 3}
----------------
{–Datatype = DW –startdag = 4}: {–datatype = CC – startdag = 4}
{–Datatype = HT –startdag = 4} / {–datatype = LT – startdag = 4} Vind fra {–datatype = WD – startdag = 4} til {–datatype = WS – startdag = 4}
Fugtighed: {–datatype = HM –startdag = 4} Nedbør: {–datatype = PC – startdag = 4}
Solopgang: {–datatype = SR –startdag = 4} Solnedgang: {–datatype = SS – startdag = 4}

Vi opretter filen ~ / Conky / scripts / mail / conkyEmail.py (vi skal oprette mailmappen)

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

og indsæt følgende indeni:

importere dig
importstreng

#Indtast dit brugernavn og din adgangskode nedenfor med dobbelt anførselstegn
# for eksempel. brugernavn = »brugernavn» og adgangskode = »adgangskode»
brugernavn = »DIN_USUARIO_SINARROBA«
adgangskode = »DIN_LYFTE«

com = »wget -O - https: //» + brugernavn + »:» + adgangskode + »@ mail.google.com / mail / feed / atom – intet check-certifikat»

temp = os.popen (com)
msg = temp.læs ()
index = string.find (msg, » »)
index2 = string.find (msg, » »)
fc = int (msg [index + 11: index2])

hvis fc == 0:
udskrive "0 nye"
andet:
udskriv str (fc) + »nyt»

Så nu har du 7 filer:

I mappen: ~
-> .startconky << - gør eksekverbar

I mappen: ~ / Conky
-> conkymain
-> conkyforecast
-> conkymail

og i mappen: ~ / Conky / scripts
-> conkyForecast.py << - gør eksekverbar
-> myweather.template

og i mappen: ~ / Conky / scripts / mail
conkyEmail.py << - gør eksekverbar

Og det er det, præciseringer, hvor der står / hjem / bruger / ... dit brugernavn går og i den del, hvor Gmail-dataene går, fremhævede jeg i farver, hvor du skal placere dine data.

for at dræbe conky-processen, skriv til en konsol

killall conky

at køre conky skriv til en konsol

./.startconky

når du har justeret alt, hvis du vil have conky til at starte hver session

System—> Præferencer—> Sessioner og i startprogrammer tilføjer vi det

I Navn kan vi skrive Conky i rækkefølge ./.startconky med at det starter hver gang du tænder pc'en.

Det er det, jeg håber det hjælper dig.


Efterlad din kommentar

Din e-mailadresse vil ikke blive offentliggjort. Obligatoriske felter er markeret med *

*

*

  1. Ansvarlig for dataene: Miguel Ángel Gatón
  2. Formålet med dataene: Control SPAM, management af kommentarer.
  3. Legitimering: Dit samtykke
  4. Kommunikation af dataene: Dataene vil ikke blive kommunikeret til tredjemand, undtagen ved juridisk forpligtelse.
  5. Datalagring: Database hostet af Occentus Networks (EU)
  6. Rettigheder: Du kan til enhver tid begrænse, gendanne og slette dine oplysninger.