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 super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data(object=self.object)
return self.render_to_response(context)
}}}
**Hi,,,
In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line like
`context = self.get_context_data(object=self.object)`. Why should we pass
`object=self.object` ? It's redundant (IMHO). I think, it's better idea to
implement `SingleObjectMixin.get_context_data` and `BaseDetailView.get`
like this. Code below
**
{{{#!python
class SingleObjectMixin(ContextMixin):
def get_context_data(self, *, object=None, **kwargs):
"""Insert the single object into the context dict."""
object = object if object is not None else self.object
context = {}
if object:
context['object'] = object
context_object_name = self.get_context_object_name(object)
if context_object_name:
context[context_object_name] = object
context.update(kwargs)
return super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data()
return self.render_to_response(context)
}}}
Also, `SingleObjectMixin` will be implemented in a same fashion as
`MultipleObjectMixin` is this moment.
--
Ticket URL: <https://code.djangoproject.com/ticket/30698>
Django <https://code.djangoproject.com/>
The Web framework for perfectionists with deadlines.
* has_patch: 0 => 1
Old description:
New description:
{{{#!python
class SingleObjectMixin(ContextMixin):
**Hi,,,
[https://github.com/gachdavit/django/pull/1]
--
--
Ticket URL: <https://code.djangoproject.com/ticket/30698#comment:1>
Old description:
> [https://github.com/gachdavit/django/pull/1]
New description:
Hi. In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line
like `context = self.get_context_data(object=self.object)`. Why should we
pass `object=self.object` ? It's redundant (IMHO).
{{{#!python
class SingleObjectMixin(ContextMixin):
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 super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data(object=self.object)
return self.render_to_response(context)
}}}
I think, it's better idea to implement
`SingleObjectMixin.get_context_data` and `BaseDetailView.get` like this.
Code below
{{{#!python
class SingleObjectMixin(ContextMixin):
def get_context_data(self, *, object=None, **kwargs):
"""Insert the single object into the context dict."""
object = object if object is not None else self.object
context = {}
if object:
context['object'] = object
context_object_name = self.get_context_object_name(object)
if context_object_name:
context[context_object_name] = object
context.update(kwargs)
return super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data()
return self.render_to_response(context)
}}}
Also, `SingleObjectMixin` will be implemented in a same fashion as
`MultipleObjectMixin` is this moment.
[https://github.com/gachdavit/django/pull/1]
--
--
Ticket URL: <https://code.djangoproject.com/ticket/30698#comment:2>
* owner: nobody => Davit Gachechiladze
* status: new => assigned
--
Ticket URL: <https://code.djangoproject.com/ticket/30698#comment:3>
Old description:
> Hi. In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line
> like `context = self.get_context_data(object=self.object)`. Why should we
> pass `object=self.object` ? It's redundant (IMHO).
>
> {{{#!python
> class SingleObjectMixin(ContextMixin):
>
> 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 super().get_context_data(**context)
> }}}
>
> {{{#!python
> class BaseDetailView(SingleObjectMixin, View):
> """A base view for displaying a single object."""
> def get(self, request, *args, **kwargs):
> self.object = self.get_object()
> context = self.get_context_data(object=self.object)
> return self.render_to_response(context)
> }}}
>
> I think, it's better idea to implement
> `SingleObjectMixin.get_context_data` and `BaseDetailView.get` like this.
> Code below
>
> {{{#!python
> class SingleObjectMixin(ContextMixin):
> def get_context_data(self, *, object=None, **kwargs):
> """Insert the single object into the context dict."""
> object = object if object is not None else self.object
> context = {}
> if object:
> context['object'] = object
> context_object_name = self.get_context_object_name(object)
> if context_object_name:
> context[context_object_name] = object
> context.update(kwargs)
> return super().get_context_data(**context)
> }}}
>
> {{{#!python
> class BaseDetailView(SingleObjectMixin, View):
> """A base view for displaying a single object."""
> def get(self, request, *args, **kwargs):
> self.object = self.get_object()
> context = self.get_context_data()
> return self.render_to_response(context)
> }}}
>
> Also, `SingleObjectMixin` will be implemented in a same fashion as
> `MultipleObjectMixin` is this moment.
>
> [https://github.com/gachdavit/django/pull/1]
New description:
Hi. In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line
like `context = self.get_context_data(object=self.object)`. Why should we
pass `object=self.object` ? It's redundant (IMHO).
{{{#!python
class SingleObjectMixin(ContextMixin):
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 super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data(object=self.object)
return self.render_to_response(context)
}}}
I think, it's better idea to implement
`SingleObjectMixin.get_context_data` and `BaseDetailView.get` like this.
Code below
{{{#!python
class SingleObjectMixin(ContextMixin):
def get_context_data(self, *, object=None, **kwargs):
"""Insert the single object into the context dict."""
object = object if object is not None else self.object
context = {}
if object:
context['object'] = object
context_object_name = self.get_context_object_name(object)
if context_object_name:
context[context_object_name] = object
context.update(kwargs)
return super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data()
return self.render_to_response(context)
}}}
Also, `SingleObjectMixin` will be implemented in a same fashion as
`MultipleObjectMixin` is this moment.
--
--
Ticket URL: <https://code.djangoproject.com/ticket/30698#comment:4>
Old description:
> Hi. In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line
> like `context = self.get_context_data(object=self.object)`. Why should we
> pass `object=self.object` ? It's redundant (IMHO).
>
> {{{#!python
> class SingleObjectMixin(ContextMixin):
>
> 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 super().get_context_data(**context)
> }}}
>
> {{{#!python
> class BaseDetailView(SingleObjectMixin, View):
> """A base view for displaying a single object."""
> def get(self, request, *args, **kwargs):
> self.object = self.get_object()
> context = self.get_context_data(object=self.object)
> return self.render_to_response(context)
> }}}
>
> I think, it's better idea to implement
> `SingleObjectMixin.get_context_data` and `BaseDetailView.get` like this.
> Code below
>
> {{{#!python
> class SingleObjectMixin(ContextMixin):
> def get_context_data(self, *, object=None, **kwargs):
> """Insert the single object into the context dict."""
> object = object if object is not None else self.object
> context = {}
> if object:
> context['object'] = object
> context_object_name = self.get_context_object_name(object)
> if context_object_name:
> context[context_object_name] = object
> context.update(kwargs)
> return super().get_context_data(**context)
> }}}
>
> {{{#!python
> class BaseDetailView(SingleObjectMixin, View):
> """A base view for displaying a single object."""
> def get(self, request, *args, **kwargs):
> self.object = self.get_object()
> context = self.get_context_data()
> return self.render_to_response(context)
> }}}
>
> Also, `SingleObjectMixin` will be implemented in a same fashion as
> `MultipleObjectMixin` is this moment.
New description:
Hi. In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line
like `context = self.get_context_data(object=self.object)`. Why should we
pass `object=self.object` ? It's redundant (IMHO).
{{{#!python
class SingleObjectMixin(ContextMixin):
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 super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data(object=self.object)
return self.render_to_response(context)
}}}
I think, it's better idea to implement
`SingleObjectMixin.get_context_data` and `BaseDetailView.get` like this.
Code below
{{{#!python
class SingleObjectMixin(ContextMixin):
def get_context_data(self, *, object=None, **kwargs):
"""Insert the single object into the context dict."""
object = object if object is not None else self.object
context = {}
if object:
context['object'] = object
context_object_name = self.get_context_object_name(object)
if context_object_name:
context[context_object_name] = object
context.update(kwargs)
return super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data()
return self.render_to_response(context)
}}}
Also, `SingleObjectMixin` will be implemented in a same fashion as
`MultipleObjectMixin` is this moment.
[https://github.com/django/django/pull/11653]
--
--
Ticket URL: <https://code.djangoproject.com/ticket/30698#comment:5>
Old description:
> Hi. In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line
> like `context = self.get_context_data(object=self.object)`. Why should we
> pass `object=self.object` ? It's redundant (IMHO).
>
> {{{#!python
> class SingleObjectMixin(ContextMixin):
>
> 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 super().get_context_data(**context)
> }}}
>
> {{{#!python
> class BaseDetailView(SingleObjectMixin, View):
> """A base view for displaying a single object."""
> def get(self, request, *args, **kwargs):
> self.object = self.get_object()
> context = self.get_context_data(object=self.object)
> return self.render_to_response(context)
> }}}
>
> I think, it's better idea to implement
> `SingleObjectMixin.get_context_data` and `BaseDetailView.get` like this.
> Code below
>
> {{{#!python
> class SingleObjectMixin(ContextMixin):
> def get_context_data(self, *, object=None, **kwargs):
> """Insert the single object into the context dict."""
> object = object if object is not None else self.object
> context = {}
> if object:
> context['object'] = object
> context_object_name = self.get_context_object_name(object)
> if context_object_name:
> context[context_object_name] = object
> context.update(kwargs)
> return super().get_context_data(**context)
> }}}
>
> {{{#!python
> class BaseDetailView(SingleObjectMixin, View):
> """A base view for displaying a single object."""
> def get(self, request, *args, **kwargs):
> self.object = self.get_object()
> context = self.get_context_data()
> return self.render_to_response(context)
> }}}
>
> Also, `SingleObjectMixin` will be implemented in a same fashion as
> `MultipleObjectMixin` is this moment.
>
> [https://github.com/django/django/pull/11653]
New description:
Hi. In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line
like `context = self.get_context_data(object=self.object)`. Why should we
pass `object=self.object` ? It's redundant (IMHO).
{{{#!python
class SingleObjectMixin(ContextMixin):
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 super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data(object=self.object)
return self.render_to_response(context)
}}}
I think, it's better idea to implement
`SingleObjectMixin.get_context_data` and `BaseDetailView.get` like this.
Code below
{{{#!python
class SingleObjectMixin(ContextMixin):
def get_context_data(self, *, object=None, **kwargs):
"""Insert the single object into the context dict."""
object = object if object is not None else self.object
context = {}
if object:
context['object'] = object
context_object_name = self.get_context_object_name(object)
if context_object_name:
context[context_object_name] = object
context.update(kwargs)
return super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data()
return self.render_to_response(context)
}}}
Also, `SingleObjectMixin` will be implemented in a same fashion as
`MultipleObjectMixin` is this moment.
--
--
Ticket URL: <https://code.djangoproject.com/ticket/30698#comment:6>
Old description:
> Hi. In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line
> like `context = self.get_context_data(object=self.object)`. Why should we
> pass `object=self.object` ? It's redundant (IMHO).
>
> {{{#!python
> class SingleObjectMixin(ContextMixin):
>
> 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 super().get_context_data(**context)
> }}}
>
> {{{#!python
> class BaseDetailView(SingleObjectMixin, View):
> """A base view for displaying a single object."""
> def get(self, request, *args, **kwargs):
> self.object = self.get_object()
> context = self.get_context_data(object=self.object)
> return self.render_to_response(context)
> }}}
>
> I think, it's better idea to implement
> `SingleObjectMixin.get_context_data` and `BaseDetailView.get` like this.
> Code below
>
> {{{#!python
> class SingleObjectMixin(ContextMixin):
> def get_context_data(self, *, object=None, **kwargs):
> """Insert the single object into the context dict."""
> object = object if object is not None else self.object
> context = {}
> if object:
> context['object'] = object
> context_object_name = self.get_context_object_name(object)
> if context_object_name:
> context[context_object_name] = object
> context.update(kwargs)
> return super().get_context_data(**context)
> }}}
>
> {{{#!python
> class BaseDetailView(SingleObjectMixin, View):
> """A base view for displaying a single object."""
> def get(self, request, *args, **kwargs):
> self.object = self.get_object()
> context = self.get_context_data()
> return self.render_to_response(context)
> }}}
>
> Also, `SingleObjectMixin` will be implemented in a same fashion as
> `MultipleObjectMixin` is this moment.
New description:
Hi. In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line
like `context = self.get_context_data(object=self.object)`. Why should we
pass `object=self.object` ? It's redundant (IMHO).
{{{#!python
class SingleObjectMixin(ContextMixin):
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 super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data(object=self.object)
return self.render_to_response(context)
}}}
I think, it's better idea to implement
`SingleObjectMixin.get_context_data` and `BaseDetailView.get` like this.
Code below
{{{#!python
class SingleObjectMixin(ContextMixin):
def get_context_data(self, *, object=None, **kwargs):
"""Insert the single object into the context dict."""
object = object if object is not None else self.object
context = {}
if object:
context['object'] = object
context_object_name = self.get_context_object_name(object)
if context_object_name:
context[context_object_name] = object
context.update(kwargs)
return super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data()
return self.render_to_response(context)
}}}
Also, `SingleObjectMixin` will be implemented in a same fashion as
`MultipleObjectMixin` is this moment.
[https://github.com/django/django/pull/11654]
--
--
Ticket URL: <https://code.djangoproject.com/ticket/30698#comment:7>
* version: 2.2 => master
--
Ticket URL: <https://code.djangoproject.com/ticket/30698#comment:8>
Old description:
> Hi. In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line
> like `context = self.get_context_data(object=self.object)`. Why should we
> pass `object=self.object` ? It's redundant (IMHO).
>
> {{{#!python
> class SingleObjectMixin(ContextMixin):
>
> 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 super().get_context_data(**context)
> }}}
>
> {{{#!python
> class BaseDetailView(SingleObjectMixin, View):
> """A base view for displaying a single object."""
> def get(self, request, *args, **kwargs):
> self.object = self.get_object()
> context = self.get_context_data(object=self.object)
> return self.render_to_response(context)
> }}}
>
> I think, it's better idea to implement
> `SingleObjectMixin.get_context_data` and `BaseDetailView.get` like this.
> Code below
>
> {{{#!python
> class SingleObjectMixin(ContextMixin):
> def get_context_data(self, *, object=None, **kwargs):
> """Insert the single object into the context dict."""
> object = object if object is not None else self.object
> context = {}
> if object:
> context['object'] = object
> context_object_name = self.get_context_object_name(object)
> if context_object_name:
> context[context_object_name] = object
> context.update(kwargs)
> return super().get_context_data(**context)
> }}}
>
> {{{#!python
> class BaseDetailView(SingleObjectMixin, View):
> """A base view for displaying a single object."""
> def get(self, request, *args, **kwargs):
> self.object = self.get_object()
> context = self.get_context_data()
> return self.render_to_response(context)
> }}}
>
> Also, `SingleObjectMixin` will be implemented in a same fashion as
> `MultipleObjectMixin` is this moment.
>
> [https://github.com/django/django/pull/11654]
New description:
Hi. In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line
like `context = self.get_context_data(object=self.object)`. Why should we
pass `object=self.object` ? It's redundant (IMHO).
{{{#!python
class SingleObjectMixin(ContextMixin):
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 super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data(object=self.object)
return self.render_to_response(context)
}}}
I think, it's better idea to implement
`SingleObjectMixin.get_context_data(self, *, object=None, **kwargs)` and
`BaseDetailView.get(self, request, *args, **kwargs)` like this. Code below
{{{#!python
class SingleObjectMixin(ContextMixin):
def get_context_data(self, *, object=None, **kwargs):
"""Insert the single object into the context dict."""
object = object if object is not None else self.object
context = {}
if object:
context['object'] = object
context_object_name = self.get_context_object_name(object)
if context_object_name:
context[context_object_name] = object
context.update(kwargs)
return super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data()
return self.render_to_response(context)
}}}
Also, `SingleObjectMixin` will be implemented in a same fashion as
`MultipleObjectMixin` is this moment.
[https://github.com/django/django/pull/11654]
--
--
Ticket URL: <https://code.djangoproject.com/ticket/30698#comment:9>
Old description:
> Hi. In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line
> like `context = self.get_context_data(object=self.object)`. Why should we
> pass `object=self.object` ? It's redundant (IMHO).
>
> {{{#!python
> class SingleObjectMixin(ContextMixin):
>
> 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 super().get_context_data(**context)
> }}}
>
> {{{#!python
> class BaseDetailView(SingleObjectMixin, View):
> """A base view for displaying a single object."""
> def get(self, request, *args, **kwargs):
> self.object = self.get_object()
> context = self.get_context_data(object=self.object)
> return self.render_to_response(context)
> }}}
>
> I think, it's better idea to implement
> `SingleObjectMixin.get_context_data(self, *, object=None, **kwargs)` and
> `BaseDetailView.get(self, request, *args, **kwargs)` like this. Code
> below
>
> {{{#!python
> class SingleObjectMixin(ContextMixin):
> def get_context_data(self, *, object=None, **kwargs):
> """Insert the single object into the context dict."""
> object = object if object is not None else self.object
> context = {}
> if object:
> context['object'] = object
> context_object_name = self.get_context_object_name(object)
> if context_object_name:
> context[context_object_name] = object
> context.update(kwargs)
> return super().get_context_data(**context)
> }}}
>
> {{{#!python
> class BaseDetailView(SingleObjectMixin, View):
> """A base view for displaying a single object."""
> def get(self, request, *args, **kwargs):
> self.object = self.get_object()
> context = self.get_context_data()
> return self.render_to_response(context)
> }}}
>
> Also, `SingleObjectMixin` will be implemented in a same fashion as
> `MultipleObjectMixin` is this moment.
>
> [https://github.com/django/django/pull/11654]
New description:
Hi. In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line
like `context = self.get_context_data(object=self.object)`. Why should we
pass `object=self.object` ? It's redundant (IMHO).
{{{#!python
class SingleObjectMixin(ContextMixin):
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 super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data(object=self.object)
return self.render_to_response(context)
}}}
I think, it's better idea to implement
`SingleObjectMixin.get_context_data(self, **kwargs)` and
`BaseDetailView.get(self, request, *args, **kwargs)` like this. Code below
{{{#!python
class SingleObjectMixin(ContextMixin):
def get_context_data(self, *, object=None, **kwargs):
"""Insert the single object into the context dict."""
object = object if object is not None else self.object
context = {}
if object:
context['object'] = object
context_object_name = self.get_context_object_name(object)
if context_object_name:
context[context_object_name] = object
context.update(kwargs)
return super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data()
return self.render_to_response(context)
}}}
Also, `SingleObjectMixin` will be implemented in a same fashion as
`MultipleObjectMixin` is this moment.
[https://github.com/django/django/pull/11654]
--
--
Ticket URL: <https://code.djangoproject.com/ticket/30698#comment:10>
Old description:
> Hi. In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line
> like `context = self.get_context_data(object=self.object)`. Why should we
> pass `object=self.object` ? It's redundant (IMHO).
>
> {{{#!python
> class SingleObjectMixin(ContextMixin):
>
> 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 super().get_context_data(**context)
> }}}
>
> {{{#!python
> class BaseDetailView(SingleObjectMixin, View):
> """A base view for displaying a single object."""
> def get(self, request, *args, **kwargs):
> self.object = self.get_object()
> context = self.get_context_data(object=self.object)
> return self.render_to_response(context)
> }}}
>
> I think, it's better idea to implement
> `SingleObjectMixin.get_context_data(self, **kwargs)` and
> `BaseDetailView.get(self, request, *args, **kwargs)` like this. Code
> below
>
> {{{#!python
> class SingleObjectMixin(ContextMixin):
> def get_context_data(self, *, object=None, **kwargs):
> """Insert the single object into the context dict."""
> object = object if object is not None else self.object
> context = {}
> if object:
> context['object'] = object
> context_object_name = self.get_context_object_name(object)
> if context_object_name:
> context[context_object_name] = object
> context.update(kwargs)
> return super().get_context_data(**context)
> }}}
>
> {{{#!python
> class BaseDetailView(SingleObjectMixin, View):
> """A base view for displaying a single object."""
> def get(self, request, *args, **kwargs):
> self.object = self.get_object()
> context = self.get_context_data()
> return self.render_to_response(context)
> }}}
>
> Also, `SingleObjectMixin` will be implemented in a same fashion as
> `MultipleObjectMixin` is this moment.
>
> [https://github.com/django/django/pull/11654]
New description:
Hi. In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line
like `context = self.get_context_data(object=self.object)`. Why should we
pass `object=self.object` ? It's redundant (IMHO).
{{{#!python
class SingleObjectMixin(ContextMixin):
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 super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data(object=self.object)
return self.render_to_response(context)
}}}
I think, it's better idea to implement
`SingleObjectMixin.get_context_data(self, **kwargs)` and
`BaseDetailView.get(self, request, *args, **kwargs)` like this. Code below
{{{#!python
class SingleObjectMixin(ContextMixin):
def get_context_data(self, *, object=None, **kwargs):
"""Insert the single object into the context dict."""
object = object if object is not None else self.object
context = {}
if object:
context['object'] = object
context_object_name = self.get_context_object_name(object)
if context_object_name:
context[context_object_name] = object
context.update(kwargs)
return super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data()
return self.render_to_response(context)
}}}
Also, `SingleObjectMixin.get_context_data(self, *, object=None, **kwargs)`
will be implemented in a same fashion as
`MultipleObjectMixin.get_context_data(self, *, object_list=None,
**kwargs)` is this moment.
[https://github.com/django/django/pull/11654]
--
--
Ticket URL: <https://code.djangoproject.com/ticket/30698#comment:11>
Old description:
> Hi. In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line
> like `context = self.get_context_data(object=self.object)`. Why should we
> pass `object=self.object` ? It's redundant (IMHO).
>
> {{{#!python
> class SingleObjectMixin(ContextMixin):
>
> 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 super().get_context_data(**context)
> }}}
>
> {{{#!python
> class BaseDetailView(SingleObjectMixin, View):
> """A base view for displaying a single object."""
> def get(self, request, *args, **kwargs):
> self.object = self.get_object()
> context = self.get_context_data(object=self.object)
> return self.render_to_response(context)
> }}}
>
> I think, it's better idea to implement
> `SingleObjectMixin.get_context_data(self, **kwargs)` and
> `BaseDetailView.get(self, request, *args, **kwargs)` like this. Code
> below
>
> {{{#!python
> class SingleObjectMixin(ContextMixin):
> def get_context_data(self, *, object=None, **kwargs):
> """Insert the single object into the context dict."""
> object = object if object is not None else self.object
> context = {}
> if object:
> context['object'] = object
> context_object_name = self.get_context_object_name(object)
> if context_object_name:
> context[context_object_name] = object
> context.update(kwargs)
> return super().get_context_data(**context)
> }}}
>
> {{{#!python
> class BaseDetailView(SingleObjectMixin, View):
> """A base view for displaying a single object."""
> def get(self, request, *args, **kwargs):
> self.object = self.get_object()
> context = self.get_context_data()
> return self.render_to_response(context)
> }}}
>
> Also, `SingleObjectMixin.get_context_data(self, *, object=None,
> **kwargs)` will be implemented in a same fashion as
> `MultipleObjectMixin.get_context_data(self, *, object_list=None,
> **kwargs)` is this moment.
>
> [https://github.com/django/django/pull/11654]
New description:
Hi. In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line
like `context = self.get_context_data(object=self.object)`. Why should we
pass `object=self.object` ? It's redundant (IMHO).
{{{#!python
class SingleObjectMixin(ContextMixin):
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 super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data(object=self.object)
return self.render_to_response(context)
}}}
I think, it's better idea to implement
`SingleObjectMixin.get_context_data(self, **kwargs)` and
`BaseDetailView.get(self, request, *args, **kwargs)` like this. Code below
{{{#!python
class SingleObjectMixin(ContextMixin):
def get_context_data(self, *, object=None, **kwargs):
"""Insert the single object into the context dict."""
object = object if object is not None else self.object
context = {}
if object:
context['object'] = object
context_object_name = self.get_context_object_name(object)
if context_object_name:
context[context_object_name] = object
context.update(kwargs)
return super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data()
return self.render_to_response(context)
}}}
Also, `SingleObjectMixin.get_context_data(self, *, object=None, **kwargs)`
will be implemented in a same fashion as
`MultipleObjectMixin.get_context_data(self, *, object_list=None,
**kwargs)` is this moment.
[https://github.com/django/django/pull/11656]
--
--
Ticket URL: <https://code.djangoproject.com/ticket/30698#comment:12>
Old description:
> Hi. In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line
> like `context = self.get_context_data(object=self.object)`. Why should we
> pass `object=self.object` ? It's redundant (IMHO).
>
> {{{#!python
> class SingleObjectMixin(ContextMixin):
>
> 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 super().get_context_data(**context)
> }}}
>
> {{{#!python
> class BaseDetailView(SingleObjectMixin, View):
> """A base view for displaying a single object."""
> def get(self, request, *args, **kwargs):
> self.object = self.get_object()
> context = self.get_context_data(object=self.object)
> return self.render_to_response(context)
> }}}
>
> I think, it's better idea to implement
> `SingleObjectMixin.get_context_data(self, **kwargs)` and
> `BaseDetailView.get(self, request, *args, **kwargs)` like this. Code
> below
>
> {{{#!python
> class SingleObjectMixin(ContextMixin):
> def get_context_data(self, *, object=None, **kwargs):
> """Insert the single object into the context dict."""
> object = object if object is not None else self.object
> context = {}
> if object:
> context['object'] = object
> context_object_name = self.get_context_object_name(object)
> if context_object_name:
> context[context_object_name] = object
> context.update(kwargs)
> return super().get_context_data(**context)
> }}}
>
> {{{#!python
> class BaseDetailView(SingleObjectMixin, View):
> """A base view for displaying a single object."""
> def get(self, request, *args, **kwargs):
> self.object = self.get_object()
> context = self.get_context_data()
> return self.render_to_response(context)
> }}}
>
> Also, `SingleObjectMixin.get_context_data(self, *, object=None,
> **kwargs)` will be implemented in a same fashion as
> `MultipleObjectMixin.get_context_data(self, *, object_list=None,
> **kwargs)` is this moment.
>
> [https://github.com/django/django/pull/11656]
New description:
Hi. In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line
like `context = self.get_context_data(object=self.object)`. Why should we
pass `object=self.object` ? It's redundant (IMHO).
{{{#!python
class SingleObjectMixin(ContextMixin):
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 super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data(object=self.object)
return self.render_to_response(context)
}}}
I think, it's better idea to implement
`SingleObjectMixin.get_context_data(self, **kwargs)` and
`BaseDetailView.get(self, request, *args, **kwargs)` like this. Code below
{{{#!python
class SingleObjectMixin(ContextMixin):
def get_context_data(self, *, object=None, **kwargs):
"""Insert the single object into the context dict."""
object = object if object is not None else self.object
context = {}
if object:
context['object'] = object
context_object_name = self.get_context_object_name(object)
if context_object_name:
context[context_object_name] = object
context.update(kwargs)
return super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data()
return self.render_to_response(context)
}}}
Also, `SingleObjectMixin.get_context_data(self, *, object=None, **kwargs)`
will be implemented in a same fashion as
`MultipleObjectMixin.get_context_data(self, *, object_list=None,
**kwargs)` is this moment.
--
--
Ticket URL: <https://code.djangoproject.com/ticket/30698#comment:13>
Old description:
> Hi. In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line
> like `context = self.get_context_data(object=self.object)`. Why should we
> pass `object=self.object` ? It's redundant (IMHO).
>
> {{{#!python
> class SingleObjectMixin(ContextMixin):
>
> 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 super().get_context_data(**context)
> }}}
>
> {{{#!python
> class BaseDetailView(SingleObjectMixin, View):
> """A base view for displaying a single object."""
> def get(self, request, *args, **kwargs):
> self.object = self.get_object()
> context = self.get_context_data(object=self.object)
> return self.render_to_response(context)
> }}}
>
> I think, it's better idea to implement
> `SingleObjectMixin.get_context_data(self, **kwargs)` and
> `BaseDetailView.get(self, request, *args, **kwargs)` like this. Code
> below
>
> {{{#!python
> class SingleObjectMixin(ContextMixin):
> def get_context_data(self, *, object=None, **kwargs):
> """Insert the single object into the context dict."""
> object = object if object is not None else self.object
> context = {}
> if object:
> context['object'] = object
> context_object_name = self.get_context_object_name(object)
> if context_object_name:
> context[context_object_name] = object
> context.update(kwargs)
> return super().get_context_data(**context)
> }}}
>
> {{{#!python
> class BaseDetailView(SingleObjectMixin, View):
> """A base view for displaying a single object."""
> def get(self, request, *args, **kwargs):
> self.object = self.get_object()
> context = self.get_context_data()
> return self.render_to_response(context)
> }}}
>
> Also, `SingleObjectMixin.get_context_data(self, *, object=None,
> **kwargs)` will be implemented in a same fashion as
> `MultipleObjectMixin.get_context_data(self, *, object_list=None,
> **kwargs)` is this moment.
New description:
Hi. In `BaseDetailView.get(self, request, *args, **kwargs)`, we have line
like `context = self.get_context_data(object=self.object)`. Why should we
pass `object=self.object` ? It's redundant (IMHO).
{{{#!python
class SingleObjectMixin(ContextMixin):
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 super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data(object=self.object)
return self.render_to_response(context)
}}}
I think, it's better idea to implement
`SingleObjectMixin.get_context_data(self, **kwargs)` and
`BaseDetailView.get(self, request, *args, **kwargs)` like this. Code below
{{{#!python
class SingleObjectMixin(ContextMixin):
def get_context_data(self, *, object=None, **kwargs):
"""Insert the single object into the context dict."""
object = object if object is not None else self.object
context = {}
if object:
context['object'] = object
context_object_name = self.get_context_object_name(object)
if context_object_name:
context[context_object_name] = object
context.update(kwargs)
return super().get_context_data(**context)
}}}
{{{#!python
class BaseDetailView(SingleObjectMixin, View):
"""A base view for displaying a single object."""
def get(self, request, *args, **kwargs):
self.object = self.get_object()
context = self.get_context_data()
return self.render_to_response(context)
}}}
Also, `SingleObjectMixin.get_context_data(self, *, object=None, **kwargs)`
will be implemented in a same fashion as
`MultipleObjectMixin.get_context_data(self, *, object_list=None,
**kwargs)` is this moment.
[https://github.com/django/django/pull/11657]
--
--
Ticket URL: <https://code.djangoproject.com/ticket/30698#comment:14>
Comment (by felixxm):
Davit please don't update ticket description so many times, you can refer
PR in a comment.
--
Ticket URL: <https://code.djangoproject.com/ticket/30698#comment:15>
Comment (by Davit Gachechiladze):
Replying to [comment:15 felixxm]:
> Davit please don't update ticket description so many times, you can
refer PR in a comment.
Thank you. I will try to do everything better in future.
--
Ticket URL: <https://code.djangoproject.com/ticket/30698#comment:16>
* status: assigned => closed
* resolution: => wontfix
Comment:
Hi Davit,
Thanks for the suggestion. Strictly you're right, in theory this
simplification is available. We can't make it, however.
Firstly, they'll be plenty of folks that overrode `get_context_data()`
relying on the fact that `self.object` is injected.
(We change it, we break their code.)
Then, removing relies too much on internal knowledge of the CBV
implementations.
The general pattern for `get_context_data()` is this:
{{{
def get_context_data(self, **kwargs):
context = {
# Some stuff...
}
# Allow caller to inject the values we want...
context.update(kwargs)
return context
}}}
Without looking at `SingleObjectMixin` at all, the implementation of
BaseDetailView.get() is exactly what one want's: we want the calling
function to ''drive'' `get_context_data() by passing in the object to be
rendered.
I don't know if you've seen them but check out http://django-vanilla-
views.org/ for a stripped back take on GCBVs here.
--
Ticket URL: <https://code.djangoproject.com/ticket/30698#comment:17>
Comment (by Davit Gachechiladze):
Replying to [comment:17 Carlton Gibson]:
> Hi Davit,
>
> Thanks for the suggestion. Strictly you're right, in theory this
simplification is available. We can't make it, however.
>
> Firstly, they'll be plenty of folks that overrode `get_context_data()`
relying on the fact that `self.object` is injected.
> (We change it, we break their code.)
>
> Then, removing relies too much on internal knowledge of the CBV
implementations.
>
> The general pattern for `get_context_data()` is this:
>
> {{{
> def get_context_data(self, **kwargs):
> context = {
> # Some stuff...
> }
>
> # Allow caller to inject the values we want...
> context.update(kwargs)
>
> return context
> }}}
>
> Without looking at `SingleObjectMixin` at all, the implementation of
BaseDetailView.get() is exactly what one want's: we want the calling
function to ''drive'' `get_context_data() by passing in the object to be
rendered.
>
> I don't know if you've seen them but check out http://django-vanilla-
views.org/ for a stripped back take on GCBVs here.
Thank you for explanation.
--
Ticket URL: <https://code.djangoproject.com/ticket/30698#comment:18>