Zeitdifferenzen und Abfrageobjekte für SQLite

[JuMi2006]

Ja es scheint ein Problem zu geben. Werde versuchen das in den nächsten Tagen zu fixen ... ad hoc sehe ich keinen Fehler im Code da die Methode definiert wurde und existiert.

[Ferengi]

hallo,

tolle sache, läuft hier seit einigen Tagen eigentlich problemlos.
seit heute fällt mir allerdings folgende Meldung auf

2015-02-01 09:54:00 ERROR    zeit         Logic: zeit, File: /usr/local/smarthome/logics/zeit.py, Line: 18, Method: days_of_month, Exception: name 'leap_year' is not defined
Traceback (most recent call last):
  File "/usr/local/smarthome/lib/scheduler.py", line 341, in _task
    exec(obj.bytecode)
  File "/usr/local/smarthome/logics/zeit.py", line 93, in <module>
    sh.day.until.month(days_of_month(sh_now.month,sh_now.year) - sh.day.since.month() - 1)
  File "/usr/local/smarthome/logics/zeit.py", line 18, in days_of_month
    elif leap_year(year):
NameError: name 'leap_year' is not defined

mache ich irgend etwas falsch oder gibts vielleicht ein problem mit dem Februar/Schaltjahrberechnung?

Christian

[JuMi2006]

Ausgehend von diesem Thema https://knx-user-forum.de/smarthome-...verbrauch.html habe ich mich an die Arbeit gemacht und mir ein paar items erstellt die in Logiken etc. sinvoll sein können.

Die Namen habe ich eigentlich so gewählt dass es "international" und "selbsterklärend" ist.

Beispiel:
Aktuelle Uhrzeit ist 21.12.2014 um 13:19 - dies ist nur ein kleiner Auszug.

minute.since.hour = 19
minute.since.hour.dbstr = 19i
minute.since.midnight = 799
minute.since.midnight.dbstr = 799i
minute.until.hour = 40
minute.until.hour.dbstr = 40i
minute.until.midnight = 640
minute.until.midnight.dbstr = 640i
hour.since.midnight = 13
hour.since.midnight.dbstr = 13h
hour.until.midnight = 10
hour.until.midnight.dbstr = 10h
day.since.week = 7
day.since.week.dbstr = 7d
day.since.month = 20
day.since.month.dbstr = 20d
day.until.week = 0
day.until.week.dbstr = 7d
day.until.month = 10
day.until.month.dbstr = 10d

Dabei werden immer nur ganze Minuten, Sekunden, Stunden etc. berücksichtigt. Um 13:10 sind also nur noch 10 volle Stunden bis Mitternacht und 13 Stunden seit Mitternacht.

Das *.dbstr Item ist der fertige String für die Abfrage im SQLite Plugin. Damit kann man den Mitternachtswert von foo.bar mit foo.bar.db('min',sh.minute.since.midnight()) abfragen.

Hier die Dateien:
logic.conf

#logic.conf
[zeit]
filename = zeit.py
crontab = init | * * * *

zeit.py

#/logics/zeit.py
#!/usr/bin/env python
sh_now = sh.now()
debug = False

# Funktionen                    
def leap_year(year):
    if (year % 400 == 0) or ((year % 4 == 0) and not (year % 100 == 0)):
        return True
    else:
        return False

def days_of_month(month, year):
    if month in [1, 3, 5, 7, 8, 10, 12]:
        days = 31
    elif month in [4, 6, 9, 11]:
        days = 30
    elif leap_year(year):
        days = 29
    else:
        days = 28
    return days

def days_of_year(year):
    period_end = datetime.datetime(year,12,31)
    days_of_year = (period_end - datetime.datetime(period_end.year, 1, 1)).days + 1
    return(days_of_year)

def day_of_year(year,month,day):
    period_end = datetime.datetime(year,month,day)
    day_of_year = (period_end - datetime.datetime(period_end.year, 1, 1)).days + 1
    return(day_of_year)

