We Keep Coding

Why using validators=[URLValidator] when defining a model CharField doesn't make it check for URL-validity upon saving the corresponding ModelForm?

app.models.py:
from django.core.validators import URLValidator
from django.db import models
class Snapshot(models.Model):
url = models.CharField(max_length=1999, validators=[URLValidator])
app.forms.py:
from django import forms
from .models import Snapshot
class SnapshotForm(forms.ModelForm):
class Meta:
model = Snapshot
fields = ('url',)
app.views.py:
from django.http import HttpResponse
from .forms import SnapshotForm
def index(request):
snapshot_form = SnapshotForm(data={'url': 'not an URL!'})
if snapshot_form.is_valid():
snapshot_form.save()
return HttpResponse("")
Why does it save 'not an URL!' into DB, despite the fact that it ain't a valid URL?!
What is the right way to incorporate URLValidator?

You've specified the validators for your field like so: validators=[URLValidator]. This is incorrect because the validators argument takes in a list of callables that perform the validation. In this case even though URLValidator is callable but that's actually the __init__ method of the class being called. You need to pass an instance of the class for it to work properly:
# Note the brackets after URLValidator to instantiate the class
url = models.CharField(max_length=1999, validators=[URLValidator()])
Better yet since you want to take input a URL you should simply use the URLField class for your field:
url = models.URLField(max_length=1999)

Django Rest Framework Returns old Data after post_save Signal

I have game,genre and producer tables. User creates new games through admin panel. After user creates a new game i need to do something but i have a problem. After new game has been created django sends signal and runs game_changed method. Problem is when i send get request to /api/game/ (Django rest framework endpoint) after i got signal of new game has been created response doesn't have this new model. More interesting is first i get count of game table through Game.objects.count i get 3 (correct) after that i send get request to game endpoint and response has 2 games. What causes this?
Models:
class Game(models.Model):
name=models.CharField(max_length=50)
producer=models.ForeignKey("Producer",on_delete=models.CASCADE)
genres=models.ManyToManyField("Genre")
def __str__(self):
return self.name
class Producer(models.Model):
name=models.CharField(max_length=50)
def __str__(self):
return self.name
class Genre(models.Model):
name=models.CharField(max_length=50)
def __str__(self):
return self.name
Signals:
from django.db.models import signals
from django.dispatch import receiver
from .models import Game
#receiver(signals.post_save,sender=Game)
def game_changed(sender,**kwargs):
print(Game.objects.count())#Returns 3
import requests
url="http://localhost:8000/api/game/"
response=requests.get(url)
print(response.json())# returns 2 games instead of 3
Views:
from rest_framework.viewsets import ReadOnlyModelViewSet
from .serializers import GenreSerializer,GameSerializer,ProducerSerializer
from .models import Genre,Game,Producer
class GenreViewSet(ReadOnlyModelViewSet):
queryset=Genre.objects.all()
serializer_class=GenreSerializer
search_fields=("name",)
class GameViewSet(ReadOnlyModelViewSet):
queryset=Game.objects.all()
serializer_class=GameSerializer
filterset_fields=("genres","producer")
search_fields=("name",)
class ProducerViewSet(ReadOnlyModelViewSet):
queryset=Producer.objects.all()
serializer_class=ProducerSerializer
search_fields=("name",)

I believe what's occuring here is a transaction isolation timing issue. While the transaction has been committed the database hasn't gotten to the point where it's readable. You can configure the transaction isolation level in your database settings. Or you can use transaction.on_commit.
I'd probably reach for transaction.on_commit as modifying your transaction isolation level can have wide reaching effects.

how to access field using django signals

I would like to check the value of a field (lightStatusA) when a new record is saved into my Django database. I feel like iv'e read the docs 10 times and still can't grasp how to get this. Here is my current models.py code:
from django.db import models
from accounts.models import Customer
from django.conf import settings
from django.contrib.auth import get_user_model
from django.db.models.signals import post_save
class Data(models.Model):
author = models.ForeignKey(get_user_model(),on_delete=models.CASCADE,)
tempData= models.CharField(max_length=50,blank=True,)
humidData= models.CharField(max_length=50,blank=True,)
lightStatusA= models.BooleanField(default=True,)
dateTime = models.DateTimeField(auto_now_add=True)
def __str__(self):
return str(self.author)
def check_light_status(sender, **kwargs):
if kwargs['created']: #make sure its a new record
#need logic to grab instance.lightStatusA and check it's value
post_save.connect(check_light_status, sender = Data)
Is there some way of passing this value as an argument to the signal?

The check_light_status function can accept an instance parameter.
From the docs:
instance
The actual instance being saved.
Update: You said this:
instance returns the author of the post.
I am going to use my powers of deduction to guess that you tried print(instance) and saw the author. Look at your __str__ implementation.
def __str__(self):
return str(self.author)
I'd say you sabotaged yourself a bit there ;)

Ahh ok got it:
def check_light_status(sender, instance, **kwargs):
if kwargs['created']: #make sure its a new record
print(instance.lightStatusA)
This prints the the field I need to run some logic against.

