cleaned up the MRO

any reference to ContextMixin has been deleted in favor of AsyncContextMixin
this was done due to inheritance problems throughout the package
a number of methods have been added to some of the classes to make this possible

Author: amirreza8002

django_async_extensions/aviews/generic/base.py

@@ -9,14 +9,28 @@
 from django.utils.functional import classproperty
 from django.views.generic.base import (
     View,
-    ContextMixin,
     TemplateResponseMixin,
     RedirectView,
 )
 
 logger = logging.getLogger("django.request")
 
 
+class AsyncContextMixin:
+    """
+    A default context mixin that passes the keyword arguments received by
+    get_context_data() as the template context.
+    """
+
+    extra_context = None
+
+    async def get_context_data(self, **kwargs):
+        kwargs.setdefault("view", self)
+        if self.extra_context is not None:
+            kwargs.update(self.extra_context)
+        return kwargs
+
+
 class AsyncView(View):
     @classproperty
     def view_is_async(cls):
@@ -110,13 +124,13 @@ async def options(self, request, *args, **kwargs):
         return response
 
 
-class AsyncTemplateView(TemplateResponseMixin, ContextMixin, AsyncView):
+class AsyncTemplateView(TemplateResponseMixin, AsyncContextMixin, AsyncView):
     """
     Render a template. Pass keyword arguments from the URLconf to the context.
     """
 
     async def get(self, request, *args, **kwargs):
-        context = self.get_context_data(**kwargs)
+        context = await self.get_context_data(**kwargs)
         return self.render_to_response(context)
 
 

django_async_extensions/aviews/generic/dates.py

@@ -6,8 +6,6 @@
 from django.utils import timezone
 from django.utils.translation import gettext as _
 from django.views.generic.dates import (
-    BaseDateListView,
-    BaseYearArchiveView,
     timezone_today,
     _date_from_string,
     YearMixin,
@@ -75,16 +73,31 @@ async def uses_datetime_field(self):
         return self._cached_uses_datetime
 
 
-class AsyncBaseDateListView(
-    AsyncMultipleObjectMixin, AsyncDateMixin, AsyncView, BaseDateListView
-):
+class AsyncBaseDateListView(AsyncMultipleObjectMixin, AsyncDateMixin, AsyncView):
+    """Abstract base class for date-based views displaying a list of objects."""
+
+    allow_empty = False
+    date_list_period = "year"
+
     async def get(self, request, *args, **kwargs):
         self.date_list, self.object_list, extra_context = await self.get_dated_items()
         context = await self.get_context_data(
             object_list=self.object_list, date_list=self.date_list, **extra_context
         )
         return self.render_to_response(context)
 
+    async def get_dated_items(self):
+        raise NotImplementedError(
+            "An AsyncDateView must provide an implementation of get_dated_items()"
+        )
+
+    def get_ordering(self):
+        """
+        Return the field or fields to use for ordering the queryset; use the
+        date field by default.
+        """
+        return "-%s" % self.get_date_field() if self.ordering is None else self.ordering
+
     async def get_dated_queryset(self, **lookup):
         """
         Get a queryset properly filtered according to `allow_future` and any
@@ -121,10 +134,12 @@ async def get_dated_queryset(self, **lookup):
 
         return qs
 
-    async def get_dated_items(self):
-        raise NotImplementedError(
-            "An AsyncDateView must provide an implementation of get_dated_items()"
-        )
+    def get_date_list_period(self):
+        """
+        Get the aggregation period for the list of dates: 'year', 'month', or
+        'day'.
+        """
+        return self.date_list_period
 
     async def get_date_list(self, queryset, date_type=None, ordering="ASC"):
         """
@@ -181,9 +196,12 @@ class AsyncArchiveIndexView(
     template_name_suffix = "_archive"
 
 
-class AsyncBaseYearArchiveView(
-    AsyncYearMixin, AsyncBaseDateListView, BaseYearArchiveView
-):
+class AsyncBaseYearArchiveView(AsyncYearMixin, AsyncBaseDateListView):
+    """List of objects published in a given year."""
+
+    date_list_period = "month"
+    make_object_list = False
+
     async def get_dated_items(self):
         """Return (date_list, items, extra_context) for this request."""
         year = self.get_year()
@@ -216,6 +234,13 @@ async def get_dated_items(self):
             },
         )
 