if debug == True:
    print("RUNNING LOGIC OF TIME - REMOVE AFTER DEBUG")
    print(sh_now.hour) #Stunde
    print(sh_now.minute) #Minute
    print(sh_now.second) #Sekunde
    print(sh_now.day)  #Tag
    print(sh_now.month) #Monat
    print(sh_now.isoweekday()) #Wochentag
    print(sh.now().isocalendar()[1]) #Kalenderwoche
    
# Sekunde/Minute
sh.second.since.minute(sh_now.second)
sh.second.until.minute(60 - sh_now.second - 1)

# Minute/Stunde
sh.minute.since.hour(sh_now.minute)
sh.minute.until.hour(60 - sh_now.minute - 1)

# Stunde/Tag
sh.hour.since.midnight(sh_now.hour)
sh.hour.until.midnight(24 - sh_now.hour - 1)

# Tag/Woche
sh.day.since.week(sh_now.isoweekday())
sh.day.until.week(7 - sh_now.isoweekday())

# Stunde/Woche
sh.hour.since.week(sh.hour.since.midnight() + (24 * (sh.day.since.week() - 1)))
sh.hour.until.week(sh.hour.until.midnight() + (24 * sh.day.until.week()))

# Kalenderwoche/Jahr
sh.week.since.year(sh.now().isocalendar()[1])

# Monat/Jahr
sh.month.since.year(sh_now.month)
sh.month.until.year(12-sh_now.month)

# Sekunde/Stunde
sh.second.since.hour(sh.second.since.minute() + (60 * sh.minute.since.hour()))
sh.second.until.hour(sh.second.until.minute() + (60 * sh.minute.until.hour()))

# Sekunde/Tag
sh.second.since.midnight(sh.second.since.minute() + (3600 * sh.hour.since.midnight()))
sh.second.until.midnight(sh.second.until.minute() + (3600 * sh.hour.until.midnight()))

# Minute/Tag
sh.minute.since.midnight(sh.minute.since.hour() + (60 * sh.hour.since.midnight()))
sh.minute.until.midnight(sh.minute.until.hour() + (60 * sh.hour.until.midnight()))

# Minute/Woche
sh.minute.since.week(sh.minute.since.hour() + (60 * sh.hour.since.week()))
sh.minute.until.week(sh.minute.until.hour() + (60 * sh.hour.until.week()))

# Sekunde/Woche
sh.second.since.week(sh.second.since.minute() + (60 * sh.minute.since.week()))
sh.second.until.week(sh.second.until.minute() + (60 * sh.minute.until.week()))

# Tage/Monat
sh.day.since.month(sh_now.day - 1)
sh.day.until.month(days_of_month(sh_now.month,sh_now.year) - sh.day.since.month() - 1)

# Tage/Jahr
sh.day.since.year(day_of_year(sh_now.year,sh_now.month,sh_now.day) - 1)
sh.day.until.year(days_of_year(sh_now.year) - sh.day.since.year() - 1)

# Stunde/Monat
sh.hour.since.month((24 * (sh.day.since.month() - 1)) + sh.hour.since.midnight())
sh.hour.until.month((24 * days_of_month(sh_now.month,sh_now.year)) - sh.hour.since.month() - 1) 

# Stunde/Jahr
sh.hour.since.year((24 * (sh.day.since.year() -1)) + sh.hour.since.midnight())
sh.hour.until.year((24 * days_of_year(sh_now.year)) - sh.hour.since.year() - 1)

# Minute/Monat
sh.minute.since.month((60 * sh.hour.since.month()) + sh.minute.since.hour())
sh.minute.until.month(sh.minute.since.month() - (60 * sh.hour.until.month()) - 1)

# Minute/Jahr
sh.minute.since.year((60 * sh.hour.since.year()) + sh.minute.since.hour())
sh.minute.until.year((60 * sh.hour.until.year()) + sh.minute.until.hour())

# Sekunde/Monat
sh.second.since.month((60 * sh.minute.since.month()) + sh.second.since.minute())
sh.second.until.month((60 * sh.minute.until.month()) + sh.second.until.minute())