In Django, how to find rows which would violate a unique together constraint?

For the following API endpoint,
import json
from django.contrib.auth.decorators import login_required
from django.http import JsonResponse, HttpResponseBadRequest
from django.views.decorators.http import require_POST
from lucy_web.models import UserApn
#login_required
#require_POST
def save_apn(request, version):
player_id = json.loads(request.body).get('player_id')
if player_id:
UserApn.objects.get_or_create(user=request.user, player_id=player_id)
return JsonResponse({'status': 'success'})
else:
return HttpResponseBadRequest()
Here is the underlying model:
from django.contrib.auth.models import User
from django.db import models
from .timestamped_model import TimeStampedModel
class UserApn(TimeStampedModel):
user = models.ForeignKey(User)
player_id = models.CharField(max_length=255)
The call to get_or_create() has been raising some MultipleObjectsReturned errors. To fix this, I'd like to impose a unique_together constraint on the user and player_id. Firstly, however, I have to write a data migration that eliminates rows that violate this unique together constraint.
How could I write a query that selects these? Right now the following has been proposed:
def remove_duplicate_apns(apps, schema_editor):
UserApn = apps.get_model('lucy_web', 'UserApn')
previous_user_id = None
previous_player_id = None
for apn in UserApn.objects.all().order_by('user_id', 'player_id'):
if apn.user_id == previous_user_id and apn.player_id == previous_player_id:
print(f'deleting {apn} (id: {apn.id})')
apn.delete()
else:
previous_user_id = apn.user_id
previous_player_id = apn.player_id
It seems, though, that this could also be done in a single query.
Update
I've found that one can pass the two fields, user and player_id, to .values(), and then check for duplicates using .distinct(). For example, the following test passes:
from django.test import TestCase
from django.contrib.auth.models import User
from myapp.models import UserApn
class UserApnTest(TestCase):
def test_1(self):
user = User.objects.create_user(username='jayz')
apn1 = UserApn.objects.create(user=user, player_id='foo')
apn2 = UserApn.objects.create(user=user, player_id='foo')
apn3 = UserApn.objects.create(user=user, player_id='bar')
self.assertEqual(
len(UserApn.objects.values('user', 'player_id')) -
len(UserApn.objects.values('user', 'player_id').distinct()), 1)
The problem remains, however, that the output from this is dictionaries with user_id and player_id, but the original id is lost, so I can't subsequently get() the duplicate objects and delete them. How can I do something similar but retain references to the duplicate objects?

I managed to group the duplicate UserApns into the following queryset:
UserApn.objects.all().difference(UserApn.objects.distinct('user', 'player_id'))
Note that passing multiple arguments to distinct() only works on PostgreSQL.

Accessing the user's request in a post_save signal

I have done the below post_save signal in my project.
from django.db.models.signals import post_save
from django.contrib.auth.models import User
# CORE - SIGNALS
# Core Signals will operate based on post
def after_save_handler_attr_audit_obj(sender, **kwargs):
print User.get_profile()
if hasattr(kwargs['instance'], 'audit_obj'):
if kwargs['created']:
kwargs['instance'].audit_obj.create(operation="INSERT", operation_by=**USER.ID**).save()
else:
kwargs['instance'].audit_obj.create(operation="UPDATE").save()
# Connect the handler with the post save signal - Django 1.2
post_save.connect(after_save_handler_attr_audit_obj, dispatch_uid="core.models.audit.new")
The operation_by column, I want to get the user_id and store it. Any idea how can do that?

Can't be done. The current user is only available via the request, which is not available when using purely model functionality. Access the user in the view somehow.

I was able to do it by inspecting the stack and looking for the view then looking at the local variables for the view to get the request. It feels like a bit of a hack, but it worked.
import inspect, os
#receiver(post_save, sender=MyModel)
def get_user_in_signal(sender, **kwargs):
for entry in reversed(inspect.stack()):
if os.path.dirname(__file__) + '/views.py' == entry[1]:
try:
user = entry[0].f_locals['request'].user
except:
user = None
break
if user:
# do stuff with the user variable

Ignacio is right. Django's model signals are intended to notify other system components about events associated with instances and their respected data, so I guess it's valid that you cannot, say, access request data from a model post_save signal, unless that request data was stored on or associated with the instance.
I guess there are lots of ways to handle it, ranging from worse to better, but I'd say this is a prime example for creating class-based/function-based generic views that will automatically handle this for you.
Have your views that inherit from CreateView, UpdateView or DeleteView additionally inherit from your AuditMixin class if they handle verbs that operate on models that need to be audited. The AuditMixin can then hook into the views that successfully create\update\delete objects and create an entry in the database.
Makes perfect sense, very clean, easily pluggable and gives birth to happy ponies. Flipside? You'll either have to be on the soon-to-be-released Django 1.3 release or you'll have to spend some time fiddlebending the function-based generic views and providing new ones for each auditing operation.

