def getRequest():
r = Request({
"PATH_INFO": "http://aaa.com/test?key=123",
"wsgi.url_scheme": "http",
"SERVER_NAME": "testserver.de",
"SERVER_PORT": 80,
"REQUEST_METHOD": "GET"
})
r.subpath = ["file1.txt"]
r.context = None
return r
def getRequest():
r = Request(
{
"PATH_INFO": "http://aaa.com/test?key=123",
"wsgi.url_scheme": "http",
"SERVER_NAME": "testserver.de",
"SERVER_PORT": 80,
"REQUEST_METHOD": "GET",
}
)
r.subpath = ["file1.txt"]
r.context = None
return r
def sdi_mgmt_views(context, request, names=None):
if not hasattr(context, '__name__'):
# shortcut if the context doesn't have a name (usually happens if the
# context is an exception); we do this because mgmt_path uses Pyramid's
# resource_path_tuple, which wants every object in the lineage to have
# a __name__.
return []
registry = request.registry
introspector = registry.introspector
unordered = []
# create a dummy request signaling our intent
req = Request(request.environ.copy())
req.script_name = request.script_name
req.context = context
req.matched_route = request.matched_route
req.method = 'GET'
req.registry = request.registry
sro_enum = list(enumerate(providedBy(context).__sro__[:-1]))
for data in introspector.get_category('sdi views'):
related = data['related']
sdi_intr = data['introspectable']
tab_title = sdi_intr['tab_title']
tab_condition = sdi_intr['tab_condition']
tab_before = sdi_intr['tab_before']
tab_after = sdi_intr['tab_after']
def is_view(intr):
return intr.category_name == 'views'
for view_intr in filter(is_view, related):
# NB: in reality, the above loop will execute exactly once because
# each "sdi view" is associated with exactly one pyramid view
view_name = view_intr['name']
req.path_info = request.sdiapi.mgmt_path(context, view_name)
if names is not None and not view_name in names:
continue
# do a passable job at figuring out whether, if we visit the
# url implied by this view, we'll be permitted to view it and
# something reasonable will show up
intr_context = view_intr['context']
sro_index = MAX_ORDER
if intr_context is None:
intr_context = Interface
if IInterface.providedBy(intr_context):
if not intr_context.providedBy(context):
continue
for i, spec in sro_enum:
if spec is intr_context:
sro_index = i
break
elif isinstance(context, intr_context):
for i, spec in sro_enum:
if spec.implementedBy(intr_context):
sro_index = i
break
else: # pragma: no cover (coverage bug, this is reached)
continue
if tab_condition is not None and names is None:
if callable(tab_condition):
if not tab_condition(context, request):
continue
elif not tab_condition:
continue
derived = view_intr['derived_callable']
if hasattr(derived, '__predicated__'):
if not derived.__predicated__(context, req):
continue
if hasattr(derived, '__permitted__'):
if not derived.__permitted__(context, req):
continue
predicate_order = getattr(derived, '__order__', MAX_ORDER)
if view_name == request.view_name:
css_class = 'active'
else:
css_class = None
unordered.append(
{'view_name': view_name,
'tab_before':tab_before,
'tab_after':tab_after,
'title': tab_title or view_name.capitalize(),
'class': css_class,
'predicate_order':predicate_order,
'sro_index':sro_index,
'url': request.sdiapi.mgmt_path(
request.context, '@@%s' % view_name)
}
)
# De-duplicate the unordered list of tabs with the same view_name. Prefer
# the tab with the lowest (sro_index, predicate_order) tuple, because this
# is the view that's most likely to be executed when visited and we'd
# like to get its title right.
unordered.sort(key=lambda s: (s['sro_index'], s['predicate_order']))
deduplicated = []
view_names = {}
# use a sort-break to take only the first of each same-named view data.
for view_data in unordered:
vn = view_data['view_name']
if vn in view_names:
continue
view_names[vn] = True
deduplicated.append(view_data)
manually_ordered = []
tab_order = request.registry.content.metadata(context, 'tab_order')
if tab_order is not None:
ordered_names = [ y for y in tab_order if y in
[ x['view_name'] for x in deduplicated ] ]
for ordered_name in ordered_names:
for view_data in unordered[:]:
if view_data['view_name'] == ordered_name:
deduplicated.remove(view_data)
manually_ordered.append(view_data)
# Sort non-manually-ordered views lexically by title. Reverse due to the
# behavior of the toposorter; we'd like groups of things that share the
# same before/after to be alpha sorted ascending relative to each other,
# and reversing lexical ordering here gets us that behavior down the line.
lexically_ordered = sorted(
deduplicated,
key=operator.itemgetter('title'),
reverse=True,
)
# Sort the lexically-presorted unordered views topologically based on any
# tab_before and tab_after values in the view data.
tsorter = TopologicalSorter(default_after=CENTER1, default_before=CENTER2)
tsorter.add(
CENTER1,
None,
after=FIRST,
before=CENTER2,
)
tsorter.add(
CENTER2,
None,
after=CENTER1,
before=LAST,
)
for view_data in lexically_ordered:
before=view_data.get('tab_before', None)
after=view_data.get('tab_after', None)
tsorter.add(
view_data['view_name'],
view_data,
before=before,
after=after,
)
topo_ordered = [
x[1] for x in tsorter.sorted() if x[0] not in (CENTER1, CENTER2)
]
return manually_ordered + topo_ordered
def sdi_mgmt_views(context, request, names=None):
if not hasattr(context, '__name__'):
# shortcut if the context doesn't have a name (usually happens if the
# context is an exception); we do this because mgmt_path uses Pyramid's
# resource_path_tuple, which wants every object in the lineage to have
# a __name__.
return []
registry = request.registry
introspector = registry.introspector
unordered = []
# create a dummy request signaling our intent
req = Request(request.environ.copy())
req.script_name = request.script_name
req.context = context
req.matched_route = request.matched_route
req.method = 'GET'
req.registry = request.registry
sro_enum = list(enumerate(providedBy(context).__sro__[:-1]))
for data in introspector.get_category('sdi views'):
related = data['related']
sdi_intr = data['introspectable']
tab_title = sdi_intr['tab_title']
tab_condition = sdi_intr['tab_condition']
tab_before = sdi_intr['tab_before']
tab_after = sdi_intr['tab_after']
def is_view(intr):
return intr.category_name == 'views'
for view_intr in filter(is_view, related):
# NB: in reality, the above loop will execute exactly once because
# each "sdi view" is associated with exactly one pyramid view
view_name = view_intr['name']
req.path_info = request.sdiapi.mgmt_path(context, view_name)
if names is not None and not view_name in names:
continue
# do a passable job at figuring out whether, if we visit the
# url implied by this view, we'll be permitted to view it and
# something reasonable will show up
intr_context = view_intr['context']
sro_index = MAX_ORDER
if intr_context is None:
intr_context = Interface
if IInterface.providedBy(intr_context):
if not intr_context.providedBy(context):
continue
for i, spec in sro_enum:
if spec is intr_context:
sro_index = i
break
elif isinstance(context, intr_context):
for i, spec in sro_enum:
if spec.implementedBy(intr_context):
sro_index = i
break
else: # pragma: no cover (coverage bug, this is reached)
continue
if tab_condition is not None and names is None:
if callable(tab_condition):
if not tab_condition(context, request):
continue
elif not tab_condition:
continue
derived = view_intr['derived_callable']
if hasattr(derived, '__predicated__'):
if not derived.__predicated__(context, req):
continue
if hasattr(derived, '__permitted__'):
if not derived.__permitted__(context, req):
continue
predicate_order = getattr(derived, '__order__', MAX_ORDER)
if view_name == request.view_name:
css_class = 'active'
else:
css_class = None
unordered.append({
'view_name':
view_name,
'tab_before':
tab_before,
'tab_after':
tab_after,
'title':
tab_title or view_name.capitalize(),
'class':
css_class,
'predicate_order':
predicate_order,
'sro_index':
sro_index,
'url':
request.sdiapi.mgmt_path(request.context, '@@%s' % view_name)
})
# De-duplicate the unordered list of tabs with the same view_name. Prefer
# the tab with the lowest (sro_index, predicate_order) tuple, because this
# is the view that's most likely to be executed when visited and we'd
# like to get its title right.
unordered.sort(key=lambda s: (s['sro_index'], s['predicate_order']))
deduplicated = []
view_names = {}
# use a sort-break to take only the first of each same-named view data.
for view_data in unordered:
vn = view_data['view_name']
if vn in view_names:
continue
view_names[vn] = True
deduplicated.append(view_data)
manually_ordered = []
tab_order = request.registry.content.metadata(context, 'tab_order')
if tab_order is not None:
ordered_names = [
y for y in tab_order
if y in [x['view_name'] for x in deduplicated]
]
for ordered_name in ordered_names:
for view_data in unordered[:]:
if view_data['view_name'] == ordered_name:
deduplicated.remove(view_data)
manually_ordered.append(view_data)
# Sort non-manually-ordered views lexically by title. Reverse due to the
# behavior of the toposorter; we'd like groups of things that share the
# same before/after to be alpha sorted ascending relative to each other,
# and reversing lexical ordering here gets us that behavior down the line.
lexically_ordered = sorted(
deduplicated,
key=operator.itemgetter('title'),
reverse=True,
)
# Sort the lexically-presorted unordered views topologically based on any
# tab_before and tab_after values in the view data.
tsorter = TopologicalSorter(default_after=CENTER1, default_before=CENTER2)
tsorter.add(
CENTER1,
None,
after=FIRST,
before=CENTER2,
)
tsorter.add(
CENTER2,
None,
after=CENTER1,
before=LAST,
)
for view_data in lexically_ordered:
before = view_data.get('tab_before', None)
after = view_data.get('tab_after', None)
tsorter.add(
view_data['view_name'],
view_data,
before=before,
after=after,
)
topo_ordered = [
x[1] for x in tsorter.sorted() if x[0] not in (CENTER1, CENTER2)
]
return manually_ordered + topo_ordered
def sdi_mgmt_views(request, context=None, names=None):
registry = request.registry
if context is None:
context = request.context
introspector = registry.introspector
L = []
# create a dummy request signaling our intent
req = Request(request.environ.copy())
req.script_name = request.script_name
req.context = context
req.matched_route = request.matched_route
req.method = 'GET'
req.registry = request.registry
for data in introspector.get_category('sdi views'):
related = data['related']
sdi_intr = data['introspectable']
tab_title = sdi_intr['tab_title']
tab_condition = sdi_intr['tab_condition']
def is_view(intr):
return intr.category_name == 'views'
for view_intr in filter(is_view, related):
# NB: in reality, the above loop will execute exactly once because
# each "sdi view" is associated with exactly one pyramid view
view_name = view_intr['name']
req.path_info = request.mgmt_path(context, view_name)
if names is not None and not view_name in names:
continue
# do a passable job at figuring out whether, if we visit the
# url implied by this view, we'll be permitted to view it and
# something reasonable will show up
intr_context = view_intr['context']
if IInterface.providedBy(intr_context):
if not intr_context.providedBy(context):
continue
elif intr_context and not isinstance(context, intr_context):
continue
if tab_condition is not None and names is None:
if tab_condition is False or not tab_condition(
context, request):
continue
derived = view_intr['derived_callable']
if hasattr(derived, '__predicated__'):
if not derived.__predicated__(context, req):
continue
if hasattr(derived, '__permitted__'):
if not derived.__permitted__(context, req):
continue
if view_name == request.view_name:
css_class = 'active'
else:
css_class = None
L.append({'view_name': view_name,
'title': tab_title or view_name.capitalize(),
'class': css_class,
'url': request.mgmt_path(request.context,
'@@%s' % view_name)
})
ordered = []
tab_order = request.registry.content.metadata(context, 'tab_order')
if tab_order is not None:
ordered_names_available = [ y for y in tab_order if y in
[ x['view_name'] for x in L ] ]
for ordered_name in ordered_names_available:
for view_data in L:
if view_data['view_name'] == ordered_name:
L.remove(view_data)
ordered.append(view_data)
return ordered + sorted(L, key=operator.itemgetter('title'))
def get_mgmt_views(request, context=None, names=None):
registry = request.registry
if context is None:
context = request.context
introspector = registry.introspector
L = []
# create a dummy request signaling our intent
req = Request(request.environ.copy())
req.script_name = request.script_name
req.context = context
req.matched_route = request.matched_route
req.method = 'GET'
req.registry = request.registry
for data in introspector.get_category('sdi views'):
related = data['related']
sdi_intr = data['introspectable']
tab_title = sdi_intr['tab_title']
tab_condition = sdi_intr['tab_condition']
if tab_condition is not None and names is None:
if tab_condition is False or not tab_condition(request):
continue
for intr in related:
view_name = intr['name']
if names is not None and not view_name in names:
continue
if intr.category_name == 'views' and not view_name in L:
derived = intr['derived_callable']
# do a passable job at figuring out whether, if we visit the
# url implied by this view, we'll be permitted to view it and
# something reasonable will show up
if IInterface.providedBy(intr['context']):
if not intr['context'].providedBy(context):
continue
elif intr['context'] and not isinstance(
context, intr['context']):
continue
req.path_info = request.mgmt_path(context, view_name)
if hasattr(derived, '__predicated__'):
if not derived.__predicated__(context, req):
continue
if hasattr(derived, '__permitted__'):
if not derived.__permitted__(context, req):
continue
L.append(
{'view_name':view_name,
'tab_title':tab_title or view_name.capitalize()}
)
ordered = []
if hasattr(context, '__tab_order__'):
tab_order = context.__tab_order__
ordered_names_available = [ y for y in tab_order if y in
[ x['view_name'] for x in L ] ]
for ordered_name in ordered_names_available:
for view_data in L:
if view_data['view_name'] == ordered_name:
L.remove(view_data)
ordered.append(view_data)
return ordered + sorted(L, key=operator.itemgetter('tab_title'))
def sdi_mgmt_views(context, request, names=None):
if not hasattr(context, '__name__'):
# shortcut if the context doesn't have a name (usually happens if the
# context is an exception); we do this because mgmt_path uses Pyramid's
# resource_path_tuple, which wants every object in the lineage to have
# a __name__.
return []
registry = request.registry
introspector = registry.introspector
unordered = []
# create a dummy request signaling our intent
req = Request(request.environ.copy())
req.script_name = request.script_name
req.context = context
req.matched_route = request.matched_route
req.method = 'GET'
req.registry = request.registry
for data in introspector.get_category('sdi views'):
related = data['related']
sdi_intr = data['introspectable']
tab_title = sdi_intr['tab_title']
tab_condition = sdi_intr['tab_condition']
tab_before = sdi_intr['tab_before']
tab_after = sdi_intr['tab_after']
def is_view(intr):
return intr.category_name == 'views'
for view_intr in filter(is_view, related):
# NB: in reality, the above loop will execute exactly once because
# each "sdi view" is associated with exactly one pyramid view
view_name = view_intr['name']
req.path_info = request.mgmt_path(context, view_name)
if names is not None and not view_name in names:
continue
# do a passable job at figuring out whether, if we visit the
# url implied by this view, we'll be permitted to view it and
# something reasonable will show up
intr_context = view_intr['context']
if IInterface.providedBy(intr_context):
if not intr_context.providedBy(context):
continue
elif intr_context and not isinstance(context, intr_context):
continue
if tab_condition is not None and names is None:
if callable(tab_condition):
if not tab_condition(context, request):
continue
elif not tab_condition:
continue
derived = view_intr['derived_callable']
if hasattr(derived, '__predicated__'):
if not derived.__predicated__(context, req):
continue
if hasattr(derived, '__permitted__'):
if not derived.__permitted__(context, req):
continue
if view_name == request.view_name:
css_class = 'active'
else:
css_class = None
unordered.append(
{'view_name': view_name,
'tab_before':tab_before,
'tab_after':tab_after,
'title': tab_title or view_name.capitalize(),
'class': css_class,
'url': request.mgmt_path(request.context, '@@%s' % view_name)
}
)
manually_ordered = []
tab_order = request.registry.content.metadata(context, 'tab_order')
if tab_order is not None:
ordered_names = [ y for y in tab_order if y in
[ x['view_name'] for x in unordered ] ]
for ordered_name in ordered_names:
for view_data in unordered[:]:
if view_data['view_name'] == ordered_name:
unordered.remove(view_data)
manually_ordered.append(view_data)
# first sort non-manually-ordered views lexically by title
lexically_ordered = sorted(unordered, key=operator.itemgetter('title'))
# then sort the lexically-presorted unordered views topologically based on
# any tab_before and tab_after values in the view data
tsorter = TopologicalSorter(default_before=MIDDLE, default_after=None)
tsorter.add(
MIDDLE,
None,
before=LAST,
after=FIRST,
)
for view_data in lexically_ordered:
before=view_data.get('tab_before', None)
after=view_data.get('tab_after', None)
tsorter.add(
view_data['view_name'],
view_data,
before=before,
after=after,
)
topo_ordered = [ x[1] for x in tsorter.sorted() if x[0] is not MIDDLE ]
return manually_ordered + topo_ordered
def sdi_mgmt_views(context, request, names=None):
if not hasattr(context, '__name__'):
# shortcut if the context doesn't have a name (usually happens if the
# context is an exception); we do this because mgmt_path uses Pyramid's
# resource_path_tuple, which wants every object in the lineage to have
# a __name__.
return []
registry = request.registry
introspector = registry.introspector
unordered = []
# create a dummy request signaling our intent
req = Request(request.environ.copy())
req.script_name = request.script_name
req.context = context
req.matched_route = request.matched_route
req.method = 'GET'
req.registry = request.registry
for data in introspector.get_category('sdi views'):
related = data['related']
sdi_intr = data['introspectable']
tab_title = sdi_intr['tab_title']
tab_condition = sdi_intr['tab_condition']
tab_before = sdi_intr['tab_before']
tab_after = sdi_intr['tab_after']
def is_view(intr):
return intr.category_name == 'views'
for view_intr in filter(is_view, related):
# NB: in reality, the above loop will execute exactly once because
# each "sdi view" is associated with exactly one pyramid view
view_name = view_intr['name']
req.path_info = request.mgmt_path(context, view_name)
if names is not None and not view_name in names:
continue
# do a passable job at figuring out whether, if we visit the
# url implied by this view, we'll be permitted to view it and
# something reasonable will show up
intr_context = view_intr['context']
if IInterface.providedBy(intr_context):
if not intr_context.providedBy(context):
continue
elif intr_context and not isinstance(context, intr_context):
continue
if tab_condition is not None and names is None:
if callable(tab_condition):
if not tab_condition(context, request):
continue
elif not tab_condition:
continue
derived = view_intr['derived_callable']
if hasattr(derived, '__predicated__'):
if not derived.__predicated__(context, req):
continue
if hasattr(derived, '__permitted__'):
if not derived.__permitted__(context, req):
continue
if view_name == request.view_name:
css_class = 'active'
else:
css_class = None
unordered.append({
'view_name':
view_name,
'tab_before':
tab_before,
'tab_after':
tab_after,
'title':
tab_title or view_name.capitalize(),
'class':
css_class,
'url':
request.mgmt_path(request.context, '@@%s' % view_name)
})
manually_ordered = []
tab_order = request.registry.content.metadata(context, 'tab_order')
if tab_order is not None:
ordered_names = [
y for y in tab_order if y in [x['view_name'] for x in unordered]
]
for ordered_name in ordered_names:
for view_data in unordered[:]:
if view_data['view_name'] == ordered_name:
unordered.remove(view_data)
manually_ordered.append(view_data)
# first sort non-manually-ordered views lexically by title
lexically_ordered = sorted(unordered, key=operator.itemgetter('title'))
# then sort the lexically-presorted unordered views topologically based on
# any tab_before and tab_after values in the view data
tsorter = TopologicalSorter(default_before=MIDDLE, default_after=None)
tsorter.add(
MIDDLE,
None,
before=LAST,
after=FIRST,
)
for view_data in lexically_ordered:
before = view_data.get('tab_before', None)
after = view_data.get('tab_after', None)
tsorter.add(
view_data['view_name'],
view_data,
before=before,
after=after,
)
topo_ordered = [x[1] for x in tsorter.sorted() if x[0] is not MIDDLE]
return manually_ordered + topo_ordered
