I am referring https://www.webforefront.com/django/namedjangourls.html to understand django urlconfs. I have encountered terms instance namespace and application namespace. I know about namespaces in urlsconfs. But I don't know the difference between them.
I referred django docs for it. It mentions that instance and app namespaces, comes into picture, when multiple instances of same app is used in django project.
But still, I am not able to understand it. I have googled out, but couldn't find any help on it.
Thanks in advance.
Think of instance namespace as your nickname and application namespace as your real name.
People can have many nicknames for you, but your real name doesn't change.
Django uses the application namespace (your real name) to reverse urls, cause as an application you should not care how many instance namespaces (nicknames) there are.
But to differentiate between one instance and the next, you will use the instance namespaces (nicknames) in urlconfs.
Let's say your app deals with customers and store employees. Both of these have physical addresses and you might want to use an app that just handles all address information: forms, validation, model structure, geo location etc. Our fictional app is a reusable django app called "django_super_address".
Your root url conf may look like this:
urlpatterns = [
path('customer/address/',
include('django_super_address.urls',
namespace='customer_address')
),
path('employee/address/',
include('django_super_address.urls',
namespace='employee_address')
),
]
This includes the same urls below different URL paths, pointing to the same app, using different namespaces (nicknames).
Within django_super_address, it has defined it's application namespace:
# File: django_super_address/urls.py
from . import views
app_name = 'django_super_address'
urlpatterns = [
path('create/', views.SomeAddressCreateView.as_view(),
name='address_create'),
path('create/success/', views.SuccessView(),
name='address_create_success'),
...
]
And in views it uses:
# File django_super_address/views.py
class SomeAddressCreateView(generic.CreateView):
def success_url(self):
return reverse(
'django_super_address:address_create_success'
)
...
When Django gets the URL `/employee/address/create/':
It sets the instance namespace to employee_address
It reads the urls from django_super_address
It sets the application namespace to django_super_address and
associates the urls.py with that application namespace.
In the view:
It reverses the URL by looking at the urls file associated with the application namespace (real name) and reverses the name into: create/success
It then goes back up the chain, now using the instance namespace (nickname) to prepend the rest of the url: root + employee/address/ + create/success/ = /employee/address/create/success/
And there you have it: nicknames for urlconfs and application namespaces for reverse!
From my understanding, it goes like this:
For two different applications using the same URL pattern, use an Application namespace.
For two different instances of the same application using the same URL configuration and views, use an Instance namespace.
The application of Instance namespace might sound a bit confusing. Let me try to clarify if that's the case. Consider the example given in the Django docs.
urls.py:
from django.urls import include, path
urlpatterns = [
path('author-polls/', include('polls.urls', namespace='author-polls')),
path('publisher-polls/', include('polls.urls', namespace='publisher-polls')),
]
polls/urls.py:
from django.urls import path
from . import views
app_name = 'polls'
urlpatterns = [
path('', views.IndexView.as_view(), name='index'),
path('<int:pk>/', views.DetailView.as_view(), name='detail'),
...
]
The namespaces are defined like this:
The Application namespace is defined by app_name attribute in polls/urls.py
The Instance namespace is defined by namespace argument in urls.py
Here, both author-polls and publisher-polls are using the same polls.urls to resolve their URLs. Without an Instance namespace, resolving a URL like 'polls:index' could create confusion on which URL it's intending to fetch. That's why Django has a set of protocol defined to fix this issue for all kinds of situations when you are attempting to reverse and resolve namespaced URLs.
You can use the urls.py for an app by including it in different urls path, for example we can have:
urlpatterns = [
path('author-polls/', include('polls.urls')),
path('publisher-polls/', include('polls.urls')),
]
As you see, both included polls.urls which is:
app_name = 'polls' urlpatterns = [
path('', views.IndexView.as_view(), name='index'),
path('<int:pk>/', views.DetailView.as_view(), name='detail'),
...
]
So far so good!
But there is a problem. In the template, where is 'polls:index' pointing?!
And now instance namespace comes into the picture.
urlpatterns = [
path('author-polls/', include('polls.urls', namespace='author-polls')),
path('publisher-polls/', include('polls.urls', namespace='publisher-polls')),
]
Django has some rules to reverse namespace urls >> https://docs.djangoproject.com/en/3.0/topics/http/urls/#reversing-namespaced-urls
basically each application namespace can have multiple instance namespace ,
for example :
this is project URLs file (main urls) :
path('', include("movie_app.urls")),
path('my_namespace1/', include("movie_app.urls", namespace='my_namespace1')),
path('my_namespace2/', include("movie_app.urls", namespace='my_namespace2')),
you can see, they all mentions to the same app.urls file (movie_app.urls) , but the path link are different .
first one is : "",
and second one is : "my_namespace1/",
and the third is : "my_namespace2/",
and this is movie_app.urls file (child file ) :
app_name = 'movie_app'
urlpatterns = [
path('appmovie1/', myview1 , name="myname"),
]
now when you use the all paths in your html templates for example :
<h1> application namespace : url name</h1>
<h1>instance namespace1 : url name</h1>
<h1>instance namespace2 : url name </h1>
you will note the different in href link :
<h1> application namespace : url name</h1>
<h1>instance namespace1 : url name</h1>
<h1>instance namespace2 : url name </h1>
in the end:
app namespace and instance name space will help you to determine / select the correct URL path from multiple URL paths that use same include .urls file.
I hope this helpful for you .
The namespace instance can only be used with include. This is useful when we want to have multiple paths with different URLs, but we want to include the same URLconf modules.
Let's say we have this code:
#my_site/urls.py
urlpatterns = [
path('url1/',include('english.urls')),
path('url2/',include('english.urls'))]
#english/urls.py
app_name='english'
urlpatterns = [
path('words/', views.index, name='words')]
#template.html
Something
Clicking on the link will redirect us to url1/words, because Django will choose the first element from the urlpatterns. If we want to be redirected to url2/words, we must use the namespace (instance namespace), that is:
#my_site/urls.py
urlpatterns = [
path('url1/',include('english.urls', namespace='eng')),
path('url2/',include('english.urls', namespace='eng2'))]
#english/urls.py
app_name='english'
urlpatterns = [
path('words/', views.index, name='words')]
and then:
#template.html
Something
I will add that if we do not have an instance namespace, Django will probably warn us:
WARNINGS: ?: (urls.W005) URL namespace 'english' isn't unique. You may
not be able to reverse all URLs in this namespace
In general, the instance namespace is useful when, for example:
we want to have different URLs depending on the user's native language, such as: 'django/documentation/', 'django/dokumentacja/' or 'django/en', 'django/pl'
we want to separate URLs for specific groups of people: 'amazon/clients/', 'amazon/employees'
we have changed the URL of the website and to not confuse old users, we also allow access to the site via the previous link
we make it easier to find our site on the internet
This is not limited to different URLs. Even though we use the same views, we can slightly modify them depending on the URL we are on:
def index(request):
current_url = request.path
if current_url == '/url1/words/':
''' do something '''
elif current_url == '/url2/words/':
''' do something else '''
return render(request, 'template.html')
We can, for example, change the context or choose a different template.
Related
I looked at the official Django documentation(https://docs.djangoproject.com/en/3.2/topics/http/urls/#reversing-namespaced-urls) and the error code and wrote the following. How can I write namespaces to work?
views.py:
from django.urls import path, include
app_name = 'home'
urlpatterns = [
path('math/', include('math_note.urls', namespace='math-note'))
]
templates:
math note
Error when running runserver:
django.core.exceptions.ImproperlyConfigured: Specifying a namespace in include() without providing an app_name is not supported. Set the app_name attribute in the included module, or pass a 2-tuple containing the list of patterns and app_name instead.
Question:
How can I use the namespace function?
Second question:
Thank you! Well connected via
<a href="{% url 'music:home-page' %}">(to app_name = music)
But when I call the form from the music app and load the url to generate, I get an error. The other URLs didn't have any issues, only this one.
Reverse for 'home-page' not found. 'home-page' is not a valid view function or pattern name.
#music/urls.py
from django.urls import path
from . import views
app_name = 'music'
urlpatterns = [
path('', views.music_home_page, name='home-page'),
path('new/', views.new_song, name='new'),
path('music_player/<int:id>/', views.music_player, name='music-player'),
]
Question:
I solved the previous problem and got the following problem. What is the cause and solution of this?
The namespace kwarg that include accepts is an instance namespace i.e. an instance of an application namespace, you cannot have instance namespaces without having an application namespace which as the error specifies you do by specifying app_name in the included module or by passing a 2-tuple containing the patterns and application namespace to include.
Hence you need to modify math_note.urls and add an app_name variable to it:
app_name = 'math_note'
urlpatterns = [
...
]
Keep your other urls (likely in home.urls?) as it is:
from django.urls import path, include
app_name = 'home'
urlpatterns = [
path('math/', include('math_note.urls', namespace='math-note'))
]
just remove namespace from the path.
including a url does not require to have namespace. having your namespace on your math-notes is enough.
views.py
from django.urls import path, include
app_name = 'home'
urlpatterns = [
path('math/', include('math_note.urls', name='math-note'))
]
Use name instead of namespace
app_name in application url will work as namespace. just remove namespace from include in root project directory.
your urlpatterns should look like:
urlpatterns = [
path('math/', include('math_note.urls'))
]
and define app_name='home' in your application urls.
something like:
`app_name='home'`
urlpatterns = [
path('list/', <your view>, name='app-list'),
]
second question answer.
I have set the navbar so I can't see the exact error code content. When I deleted the navbar, I saw the exact error content, and the cause of the error was the return link.
I want to write a reusable Django application.
I tell my users to add the following to their urls.py
path('slack/', include(('slack_integration.urls', 'slack_integration'), namespace='slack_integration'),
And in my urls.py I want to have a view login_callback.
Now in my view, I need to get a value of slack_integration:login_callback.
I can trust the user that he/she will integrate it with slack_integration prefix and use it. But is this the best practise? Can I somehow get the name of the namespace for the app if user chooses a different name for it?
Thanks a lot!
Using namespace= within urls.py files is no longer supported, as it moves something specific to the Django app outside of the Python package that is the Django app.
The best practice now is to define the app_name within the urls.py file inside the Django app.
The old way: DON'T DO THIS (pre-Django 2.0)
the root urls.py
path('slack/', include(('slack_integration.urls', 'slack_integration'), namespace='slack_integration'),
The new way: DO THIS! (Django 2.0+)
the root urls.py
from django.urls import path, include
urlpatterns = [
path('slack/', include(('slack_integration.urls', 'slack_integration')),
]
slack_integration/urls.py
from django.urls import path
app_name = "slack_integrations"
urlpatterns = [
path('', HomeView.as_view(), name='home'),
]
As you can see, this keeps the namespace for the patterns within the app itself, along with the templates most likely to use it. The days of extra instructions on how to include an app are over! Good luck.
I want to include some django app's urls, in two different parent routes. The problem is, if I try to do this, then I will not be able to use reverse function properly for that app's urls.
This is where I'm stuck. The following url configurations will result in creation of two different url sets, e.g:
/api/v4/auth/{login, register, ...}
/api/auth/{login, register, ...}
app A (urls.py)
from auth import views
urlpatterns = [
url(r'^login/', views.login, name='login'),
url(r'^register/', views.register, name='register'),
...
]
main app (urls.py)
from auth import urls as auth_urls
urlpatterns = [
url(r'^api/v4/auth/', include(auth_urls)),
url(r'^api/auth/', include(auth_urls)),
...
]
Now, if I try to use reverse function like below:
def get_login_url():
return reverse('login')
I would probably get one of the possible outputs which I don't know how to control!
I don't know if django supports appending some kind of prefix to names of the urls that are being included or is there any tricks to hack around it or not!
You can use namespaces
from auth import urls as auth_urls
urlpatterns = [
url(r'^api/v4/auth/', include(auth_urls, namespace='auth1'))),
url(r'^api/auth/', include(auth_urls, namespace='auth2'))),
...
]
This way, you will be able to reverse alling auth1:login
In my project I have three apps, "abc", "xyz" and "common." Common isn't a real app inasmuch as it just stores templates, models and views that are inherited and extended by both apps.
Project-level urls.py looks like so, and properly redirects requests to the respective app:
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^abc/', include('abc.urls')),
url(r'^xyz/', include('xyz.urls')),
]
Both apps' url.py files look like so; the ONLY difference is replace every instance of ABC with XYZ:
from django.conf.urls import url
from views import ABCAlertList as AlertList
from views import ABCEventList as EventList
from views import ABCEventDetail as EventDetail
from views import ABCEventReplay as EventReplay
from views import ABCUploadView as UploadView
urlpatterns = [
url(r'^$', AlertList.as_view(), name='view_alerts'),
url(r'^entities/(?P<uid>\w+)/$', EventList.as_view(), name='view_uid'),
url(r'^entities/(?P<uid>\w+)/replay/$', EventReplay.as_view(), name='view_replay'),
url(r'^entities/(?P<uid>\w+)/event/(?P<eid>\w+)/$', EventDetail.as_view(), name='view_event'),
url(r'^upload/$', UploadView.as_view(), name='upload_file'),
]
Again, all the views are common between both apps so there is nothing app-specific to either of them. Both apps make use of the same line in the same common template:
<a href="{% url 'view_uid' alert.uid %}">
Now, the problem:
App ABC works fine on the top-level page. But the urls it's rendering to go past that point point to the wrong app.
For example, I'll be in
http://localhost:8888/abc/
and the urls on that page render as
http://localhost:8888/xyz/entities/262b3bce18e71c5459a41e1e6d52a946ab47e88f/
What gives? It looks like Django is reading the wrong app's urls.py.
Django can't tell the difference between the URLs under abc/ and xyz/ just by the view name and arguments. Since reversing will go through the patterns in reverse order, the patterns under xyz/ will always match first, so all links generated using reverse() or the {% url %} tag will point to the xyz app.
You need to give each pattern a unique name, or use a URL namespace. In Django 1.9+ you should set the app_name attribute:
app_name = 'abc'
urlpatterns = [
url(r'^$', AlertList.as_view(), name='view_alerts'),
url(r'^entities/(?P<uid>\w+)/$', EventList.as_view(), name='view_uid'),
url(r'^entities/(?P<uid>\w+)/replay/$', EventReplay.as_view(), name='view_replay'),
url(r'^entities/(?P<uid>\w+)/event/(?P<eid>\w+)/$', EventDetail.as_view(), name='view_event'),
url(r'^upload/$', UploadView.as_view(), name='upload_file'),
]
In Django 1.8 you need to pass the namespace parameter to include():
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^abc/', include('abc.urls', namespace='abc')),
url(r'^xyz/', include('xyz.urls', namespace='xyz')),
]
You can then reverse the url by passing the proper namespace:
<a href="{% url 'abc:view_uid' alert.uid %}">
If you need to use the same templates or functions for both apps, you need to set the application namespace of both apps to be the same, but use a different instance namespace.
In 1.9+, this means using the same app_name attribute, but passing a different namespace argument:
# myapp/urls.py
app_name = 'common_app_name'
urlpatterns = [
# app urls
]
# myproject/urls.py
urlpatterns = [
url(r'^abc/', include('abc.urls', namespace='abc')),
url(r'^xyz/', include('xyz.urls', namespace='xyz')),
]
In templates, you need to use the application namespace to reverse urls. The current instance namespace is automatically taken into account. In calls to reverse() you need to pass the current namespace:
reverse('common_app_name:view_alerts', current_app=request.resolver_match.namespace)
In Django 1.8 you don't have the app_name attribute, you need to pass it as a parameter to include():
urlpatterns = [
url(r'^abc/', include('abc.urls', namespace='abc', app_name='common_app_name')),
url(r'^xyz/', include('xyz.urls', namespace='xyz', app_name='common_app_name')),
]
Django 1.8 also won't automatically use the current instance namespace in calls to the {% url %} tag. You need to set the request.current_app attribute for that:
def my_view(request):
request.current_app = request.resolver_match.namespace
...
I'm using models.FileField like this below.
It's a fantastic django function. Because, it makes user can upload within Django administration page without any code.
So, I clicked Part image url Link. But, I got a error message below.
my urls pattern is below.
urls.py
urlpatterns = [
url(r'^parts/', include('parts.urls', namespace='parts')),
url(r'^admin/', include(admin.site.urls)),
url(r'^$', views.MW_Hello.as_view(), name='Hello'),
]
Do I have to add url mapping in url patterns?
You need to configure your urls and settings for managing the static files
https://docs.djangoproject.com/en/1.8/howto/static-files/
https://docs.djangoproject.com/en/1.8/topics/files/