# Sekunde/Jahr
sh.second.since.year((60 * sh.minute.since.year()) + sh.second.since.minute())
sh.second.until.year((60 * sh.minute.until.year()) + sh.second.until.minute())

item.conf

[month]
    [[since]]
        [[[year]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = month.since.year
                eval = str(sh.month.since.year()) + 'm'
    [[until]]
        [[[year]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = month.until.year
                eval = str(sh.month.until.year()) + 'm'
[week]
    [[since]]
        [[[month]]]
            type = num
        [[[year]]]
            type = num
    [[until]]
        [[[month]]]
            type = num
        [[[year]]]
            type = num
[day]
    [[since]]
        [[[week]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = day.since.week
                eval = str(sh.day.since.week()) + 'd'
        [[[month]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = day.since.month
                eval = str(sh.day.since.month()) + 'd'
        [[[year]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = day.since.year
                eval = str(sh.day.since.year()) + 'd'
    [[until]]
        [[[week]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = day.since.week
                eval = str(sh.day.since.week()) + 'd'
        [[[month]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = day.until.month
                eval = str(sh.day.until.month()) + 'd'
        [[[year]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = day.until.year
                eval = str(sh.day.until.year()) + 'd'
        
[hour]
    [[since]]
        [[[midnight]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = hour.since.midnight
                eval = str(sh.hour.since.midnight()) + 'h'
        [[[week]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = hour.since.week
                eval = str(sh.hour.since.week()) + 'h'
        [[[month]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = hour.since.month
                eval = str(sh.hour.since.month()) + 'h'
        [[[year]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = hour.since.year
                eval = str(sh.hour.since.year()) + 'h'
    [[until]]
        [[[midnight]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = hour.until.midnight
                eval = str(sh.hour.until.midnight()) + 'h'
        [[[week]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = hour.until.week
                eval = str(sh.hour.until.week()) + 'h'
        [[[month]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = hour.until.month
                eval = str(sh.hour.until.month()) + 'h'
        [[[year]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = hour.until.year
                eval = str(sh.hour.until.year()) + 'h'
[minute]
    [[since]]
        [[[hour]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = minute.since.hour
                eval = str(sh.minute.since.hour()) + 'i'
        [[[midnight]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = minute.since.midnight
                eval = str(sh.minute.since.midnight()) + 'i'
        [[[week]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = minute.since.week
                eval = str(sh.minute.since.week()) + 'i'
        [[[month]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = minute.since.month
                eval = str(sh.minute.since.month()) + 'i'
        [[[year]]]
            type = num   
            [[[[dbstr]]]]
                type = str
                eval_trigger = minute.since.year
                eval = str(sh.minute.since.year()) + 'i'
    [[until]]
        [[[hour]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = minute.until.hour
                eval = str(sh.minute.until.hour()) + 'i'
        [[[midnight]]]
            type = num
            [[[[dbstr]]]]
                type = str
                eval_trigger = minute.until.midnight
                eval = str(sh.minute.until.midnight()) + 'i'
        [[[week]]]
            type = num   
            [[[[dbstr]]]]
                type = str
                eval_trigger = minute.until.week
                eval = str(sh.minute.until.week()) + 'i'
        [[[month]]]
            type = num   
            [[[[dbstr]]]]
                type = str
                eval_trigger = minute.until.month
                eval = str(sh.minute.until.month()) + 'i'
        [[[year]]]
            type = num   
            [[[[dbstr]]]]
                type = str
                eval_trigger = minute.until.year
                eval = str(sh.minute.until.year()) + 'i'
[second]
    [[since]]
        [[[minute]]]
            type = num
        [[[hour]]]
            type = num
        [[[midnight]]]
            type = num
        [[[week]]]
            type = num
        [[[month]]]
            type = num
        [[[year]]]
            type = num
    [[until]]
        [[[minute]]]
            type = num
        [[[hour]]]
            type = num
        [[[midnight]]]
            type = num
        [[[week]]]
            type = num
        [[[month]]]
            type = num
        [[[year]]]
            type = num

Unschlüssig bin ich noch beim Umgang mit den Wochen. Vielleicht kanns ja jemand gebrauchen.

Gruß Mirko