You can do that with the help of middleware. Create get_request.py in your app. Then
from threading import current_thread
from django.utils.deprecation import MiddlewareMixin
_requests = {}
def current_request():
return _requests.get(current_thread().ident, None)
class RequestMiddleware(MiddlewareMixin):
def process_request(self, request):
_requests[current_thread().ident] = request
def process_response(self, request, response):
# when response is ready, request should be flushed
_requests.pop(current_thread().ident, None)
return response
def process_exception(self, request, exception):
# if an exception has happened, request should be flushed too
_requests.pop(current_thread().ident, None)
Then add this middleware to your settings:
MIDDLEWARE = [
....
'<your_app>.get_request.RequestMiddleware',
]
Then add import to your signals:
from django.db.models.signals import post_save
from django.contrib.auth.models import User
from <your_app>.get_request import current_request
# CORE - SIGNALS
# Core Signals will operate based on post
def after_save_handler_attr_audit_obj(sender, **kwargs):
print(Current User, current_request().user)
print User.get_profile()
if hasattr(kwargs['instance'], 'audit_obj'):
if kwargs['created']:
kwargs['instance'].audit_obj.create(operation="INSERT", operation_by=**USER.ID**).save()
else:
kwargs['instance'].audit_obj.create(operation="UPDATE").save()
# Connect the handler with the post save signal - Django 1.2
post_save.connect(after_save_handler_attr_audit_obj, dispatch_uid="core.models.audit.new")

Why not adding a middleware with something like this :
class RequestMiddleware(object):
thread_local = threading.local()
def process_request(self, request):
RequestMiddleware.thread_local.current_user = request.user
and later in your code (specially in a signal in that topic) :
thread_local = RequestMiddleware.thread_local
if hasattr(thread_local, 'current_user'):
user = thread_local.current_user
else:
user = None

For traceability add two attributes to your Model(created_by and updated_by), in "updated_by" save the last user who modified the record. Then in your signal you have the user:
models.py:
class Question(models.Model):
question_text = models.CharField(max_length=200)
pub_date = models.DateTimeField('date published')
created_by = models. (max_length=100)
updated_by = models. (max_length=100)
views.py
p = Question.objects.get(pk=1)
p.question_text = 'some new text'
p.updated_by = request.user
p.save()
signals.py
#receiver(pre_save, sender=Question)
def do_something(sender, instance, **kwargs):
try:
obj = Question.objects.get(pk=instance.pk)
except sender.DoesNotExist:
pass
else:
if not obj.user == instance.user: # Field has changed
# do something
print('change: user, old=%s new=%s' % (obj.user, instance.user))

You could also use django-reversion for this purpose, e.g.
from reversion.signals import post_revision_commit
import reversion
#receiver(post_save)
def post_revision_commit(sender, **kwargs):
if reversion.is_active():
print(reversion.get_user())
Read more on their API https://django-reversion.readthedocs.io/en/stable/api.html#revision-api

You can do a small hack by overriding you model save() method and setting the user on the saved instance as additional parameter. To get the user I used get_current_authenticated_user() from django_currentuser.middleware.ThreadLocalUserMiddleware (see https://pypi.org/project/django-currentuser/).
In your models.py:
from django_currentuser.middleware import get_current_authenticated_user
class YourModel(models.Model):
...
...
def save(self, *args, **kwargs):
# Hack to pass the user to post save signal.
self.current_authenticated_user = get_current_authenticated_user()
super(YourModel, self).save(*args, **kwargs)
In your signals.py:
#receiver(post_save, sender=YourModel)
def your_model_saved(sender, instance, **kwargs):
user = getattr(instance, 'current_authenticated_user', None)
PS: Don't forget to add 'django_currentuser.middleware.ThreadLocalUserMiddleware' to your MIDDLEWARE_CLASSES.

I imagine you would have figured this out, but I had the same problem and I realised that all the instances I create had a reference to the user that creates them (which is what you are looking for)

it's possible i guess.
in models.py
class _M(models.Model):
user = models.ForeignKey(...)
in views.py
def _f(request):
_M.objects.create(user=request.user)
in signals.py
#receiver(post_save, sender=_M)
def _p(sender, instance, created, **kwargs):
user = instance.user
No ?

Request object can be obtained from frame record by inspecting.
import inspect
request = [
frame_record[0].f_locals["request"]
for frame_record in inspect.stack()
if frame_record[3] == "get_response"
][0]

def get_requested_user():
import inspect
for frame_record in inspect.stack():
if frame_record[3] == 'get_response':
request = frame_record[0].f_locals['request']
return request.user
else:
return None

context_processors.py
from django.core.cache import cache
def global_variables(request):
cache.set('user', request.user)
----------------------------------
in you model
from django.db.models.signals import pre_delete
from django.dispatch import receiver
from django.core.cache import cache
from news.models import News
#receiver(pre_delete, sender=News)
def news_delete(sender, instance, **kwargs):
user = cache.get('user')
in settings.py
TEMPLATE_CONTEXT_PROCESSORS = (
'web.context_processors.global_variables',
)