Nie można odjąć daty offsetowej i offsetowej

Poprawnym rozwiązaniem jest dodanie informacji o strefie czasowej, np. aby uzyskać bieżący czas jako świadomy obiekt datetime w Pythonie 3:

from datetime import datetime, timezone

now = datetime.now(timezone.utc)

W starszych wersjach Pythona można samemu zdefiniować obiekt utc tzinfo (przykład z datetime docs):

from datetime import tzinfo, timedelta, datetime

ZERO = timedelta(0)

class UTC(tzinfo):
  def utcoffset(self, dt):
    return ZERO
  def tzname(self, dt):
    return "UTC"
  def dst(self, dt):
    return ZERO

utc = UTC()

Wtedy:

now = datetime.now(utc)

Wiem, że niektórzy ludzie używają Django specjalnie jako interfejsu do abstrakcji tego typu interakcji z bazą danych. Django dostarcza narzędzia, które mogą być użyte do tego:

from django.utils import timezone
now_aware = timezone.now()

Musisz skonfigurować podstawową infrastrukturę ustawień Django, nawet jeśli używasz tylko tego typu interfejsu(w Ustawieniach musisz dołączyć USE_TZ=True, Aby uzyskać świadomy datetime).

Samo w sobie, prawdopodobnie nie jest to wystarczająco blisko, aby zmotywować cię do używania Django jako interfejsu, ale jest wiele innych korzyści. Z drugiej strony, jeśli natknąłeś się tutaj, ponieważ niszczyłeś swoją aplikację Django( tak jak ja), to może to pomoże...

Jest to bardzo proste i jasne rozwiązanie
dwie linijki kodu

# First we obtain de timezone info o some datatime variable    

tz_info = your_timezone_aware_variable.tzinfo

# Now we can subtract two variables using the same time zone info
# For instance
# Lets obtain the Now() datetime but for the tz_info we got before

diff = datetime.datetime.now(tz_info)-your_timezone_aware_variable

Wniosek: musisz mange swoje zmienne datetime z tym samym czasie info

Ja również stanąłem przed tym samym problemem. Potem znalazłem rozwiązanie po wielu poszukiwaniach .

Problem polegał na tym, że gdy otrzymujemy obiekt datetime z modelu lub postaci, jest to offset aware , a jeśli otrzymamy czas przez system, to jest to offset naive.

Więc to, co zrobiłem, to otrzymałem bieżący czas używając strefy czasowej.now () i zaimportuj strefę czasową przez z django.utils importuje strefę czasową i umieszcza USE_TZ = True w pliku ustawień projektu.

Moduł psycopg2 ma własne definicje stref czasowych, więc skończyło się na pisaniu własnego wrappera wokół utcnow:

def pg_utcnow():
    import psycopg2
    return datetime.utcnow().replace(
        tzinfo=psycopg2.tz.FixedOffsetTimezone(offset=0, name=None))

I po prostu użyj pg_utcnow, gdy potrzebujesz bieżącego czasu, aby porównać z PostgreSQL timestamptz

Wymyśliłem ultra-proste rozwiązanie:

import datetime

def calcEpochSec(dt):
    epochZero = datetime.datetime(1970,1,1,tzinfo = dt.tzinfo)
    return (dt - epochZero).total_seconds()

Działa zarówno z wartością timezone-aware, jak i timezone-naiwne datetime. Nie są wymagane żadne dodatkowe biblioteki ani obejścia w bazie danych.

Znalazłem timezone.make_aware(datetime.datetime.now()) jest pomocny w django(jestem na 1.9.1). Niestety nie można po prostu zrobić datetime obiekt offsetowy świadomy, a następnie timetz() to. Musisz zrobić datetime i dokonać porównań na tej podstawie.

Czy Jest jakiś pilny powód, dla którego nie możesz poradzić sobie z obliczaniem wieku w samym PostgreSQL? Coś jak

select *, age(timeStampField) as timeStampAge from myTable

Wiem, że to stare, ale pomyślałem, że dodam moje rozwiązanie na wypadek, gdyby ktoś uznał je za przydatne.

Chciałem porównać lokalny naiwny datetime ze świadomym datetime z serwera czasowego. W zasadzie stworzyłem nowy naiwny obiekt datetime przy użyciu świadomego obiektu datetime. To trochę hack i nie wygląda bardzo ładnie, ale robi robotę.

import ntplib
import datetime
from datetime import timezone

def utc_to_local(utc_dt):
    return utc_dt.replace(tzinfo=timezone.utc).astimezone(tz=None)    

try:
    ntpt = ntplib.NTPClient()
    response = ntpt.request('pool.ntp.org')
    date = utc_to_local(datetime.datetime.utcfromtimestamp(response.tx_time))
    sysdate = datetime.datetime.now()

...nadchodzi krówka...

    temp_date = datetime.datetime(int(str(date)[:4]),int(str(date)[5:7]),int(str(date)[8:10]),int(str(date)[11:13]),int(str(date)[14:16]),int(str(date)[17:19]))
    dt_delta = temp_date-sysdate
except Exception:
    print('Something went wrong :-(')

Nie potrzebujesz niczego poza std libs

datetime.datetime.now().astimezone()

Jeśli po prostu zastąpisz strefę czasową, nie dostosujesz czasu. Jeśli Twój system jest już UTC to .replace (TZ='UTC') jest w porządku.

>>> x=datetime.datetime.now()
datetime.datetime(2020, 11, 16, 7, 57, 5, 364576)

>>> print(x)
2020-11-16 07:57:05.364576

>>> print(x.astimezone()) 
2020-11-16 07:57:05.364576-07:00

>>> print(x.replace(tzinfo=datetime.timezone.utc)) # wrong
2020-11-16 07:57:05.364576+00:00