Impossibile sottrarre i periodi di dati ingenui e consapevoli dell'offset

Ho un timestamptzcampo sensibile al fuso orario in PostgreSQL. Quando estraggo i dati dalla tabella, desidero quindi sottrarre l'ora in questo momento in modo da poter ottenere l'età.

Il problema che sto riscontrando è che entrambi datetime.datetime.now()e datetime.datetime.utcnow()sembrano restituire timestamp inconsapevoli del fuso orario, il che mi fa ottenere questo errore:

TypeError: can't subtract offset-naive and offset-aware datetimes 

C'è un modo per evitarlo (preferibilmente senza l'utilizzo di un modulo di terze parti).

EDIT: Grazie per i suggerimenti, tuttavia cercare di regolare il fuso orario sembra darmi errori .. quindi userò timestamp inconsapevoli di fuso orario in PG e inserirò sempre usando:

NOW() AT TIME ZONE 'UTC'

In questo modo tutti i miei timestamp sono UTC per impostazione predefinita (anche se è più fastidioso farlo).

hai provato a rimuovere la consapevolezza del fuso orario?

da http://pytz.sourceforge.net/

naive = dt.replace(tzinfo=None)

potrebbe essere necessario aggiungere anche la conversione del fuso orario.

modifica: si prega di essere consapevoli dell'età di questa risposta. Una risposta di Python 3 è di seguito.

La soluzione corretta è aggiungere le informazioni sul fuso orario, ad esempio, per ottenere l'ora corrente come oggetto datetime consapevole in Python 3:

from datetime import datetime, timezone

now = datetime.now(timezone.utc)

Nelle versioni precedenti di Python, potresti definire utctu stesso l'oggetto tzinfo (esempio dai documenti datetime):

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

poi:

now = datetime.now(utc)

So che alcune persone usano Django specificamente come interfaccia per astrarre questo tipo di interazione con il database. Django fornisce utility che possono essere utilizzate per questo:

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

È necessario configurare un'infrastruttura di impostazioni Django di base, anche se si sta semplicemente utilizzando questo tipo di interfaccia (nelle impostazioni, è necessario includere USE_TZ=Trueper ottenere un datetime consapevole).

Di per sé, questo probabilmente non è abbastanza vicino per motivarti a usare Django come interfaccia, ma ci sono molti altri vantaggi. D'altra parte, se ti sei imbattuto qui perché stavi distruggendo la tua app Django (come ho fatto io), allora forse questo aiuta ...

Questa è una soluzione molto semplice e chiara
Due righe di codice

# 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

Conclusione: è necessario gestire le variabili datetime con le stesse informazioni sull'ora

Il modulo psycopg2 ha le sue definizioni di fuso orario, quindi ho finito per scrivere il mio wrapper su utcnow:

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

e basta usare pg_utcnowogni volta che è necessario il tempo corrente per confrontare con un PostgreSQLtimestamptz

Ho anche affrontato lo stesso problema. Poi ho trovato una soluzione dopo molte ricerche.

Il problema era che quando otteniamo l'oggetto datetime dal modello o dal modulo, viene rilevato l'offset e se otteniamo il tempo dal sistema, esso viene compensato ingenuo .

Quindi quello che ho fatto è stato ottenere l'ora corrente usando timezone.now () e importare il fuso orario da django.utils importare il fuso orario e inserire USE_TZ = True nel file delle impostazioni del progetto.

Ho trovato una soluzione semplicissima:

import datetime

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

Funziona con valori datetime sia in base al fuso orario che ingenui. E non sono necessarie ulteriori librerie o soluzioni alternative al database.

Ho trovato timezone.make_aware(datetime.datetime.now())utile in Django (sono in 1.9.1). Sfortunatamente non puoi semplicemente rendere un datetimeoggetto sensibile all'offset, quindi timetz(). Devi fare un datetimee fare confronti basati su quello.

C'è qualche motivo urgente per cui non puoi gestire il calcolo dell'età in PostgreSQL stesso? Qualcosa di simile a

select *, age(timeStampField) as timeStampAge from myTable

So che è vecchio, ma ho pensato di aggiungere la mia soluzione nel caso in cui qualcuno la trovasse utile.

Volevo confrontare il datetime ingenuo locale con un datetime consapevole di un timeserver. Fondamentalmente ho creato un nuovo oggetto datetime ingenuo usando l'oggetto datetime consapevole. È un po 'un trucco e non sembra molto carino ma fa il lavoro.

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

... ecco che arriva il fondente ...

    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 :-(')