+    def get_make_object_list(self):
+        """
+        Return `True` if this view should contain the full list of objects in
+        the given year.
+        """
+        return self.make_object_list
+
 
 class AsyncYearArchiveView(
     MultipleObjectTemplateResponseMixin, AsyncBaseYearArchiveView

django_async_extensions/aviews/generic/detail.py

@@ -1,15 +1,27 @@
 from django.core.exceptions import ImproperlyConfigured
+from django.db import models
 from django.http import Http404
 from django.views.generic.detail import (
-    SingleObjectMixin,
     SingleObjectTemplateResponseMixin,
 )
 from django.utils.translation import gettext as _
 
-from django_async_extensions.aviews.generic.base import AsyncView
+from django_async_extensions.aviews.generic.base import AsyncView, AsyncContextMixin
 
 
-class AsyncSingleObjectMixin(SingleObjectMixin):
+class AsyncSingleObjectMixin(AsyncContextMixin):
+    """
+    Provide the ability to retrieve a single object for further manipulation.
+    """
+
+    model = None
+    queryset = None
+    slug_field = "slug"
+    context_object_name = None
+    slug_url_kwarg = "slug"
+    pk_url_kwarg = "pk"
+    query_pk_and_slug = False
+
     async def get_object(self, queryset=None):
         """
         Return the object the view is displaying.
@@ -70,6 +82,30 @@ async def get_queryset(self):
                 )
         return self.queryset.all()
 
+    def get_slug_field(self):
+        """Get the name of a slug field to be used to look up by slug."""
+        return self.slug_field
+
+    def get_context_object_name(self, obj):
+        """Get the name to use for the object."""
+        if self.context_object_name:
+            return self.context_object_name
+        elif isinstance(obj, models.Model):
+            return obj._meta.model_name
+        else:
+            return None
+
+    async def get_context_data(self, **kwargs):
+        """Insert the single object into the context dict."""
+        context = {}
+        if self.object:
+            context["object"] = self.object
+            context_object_name = self.get_context_object_name(self.object)
+            if context_object_name:
+                context[context_object_name] = self.object
+        context.update(kwargs)
+        return await super().get_context_data(**context)
+
 
 class AsyncBaseDetailView(AsyncSingleObjectMixin, AsyncView):
     """
@@ -80,7 +116,7 @@ class AsyncBaseDetailView(AsyncSingleObjectMixin, AsyncView):
 
     async def get(self, request, *args, **kwargs):
         self.object = await self.get_object()
-        context = self.get_context_data(object=self.object)
+        context = await self.get_context_data(object=self.object)
         return self.render_to_response(context)
 
 

django_async_extensions/aviews/generic/edit.py

@@ -1,16 +1,30 @@
 from django.core.exceptions import ImproperlyConfigured
 from django.forms import models as model_forms
 from django.http import HttpResponseRedirect
-from django.views.generic.base import ContextMixin, TemplateResponseMixin
-from django.views.generic.edit import FormMixin
+from django.views.generic.base import TemplateResponseMixin
 
-from django_async_extensions.aviews.generic.base import AsyncView
+from django_async_extensions.aviews.generic.base import AsyncView, AsyncContextMixin
 from django_async_extensions.aviews.generic.detail import (
     AsyncSingleObjectMixin,
 )
 
 
-class AsyncFormMixin(FormMixin):
+class AsyncFormMixin(AsyncContextMixin):
+    """Provide a way to show and handle a form in a request."""
+
+    initial = {}
+    form_class = None
+    success_url = None
+    prefix = None
+
+    def get_initial(self):
+        """Return the initial data to use for forms on this view."""
+        return self.initial.copy()
+
+    def get_prefix(self):
+        """Return the prefix to use for forms."""
+        return self.prefix
+
     async def get_form_class(self):
         """Return the form class to use."""
         # this is async so subclasses can be of the same nature
@@ -22,6 +36,28 @@ async def get_form(self, form_class=None):
             form_class = await self.get_form_class()
         return form_class(**self.get_form_kwargs())
 
+    def get_form_kwargs(self):
+        """Return the keyword arguments for instantiating the form."""
+        kwargs = {
+            "initial": self.get_initial(),
+            "prefix": self.get_prefix(),
+        }
+
+        if self.request.method in ("POST", "PUT"):
+            kwargs.update(
+                {
+                    "data": self.request.POST,
+                    "files": self.request.FILES,
+                }
+            )
+        return kwargs
+
+    def get_success_url(self):
+        """Return the URL to redirect to after processing a valid form."""
+        if not self.success_url:
+            raise ImproperlyConfigured("No URL to redirect to. Provide a success_url.")
+        return str(self.success_url)  # success_url may be lazy
+
     async def form_valid(self, form):
         """If the form is valid, redirect to the supplied URL."""
         return HttpResponseRedirect(self.get_success_url())
@@ -34,7 +70,7 @@ async def get_context_data(self, **kwargs):
         """Insert the form into the context dict."""
         if "form" not in kwargs:
             kwargs["form"] = await self.get_form()
-        return ContextMixin().get_context_data(**kwargs)
+        return await super().get_context_data(**kwargs)
 
 
 class AsyncModelFormMixin(AsyncFormMixin, AsyncSingleObjectMixin):
@@ -72,10 +108,31 @@ async def get_form_class(self):
 
             return model_forms.modelform_factory(model, fields=self.fields)
 
+    def get_form_kwargs(self):
+        """Return the keyword arguments for instantiating the form."""
+        kwargs = super().get_form_kwargs()
+        if hasattr(self, "object"):
+            kwargs.update({"instance": self.object})
+        return kwargs
+
+    def get_success_url(self):
+        """Return the URL to redirect to after processing a valid form."""
+        if self.success_url:
+            url = self.success_url.format(**self.object.__dict__)
+        else:
+            try:
+                url = self.object.get_absolute_url()
+            except AttributeError:
+                raise ImproperlyConfigured(
+                    "No URL to redirect to.  Either provide a url or define"
+                    " a get_absolute_url method on the Model."
+                )
+        return url
+
     async def form_valid(self, form):
         """If the form is valid, save the associated model."""
         self.object = await form.asave()
-        return super().form_valid(form)
+        return await super().form_valid(form)
 
 
 class AsyncProcessFormView(AsyncView):