def get_urlpatterns(handler_module):
# NB: This could just as well be your `urls.py` – it's here to make testing various handler
# configurations easier.
router = Router.from_file(os.path.join(os.path.dirname(__file__), 'tests', 'petstore-expanded.yaml'))
router.add_handlers(handler_module)
validate_router(router)
router_urls = router.get_urls(
decorate=(csrf_exempt,),
optional_trailing_slash=True,
)
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^api/', include(router_urls, 'api')),
url(r'^api/', include(get_docs_urls(router, 'api-docs'), 'api-docs')),
]
return urlpatterns
python类include()的实例源码
def include_docs_urls(
title=None, description=None, schema_url=None, public=True,
patterns=None, generator_class=SchemaGenerator):
docs_view = get_docs_view(
title=title,
description=description,
schema_url=schema_url,
public=public,
patterns=patterns,
generator_class=generator_class,
)
schema_js_view = get_schemajs_view(
title=title,
description=description,
schema_url=schema_url,
public=public,
patterns=patterns,
generator_class=generator_class,
)
urls = [
url(r'^$', docs_view, name='docs-index'),
url(r'^schema.js$', schema_js_view, name='schema-js')
]
return include(urls, namespace='api-docs')
def test_partner_patterns_instance_ns(partner_factory):
partner = partner_factory(slug='automatic_partner',
auto_set_partner=False)
set_partner(partner)
urlconf = (partner_patterns(
url(r'^ns/', include(base_urlconf, namespace='instance-ns'))
),)
url_ = reverse('instance-ns:static-url', urlconf)
assert url_ == '/automatic_partner/ns/static/'
url_ = reverse('instance-ns:static-url', urlconf, kwargs=dict(
partner_slug='manual_partner'))
assert url_ == '/manual_partner/ns/static/'
url_ = reverse('instance-ns:dynamic-url', urlconf, kwargs=dict(pk=1))
assert url_ == '/automatic_partner/ns/dynamic/1/'
url_ = reverse('instance-ns:dynamic-url', urlconf, kwargs=dict(
partner_slug='manual_partner', pk=1))
assert url_ == '/manual_partner/ns/dynamic/1/'
url_ = reverse('instance-ns:dynamic-url', urlconf, args=(1,))
assert url_ == '/automatic_partner/ns/dynamic/1/'
def test_register_adds_default_routes_from_modelname(self):
class ParentView(ModelView):
pass
class FooView(ParentView):
model = FooModel
class BarView(ParentView):
model = BarModel
r = Router()
r.register(ParentView)
urls_module.urlpatterns = [url(r'^', include(r.urls))]
self.assertTrue(is_valid_path('/foo_model/', urls_module))
self.assertTrue(is_valid_path('/foo_model/1/', urls_module))
self.assertTrue(is_valid_path('/bar_model/12345/', urls_module))
self.assertFalse(is_valid_path('/bar_model/lalala/', urls_module))
self.assertFalse(is_valid_path('/another_model/', urls_module))
def test_register_adds_custom_route_names(self):
class ParentView(ModelView):
pass
class FooView(ParentView):
model = FooModel
route = 'foo'
class BarView(ParentView):
model = BarModel
# Explicit Route objects should also be accepted
route = Route('bar')
r = Router()
r.register(ParentView)
urls_module.urlpatterns = [url(r'^', include(r.urls))]
self.assertTrue(is_valid_path('/foo/', urls_module))
self.assertTrue(is_valid_path('/foo/1/', urls_module))
self.assertTrue(is_valid_path('/bar/12345/', urls_module))
# Default named routes should not be there
self.assertFalse(is_valid_path('/foo_model/1/', urls_module))
self.assertFalse(is_valid_path('/bar_model/1/', urls_module))
def test_register_obeys_custom_route_config(self):
class ParentView(ModelView):
pass
class FooView(ParentView):
model = FooModel
route = Route('foo', list_endpoint=False)
class BarView(ParentView):
model = BarModel
route = Route('bar', detail_endpoint=False)
r = Router()
r.register(ParentView)
urls_module.urlpatterns = [url(r'^', include(r.urls))]
self.assertFalse(is_valid_path('/foo/', urls_module))
self.assertTrue(is_valid_path('/foo/1/', urls_module))
self.assertTrue(is_valid_path('/bar/', urls_module))
self.assertFalse(is_valid_path('/bar/1/', urls_module))
def test_register_adds_default_routes_from_modelname(self):
class ParentView(ModelView):
pass
class FooView(ParentView):
model = FooModel
class BarView(ParentView):
model = BarModel
r = Router()
r.register(ParentView)
urls_module.urlpatterns = [url(r'^', include(r.urls))]
self.assertTrue(is_valid_path('/foo_model/', urls_module))
self.assertTrue(is_valid_path('/foo_model/1/', urls_module))
self.assertTrue(is_valid_path('/bar_model/12345/', urls_module))
self.assertFalse(is_valid_path('/bar_model/lalala/', urls_module))
self.assertFalse(is_valid_path('/another_model/', urls_module))
def test_register_adds_custom_route_names(self):
class ParentView(ModelView):
pass
class FooView(ParentView):
model = FooModel
route = 'foo'
class BarView(ParentView):
model = BarModel
# Explicit Route objects should also be accepted
route = Route('bar')
r = Router()
r.register(ParentView)
urls_module.urlpatterns = [url(r'^', include(r.urls))]
self.assertTrue(is_valid_path('/foo/', urls_module))
self.assertTrue(is_valid_path('/foo/1/', urls_module))
self.assertTrue(is_valid_path('/bar/12345/', urls_module))
# Default named routes should not be there
self.assertFalse(is_valid_path('/foo_model/1/', urls_module))
self.assertFalse(is_valid_path('/bar_model/1/', urls_module))
def test_app_creation(self):
app_name = 'TestUssdApp'
call_command('create_ussd_app', app_name)
ussd_url = [
url(r'^ussd/', include('TestUssdApp.urls'))
]
urls.urlpatterns += ussd_url
end_point_url = "http://localhost:8081/ussd/TestUssdApp_ussd_gateway"
payload = {
"phoneNumber": "0717199135", "sessionId": "12", "text": "1", "language": "en", "serviceCode": "200"}
response = self.client.post(end_point_url,
data=json.dumps(payload),
content_type="application/json",)
self.assertEqual(response.content,
b'END Example Quit Screen. Delete this and define your own customer journey screens.')
self.assertEqual(response.status_code, 200)
print(response.status_code)
os.system('rm -r TestUssdApp') # Remove created app. Clean up
def get_patterns(self):
self.discover_plugins()
# We want untranslated name of the plugin for its slug so we deactivate translation
lang = get_language()
deactivate_all()
try:
url_patterns = []
for plugin in self.get_all_plugins():
p = plugin()
slug = slugify(force_text(normalize_name(p.__class__.__name__)))
url_patterns += [
url(r'^plugin/%s/' % (slug,), include(p.plugin_urls)),
]
finally:
# Reactivate translation
activate(lang)
return url_patterns
def get_plugin_urls():
urlpatterns = []
for plugin in list(registry.get_plugins().values()):
slug = getattr(plugin, 'slug', None)
if slug:
article_urlpatterns = plugin.urlpatterns.get('article', [])
urlpatterns += [
url(r'^(?P<article_id>\d+)/plugin/' + slug + '/',
include(article_urlpatterns)),
url(r'^(?P<path>.+/|)_plugin/' + slug + '/',
include(article_urlpatterns)),
]
root_urlpatterns = plugin.urlpatterns.get('root', [])
urlpatterns += [
url(r'^_plugin/' + slug + '/', include(root_urlpatterns)),
]
return urlpatterns
def urls(self):
"""
Provides URLconf details for the ``Api`` and all registered
``Resources`` beneath it.
"""
pattern_list = [
url(r"^(?P<api_name>%s)%s$" % (self.api_name, trailing_slash()), self.wrap_view('top_level'), name="api_%s_top_level" % self.api_name),
]
for name in sorted(self._registry.keys()):
self._registry[name].api_name = self.api_name
pattern_list.append((r"^(?P<api_name>%s)/" % self.api_name, include(self._registry[name].urls)))
urlpatterns = self.prepend_urls()
overridden_urls = self.override_urls()
if overridden_urls:
warnings.warn("'override_urls' is a deprecated method & will be removed by v1.0.0. Please rename your method to ``prepend_urls``.")
urlpatterns += overridden_urls
urlpatterns += patterns('',
*pattern_list
)
return urlpatterns
def default_urlpatterns(provider):
package = provider.get_package()
login_view = import_attribute(package + '.views.login')
callback_view = import_attribute(package + '.views.callback')
logout_view = import_attribute(package + '.views.logout')
urlpatterns = [
url('^login/$',
login_view, name=provider.id + '_login'),
url('^login/callback/$',
callback_view, name=provider.id + '_callback'),
url('^logout/$',
logout_view, name=provider.id + '_logout'),
]
return [url('^' + provider.get_slug() + '/', include(urlpatterns))]
def construct_endpoint(self, instance, spec, loc, context):
"""
Constructor of '.endpoint' predicate.
It gets the generated views and it maps them with urlpatterns which
will later be used from django.
"""
parent_name = context.get('parent_name')
collections = self.get_structural_elements(instance)
if not collections:
raise utils.DRFAdapterException(
'.endpoint without any collection found.', loc=loc)
router = routers.DefaultRouter()
for collection in collections:
collection_spec = instance.get(collection)
view = collection_spec.get(self.ADAPTER_CONF)
basename = parent_name + '_' + collection
router.register(collection, view, base_name=basename)
self.urls[parent_name] = url(
r'^' + parent_name + '/', include(router.urls))
def get_urls(self):
"""
Override the default get_urls() method to move default Oscar promotions
from location r'' to r'^promotions/' to free up space for Wagtail's
wagtailcore serving mechanism.
"""
urls = super(OscarApplication, self).get_urls()[:-1]
urls.append(url(r'^promotions/', include(self.promotions_app.urls)),)
return urls
def _decorated_urls(self):
urlpatterns = self._get_default_urlpatterns()
# Apply access controls to all views in the patterns
permissions = getattr(self, 'permissions', [])
_decorate_urlconf(urlpatterns, require_perms, permissions)
_decorate_urlconf(urlpatterns, _current_component, panel=self)
# Return the three arguments to django.conf.urls.include
return urlpatterns, self.slug, self.slug
def _decorated_urls(self):
urlpatterns = self._get_default_urlpatterns()
default_panel = None
# Add in each panel's views except for the default view.
for panel in self._registry.values():
if panel.slug == self.default_panel:
default_panel = panel
continue
url_slug = panel.slug.replace('.', '/')
urlpatterns.append(url(r'^%s/' % url_slug,
include(panel._decorated_urls)))
# Now the default view, which should come last
if not default_panel:
raise NotRegistered('The default panel "%s" is not registered.'
% self.default_panel)
urlpatterns.append(url(r'', include(default_panel._decorated_urls)))
# Require login if not public.
if not self.public:
_decorate_urlconf(urlpatterns, require_auth)
# Apply access controls to all views in the patterns
permissions = getattr(self, 'permissions', [])
_decorate_urlconf(urlpatterns, require_perms, permissions)
_decorate_urlconf(urlpatterns, _current_component, dashboard=self)
# Return the three arguments to django.conf.urls.include
return urlpatterns, self.slug, self.slug
def _urls(self):
"""Constructs the URLconf for Horizon from registered Dashboards."""
urlpatterns = self._get_default_urlpatterns()
self._autodiscover()
# Discover each dashboard's panels.
for dash in self._registry.values():
dash._autodiscover()
# Load the plugin-based panel configuration
self._load_panel_customization()
# Allow for override modules
if self._conf.get("customization_module", None):
customization_module = self._conf["customization_module"]
bits = customization_module.split('.')
mod_name = bits.pop()
package = '.'.join(bits)
mod = import_module(package)
try:
before_import_registry = copy.copy(self._registry)
import_module('%s.%s' % (package, mod_name))
except Exception:
self._registry = before_import_registry
if module_has_submodule(mod, mod_name):
raise
# Compile the dynamic urlconf.
for dash in self._registry.values():
urlpatterns.append(url(r'^%s/' % dash.slug,
include(dash._decorated_urls)))
# Return the three arguments to django.conf.urls.include
return urlpatterns, self.namespace, self.slug
def get_urls(self):
urlpatterns = [
url(r'', include(wagtail_urls)),
]
return self.post_process_urls(urlpatterns)
def get_urls(self):
urlpatterns = super(AdminoSite, self).get_urls()
valid_app_labels = []
for model, model_admin in self._registry.items():
api_urlpatterns = [
url(r'^api/%s/%s/' % (model._meta.app_label, model._meta.model_name), include(model_admin.api_urls)),
]
urlpatterns = urlpatterns + api_urlpatterns
if model._meta.app_label not in valid_app_labels:
valid_app_labels.append(model._meta.app_label)
return urlpatterns
def get_urls(self):
from django.conf.urls import url, include
from xadmin.views.base import BaseAdminView
if settings.DEBUG:
self.check_dependencies()
def wrap(view, cacheable=False):
def wrapper(*args, **kwargs):
return self.admin_view(view, cacheable)(*args, **kwargs)
return update_wrapper(wrapper, view)
# Admin-site-wide views.
urlpatterns = [
url(r'^jsi18n/$', wrap(self.i18n_javascript, cacheable=True), name='jsi18n')
]
# Registed admin views
# inspect[isclass]: Only checks if the object is a class. With it lets you create an custom view that
# inherits from multiple views and have more of a metaclass.
urlpatterns += [
url(path, wrap(self.create_admin_view(clz_or_func)) if inspect.isclass(clz_or_func) and issubclass(clz_or_func, BaseAdminView) else include(clz_or_func(self)),
name=name) for path, clz_or_func, name in self._registry_views
]
# Add in each model's views.
for model, admin_class in self._registry.iteritems():
view_urls = [url(
path, wrap(
self.create_model_admin_view(clz, model, admin_class)),
name=name % (model._meta.app_label, model._meta.model_name))
for path, clz, name in self._registry_modelviews]
urlpatterns += [
url(r'^%s/%s/' % ( model._meta.app_label, model._meta.model_name), include(view_urls))
]
return urlpatterns
def get_urls(self):
return [
url(r'^', include('django.contrib.auth.urls')),
url(r'^parameters/edit/', self.user_parameters_update_view.as_view(), name='account-parameters'),
url(r'^password/edit/', self.user_password_update_view.as_view(), name='account-password'),
url(r'^register/', self.user_create_view.as_view(), name='register'),
url(r'^unregister/$', self.user_delete_view.as_view(), name='unregister'),
]
def get_urls(self):
urls = super(AGCSForumApp, self).get_urls()
return urls + [
url(r'^account/', include(self.auth_app.urls)),
]
def test_include(self):
"""Make sure requires(A)(include(my_app.urls)) works."""
decorated_include = requires(A)(include(nested_urls2))
for pattern in decorated_include[0].urlpatterns:
[cell] = [cell for cell in pattern.resolve.__closure__
if isinstance(cell.cell_contents, requires)]
requirer = cell.cell_contents
self.assertTrue(
PermissionChecker(['a']).visit(requirer.gate.get_requires))
self.assertTrue(
PermissionChecker(['a']).visit(requirer.gate.post_requires))
def get_urls(self):
"""Ensure that urls included in get_urls() are behind requires().
We need to fix the include() logic for admin URLs. Django admin isn't
very extensible, so we have to call super, remove the url patterns
for model_admins that have a _gate, and replace the pattern with
a properly built include behind the model admin's gate.
Would be a lot easier if django exposed something like
get_patterns_for_app(app_label), but noooooo.
"""
# We have to maintain the URL ordering due to the way URLs are resolved
# TODO - Test this, can lead to heisenbugs
urls = OrderedDict((urlp.regex.pattern, urlp) for urlp in
super(NestedGroupsAdminSite, self).get_urls())
for model, model_admin in self._get_admins_with_gate():
if hasattr(model._meta, 'module_name'):
model_name = model._meta.module_name
elif hasattr(model._meta, 'model_name'):
model_name = model._meta.model_name
else:
raise ValueError(
"Model Admin is missing a module or model name.")
pattern = (
r'^%s/%s/' %
(model._meta.app_label, model_name))
urls[pattern] = url(
pattern,
requires(get=model_admin._gate.get_requires,
post=model_admin._gate.post_requires)(
include(model_admin.urls)))
return list(urls.values())
def test_include(self):
"""Make sure requires(A)(include(my_app.urls)) works."""
decorated_include = requires(A)(include(nested_urls2))
for pattern in decorated_include[0].urlpatterns:
[cell] = [cell for cell in pattern.resolve.__closure__
if isinstance(cell.cell_contents, requires)]
requirer = cell.cell_contents
self.assertTrue(
PermissionChecker(['a']).visit(requirer.gate.get_requires))
self.assertTrue(
PermissionChecker(['a']).visit(requirer.gate.post_requires))
def get_urls(self):
"""Ensure that urls included in get_urls() are behind requires().
We need to fix the include() logic for admin URLs. Django admin isn't
very extensible, so we have to call super, remove the url patterns
for model_admins that have a _gate, and replace the pattern with
a properly built include behind the model admin's gate.
Would be a lot easier if django exposed something like
get_patterns_for_app(app_label), but noooooo.
"""
# We have to maintain the URL ordering due to the way URLs are resolved
# TODO - Test this, can lead to heisenbugs
urls = OrderedDict((urlp.regex.pattern, urlp) for urlp in
super(NestedGroupsAdminSite, self).get_urls())
for model, model_admin in self._get_admins_with_gate():
if hasattr(model._meta, 'module_name'):
model_name = model._meta.module_name
elif hasattr(model._meta, 'model_name'):
model_name = model._meta.model_name
else:
raise ValueError(
"Model Admin is missing a module or model name.")
pattern = (
r'^%s/%s/' %
(model._meta.app_label, model_name))
urls[pattern] = url(
pattern,
requires(get=model_admin._gate.get_requires,
post=model_admin._gate.post_requires)(
include(model_admin.urls)))
return list(urls.values())
def include(module, namespace=None, app_name=None):
from django.conf.urls import include
if django.VERSION < (1,9):
return include(module, namespace, app_name)
else:
return include((module, app_name), namespace)
def register_admin_urls():
return [
url(r'^relevancy/', include(urls)),
]
def register_admin_urls():
return [
url(r'^experiments/', include(admin_urls, app_name='experiments', namespace='experiments')),
]
