Ne peut pas soustraire des heures de temps naïves et sensibles à l'offset

J'ai un timestamptzchamp sensible au fuseau horaire dans PostgreSQL. Lorsque je tire des données du tableau, je veux ensuite soustraire le temps maintenant afin que je puisse obtenir son âge.

Le problème que je vais avoir est que les deux datetime.datetime.now()et datetime.datetime.utcnow()semblent revenir fuseau horaire horodatages pas au courant, ce qui conduit à me faire cette erreur:

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

Existe-t-il un moyen d'éviter cela (de préférence sans qu'un module tiers soit utilisé).

EDIT: Merci pour les suggestions, cependant essayer d'ajuster le fuseau horaire semble me donner des erreurs .. donc je vais juste utiliser des horodatages ignorés du fuseau horaire dans PG et toujours insérer en utilisant:

NOW() AT TIME ZONE 'UTC'

De cette façon, tous mes horodatages sont UTC par défaut (même si c'est plus ennuyeux de le faire).

avez-vous essayé de supprimer la prise de conscience du fuseau horaire?

depuis http://pytz.sourceforge.net/

naive = dt.replace(tzinfo=None)

Il se peut que vous deviez également ajouter une conversion de fuseau horaire.

modifier: Veuillez connaître l'âge de cette réponse. Une réponse Python 3 est ci-dessous.

La bonne solution consiste à ajouter les informations de fuseau horaire, par exemple, pour obtenir l'heure actuelle en tant qu'objet datetime conscient dans Python 3:

from datetime import datetime, timezone

now = datetime.now(timezone.utc)

Sur les anciennes versions de Python, vous pouviez définir utcvous-même l'objet tzinfo (exemple de la documentation 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()

puis:

now = datetime.now(utc)

Je sais que certaines personnes utilisent Django spécifiquement comme interface pour résumer ce type d'interaction avec la base de données. Django fournit des utilitaires qui peuvent être utilisés pour cela:

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

Vous devez configurer une infrastructure de paramètres Django de base, même si vous utilisez simplement ce type d'interface (dans les paramètres, vous devez inclure USE_TZ=Truepour obtenir une date / heure consciente).

En soi, cela est probablement loin d'être suffisant pour vous motiver à utiliser Django comme interface, mais il existe de nombreux autres avantages. D'un autre côté, si vous êtes tombé ici parce que vous manipuliez votre application Django (comme je l'ai fait), alors peut-être que cela aide ...

Ceci est une solution très simple et claire
Deux lignes de code

# 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

Conclusion: vous devez gérer vos variables datetime avec les mêmes informations de temps

Le module psycopg2 a ses propres définitions de fuseau horaire, j'ai donc fini par écrire mon propre wrapper autour d'utcnow:

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

et utilisez simplement pg_utcnowchaque fois que vous avez besoin de l'heure actuelle pour comparer avec un PostgreSQLtimestamptz

J'ai également rencontré le même problème. Ensuite, j'ai trouvé une solution après de nombreuses recherches.

Le problème était que lorsque nous obtenons l'objet datetime à partir d'un modèle ou d'une forme, il est conscient du décalage et si nous obtenons l'heure par le système, il est naïf .

Donc, ce que j'ai fait, c'est que j'ai obtenu l'heure actuelle en utilisant timezone.now () et en important le fuseau horaire à partir de django.utils import timezone et en mettant USE_TZ = True dans votre fichier de paramètres de projet.

J'ai trouvé une solution ultra simple:

import datetime

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

Il fonctionne avec des valeurs datetime sensibles au fuseau horaire et naïves au fuseau horaire. Et aucune bibliothèque ou solution de contournement de base de données supplémentaire n'est requise.

Je l'ai trouvé timezone.make_aware(datetime.datetime.now())utile dans Django (je suis sur 1.9.1). Malheureusement, vous ne pouvez pas simplement rendre un datetimeobjet sensible à l'offset, alors timetz(). Vous devez faire un datetimeet faire des comparaisons sur la base de cela.

Y a-t-il une raison urgente pour laquelle vous ne pouvez pas gérer le calcul de l'âge dans PostgreSQL lui-même? Quelque chose comme

select *, age(timeStampField) as timeStampAge from myTable

Je sais que c'est vieux, mais je pensais simplement ajouter ma solution au cas où quelqu'un la trouverait utile.

Je voulais comparer le datetime naïf local avec un datetime conscient d'un serveur de temps. J'ai essentiellement créé un nouvel objet datetime naïf en utilisant l'objet datetime conscient. C'est un peu un hack et n'a pas l'air très joli mais fait le travail.

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

... voici le fudge ...

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