Determine complete Django url configuration

Django extensions provides a utility to do this as a manage.py command.

pip install django-extensions

Then add django_extensions to your INSTALLED_APPS in settings.py. then from the console just type the following

python manage.py show_urls

At the risk of adding a "me too" answer, I am posting a modified version of the above submitted script that gives you a view listing all the URLs in the project, somewhat prettified and sorted alphabetically, and the views that they call. More of a developer tool than a production page.

def all_urls_view(request):
    from your_site.urls import urlpatterns #this import should be inside the function to avoid an import loop
    nice_urls = get_urls(urlpatterns) #build the list of urls recursively and then sort it alphabetically
    return render(request, "yourapp/links.html", {"links":nice_urls})

def get_urls(raw_urls, nice_urls=[], urlbase=''):
    '''Recursively builds a list of all the urls in the current project and the name of their associated view'''
    from operator import itemgetter
    for entry in raw_urls:
        fullurl = (urlbase + entry.regex.pattern).replace('^','')
        if entry.callback: #if it points to a view
            viewname = entry.callback.func_name
            nice_urls.append({"pattern": fullurl, 
                  "location": viewname})
        else: #if it points to another urlconf, recur!
            get_urls(entry.url_patterns, nice_urls, fullurl)
    nice_urls = sorted(nice_urls, key=itemgetter('pattern')) #sort alphabetically
    return nice_urls

and the template:

<ul>
{% for link in links %}
<li>
{{link.pattern}}   -----   {{link.location}}
</li>
{% endfor%}
</ul>

If you wanted to get real fancy you could render the list with input boxes for any of the regexes that take variables to pass to the view (again as a developer tool rather than production page).

Django is Python, so introspection is your friend.

In the shell, import urls. By looping through urls.urlpatterns, and drilling down through as many layers of included url configurations as possible, you can build the complete url configuration.

import urls
urls.urlpatterns

The list urls.urlpatterns contains RegexURLPattern and RegexURLResolver objects.

For a RegexURLPattern object p you can display the regular expression with

p.regex.pattern

For a RegexURLResolver object q, which represents an included url configuration, you can display the first part of the regular expression with

q.regex.pattern

Then use

q.url_patterns

which will return a further list of RegexURLResolver and RegexURLPattern objects.

This question is a bit old, but I ran into the same problem and I thought I would discuss my solution. A given Django project obviously needs a means of knowing about all its URLs and needs to be able to do a couple things:

1. map from a url -> view
2. map from a named url -> url (then 1 is used to get the view)
3. map from a view name -> url (then 1 is used to get the view)

Django accomplishes this mostly through an object called a RegexURLResolver.

1. RegexURLResolver.resolve (map from a url -> view)
2. RegexURLResolver.reverse

You can get your hands on one of these objects the following way:

from my_proj import urls
from django.core.urlresolvers import get_resolver
resolver = get_resolver(urls)

Then, you can simply print out your urls the following way:

for view, regexes in resolver.reverse_dict.iteritems():
    print "%s: %s" % (view, regexes)

That said, Alasdair's solution is perfectly fine and has some advantages, as it prints out some what more nicely than this method. But knowing about and getting your hands on a RegexURLResolver object is something nice to know about, especially if you are interested in Django internals.