class InternalCitationLayer(InlineLayer):
shorthand = 'internal'
data_source = 'internal-citations'
def __init__(self, layer):
self.layer = layer
self.sectional = False
self.version = None
self.rev_urls = SectionUrl()
self.rendered = {}
def render_url(self,
label,
text,
template_name='regulations/layers/internal_citation.html'):
key = (tuple(label), text, template_name)
if key not in self.rendered:
url = self.rev_urls.fetch(label, self.version, self.sectional)
c = Context({
'citation': {
'url': url,
'label': text,
'label_id':
self.rev_urls.view_label_id(label, self.version)
}
})
template = loader.get_template(template_name)
self.rendered[key] = template.render(c).strip('\n')
return self.rendered[key]
def replacement_for(self, original, data):
return self.render_url(data['citation'], original)
class InternalCitationLayer():
shorthand = 'internal'
def __init__(self, layer):
self.layer = layer
self.sectional = False
self.version = None
self.rev_urls = SectionUrl()
self.rendered = {}
def render_url(
self, label, text,
template_name='regulations/layers/internal_citation.html'):
key = (tuple(label), text, template_name)
if key not in self.rendered:
url = self.rev_urls.fetch(label, self.version, self.sectional)
c = Context({'citation': {
'url': url, 'label': text,
'label_id': self.rev_urls.view_label_id(label, self.version)}})
template = loader.get_template(template_name)
self.rendered[key] = template.render(c).strip('\n')
return self.rendered[key]
def apply_layer(self, text, text_index):
if text_index in self.layer:
layer_elements = self.layer[text_index]
layer_pairs = []
for layer_element in layer_elements:
for start, end in layer_element['offsets']:
ot = text[int(start):int(end)]
rt = self.render_url(layer_element['citation'], ot)
layer_pairs.append((ot, rt, (start, end)))
return layer_pairs
class InternalCitationLayer(InlineLayer):
shorthand = 'internal'
data_source = 'internal-citations'
def __init__(self, layer):
self.layer = layer
self.sectional = False
self.version = None
self.rev_urls = SectionUrl()
self.rendered = {}
def render_url(self, label, text,
template_name='regulations/layers/internal_citation.html'):
key = (tuple(label), text, template_name)
if key not in self.rendered:
url = self.rev_urls.fetch(label, self.version, self.sectional)
c = Context({'citation': {
'url': url, 'label': text,
'label_id': self.rev_urls.view_label_id(label, self.version)}})
template = loader.get_template(template_name)
self.rendered[key] = template.render(c).strip('\n')
return self.rendered[key]
def replacement_for(self, original, data):
return self.render_url(data['citation'], original)
class DefinitionsLayer(InlineLayer):
shorthand = 'terms'
data_source = 'terms'
def __init__(self, layer):
self.layer = layer
self.template = loader.get_template(
'regulations/layers/definition_citation.html')
self.sectional = False
self.version = None
self.rev_urls = SectionUrl()
self.rendered = {}
# precomputation
for def_struct in self.layer['referenced'].values():
def_struct['reference_split'] = def_struct['reference'].split('-')
def replacement_for(self, original, data):
""" Create the link that takes you to the definition of the term. """
citation = data['ref']
# term = term w/o pluralization
term = self.layer['referenced'][citation]['term']
citation = self.layer['referenced'][citation]['reference_split']
key = (original, tuple(citation))
if key not in self.rendered:
context = {'citation': {
'url': self.rev_urls.fetch(citation, self.version,
self.sectional),
'label': original,
'term': term,
'definition_reference': '-'.join(to_markup_id(citation))}}
rendered = utils.render_template(self.template, context)
self.rendered[key] = rendered
return self.rendered[key]
class InternalCitationLayer():
shorthand = 'internal'
def __init__(self, layer):
self.layer = layer
self.sectional = False
self.version = None
self.rev_urls = SectionUrl()
self.rendered = {}
def render_url(
self, label, text,
template_name='regulations/layers/internal_citation.html'):
key = (tuple(label), text, template_name)
if key not in self.rendered:
url = self.rev_urls.fetch(label, self.version, self.sectional)
c = Context({'citation': {'url': url, 'label': text,
'label_id': self.rev_urls.view_label_id(label, self.version)}})
template = loader.get_template(template_name)
self.rendered[key] = template.render(c).strip('\n')
return self.rendered[key]
def apply_layer(self, text, text_index):
if text_index in self.layer:
layer_elements = self.layer[text_index]
layer_pairs = []
for layer_element in layer_elements:
for start, end in layer_element['offsets']:
ot = text[int(start):int(end)]
rt = self.render_url(layer_element['citation'], ot)
layer_pairs.append((ot, rt, (start, end)))
return layer_pairs
class TableOfContentsLayer(ParagraphLayer):
shorthand = 'toc'
data_source = 'toc'
def __init__(self, layer):
self.layer = layer
self.sectional = False
self.version = None
self.section_url = SectionUrl()
def attach_metadata(self, node):
text_index = node['label_id']
if text_index in self.layer:
layer_elements = self.layer[text_index]
toc_list = []
for data in layer_elements:
if 'Subpart' in data['index']:
toc_list.append(toc_subpart(data, toc_list, self.layer))
elif 'Interp' in data['index']:
toc_list.append(toc_interp(data, toc_list, self.layer))
else:
toc_list.append(toc_sect_appendix(data, toc_list))
for el in toc_list:
el['url'] = self.section_url.fetch(
el['index'], self.version, self.sectional)
for sub in el.get('sub_toc', []):
sub['url'] = self.section_url.fetch(
sub['index'], self.version, self.sectional)
node['TOC'] = toc_list
@staticmethod
def section(element, data):
title_data = title_parsing.section(data)
if title_data:
element.update(title_data)
@staticmethod
def appendix_supplement(element, data, seen_appendix=False):
as_data = title_parsing.appendix_supplement(data)
if as_data:
element.update(as_data)
if element.get('is_appendix'):
element['is_first_appendix'] = not seen_appendix
def get_context_data(self, **kwargs):
# We don't want to run the content data of PartialView -- it assumes
# we will be applying layers
context = super(PartialView, self).get_context_data(**kwargs)
context['q'] = self.request.GET.get('q')
context['version'] = self.request.GET.get('version')
context['regulation'] = context['label_id'].split('-')[0]
try:
page = int(self.request.GET.get('page', '0'))
except ValueError:
page = 0
api_page = page // (API_PAGE_SIZE / PAGE_SIZE)
context['warnings'] = []
if not context['q']:
context['warnings'].append('Please provide a query.')
if not context['version']:
context['warnings'].append('Please provide a version.')
if context['warnings']:
results = {'results': [], 'total_hits': 0}
else:
results = api_reader.ApiReader().search(context['q'],
context['version'],
context['regulation'],
api_page)
self.reduce_results(results, page)
section_url = SectionUrl()
for result in results['results']:
result['header'] = node_types.label_to_text(result['label'])
if 'title' in result:
result['header'] += ' ' + title(result['title'])
result['section_id'] = section_url.view_label_id(
result['label'], context['version'])
result['url'] = section_url.fetch(result['label'],
context['version'],
sectional=True)
context['results'] = results
for version in fetch_grouped_history(context['regulation']):
for notice in version['notices']:
if notice['document_number'] == context['version']:
context['version_by_date'] = notice['effective_on']
self.add_prev_next(page, context)
self.final_context = context
return context
def process_cfr_results(results, version):
"""Modify the results of a search over the CFR by adding a human-readable
label, appropriate links, and version information"""
section_url = SectionUrl()
results = deepcopy(results)
for result in results['results']:
add_cfr_headers(result)
result['section_id'] = section_url.view_label_id(
result['label'], version)
result['url'] = section_url.fetch(
result['label'], version, sectional=True)
return results
def process_cfr_results(results, version):
"""Modify the results of a search over the CFR by adding a human-readable
label, appropriate links, and version information"""
section_url = SectionUrl()
results = deepcopy(results)
for result in results["results"]:
result["header"] = node_types.label_to_text(result["label"])
if "title" in result:
result["header"] += " " + title(result["title"])
result["section_id"] = section_url.view_label_id(result["label"], version)
result["url"] = section_url.fetch(result["label"], version, sectional=True)
return results
class DefinitionsLayer(object):
shorthand = 'terms'
def __init__(self, layer):
self.layer = layer
self.template = loader.get_template(
'regulations/layers/definition_citation.html')
self.sectional = False
self.version = None
self.rev_urls = SectionUrl()
self.rendered = {}
# precomputation
for def_struct in self.layer['referenced'].values():
def_struct['reference_split'] = def_struct['reference'].split('-')
def create_definition_link(self, original_text, citation, term):
""" Create the link that takes you to the definition of the term. """
key = (original_text, tuple(citation))
if key not in self.rendered:
context = {
'citation': {
'url':
self.rev_urls.fetch(citation, self.version,
self.sectional),
'label':
original_text,
'term':
term,
'definition_reference':
'-'.join(to_markup_id(citation))
}
}
rendered = utils.render_template(self.template, context)
self.rendered[key] = rendered
return self.rendered[key]
def apply_layer(self, text, text_index):
"""Catch all terms which are defined elsewhere and replace them with
a link"""
layer_pairs = []
if text_index in self.layer:
layer_elements = self.layer[text_index]
for layer_element in layer_elements:
ref = layer_element['ref']
# term = term w/o pluralization
term = self.layer['referenced'][ref]['term']
ref = self.layer['referenced'][ref]['reference_split']
for start, end in layer_element['offsets']:
ot = text[start:end]
rt = self.create_definition_link(ot, ref, term)
layer_pairs.append((ot, rt, (start, end)))
return layer_pairs
def get_context_data(self, **kwargs):
# We don't want to run the content data of PartialView -- it assumes
# we will be applying layers
context = super(PartialView, self).get_context_data(**kwargs)
context['regulation'] = context['label_id'].split('-')[0]
try:
page = int(self.request.GET.get('page', '0'))
except ValueError:
page = 0
# API page size is API_PAGE_SIZE, but we show only PAGE_SIZE
api_page = page // (API_PAGE_SIZE / PAGE_SIZE)
page_idx = (page % (API_PAGE_SIZE / PAGE_SIZE)) * PAGE_SIZE
results = api_reader.ApiReader().search(context['q'],
context['version'],
context['regulation'],
api_page)
# Ignore results found in the root (i.e. not a section), adjust
# the number of results accordingly.
original_count = len(results['results'])
results['results'] = [
r for r in results['results'] if len(r['label']) > 1
]
num_results_ignored = original_count - len(results['results'])
results['total_hits'] -= num_results_ignored
results['results'] = results['results'][page_idx:page_idx + PAGE_SIZE]
section_url = SectionUrl()
for result in results['results']:
result['header'] = label_to_text(result['label'])
if 'title' in result:
result['header'] += ' ' + title(result['title'])
result['section_id'] = section_url.view_label_id(
result['label'], context['version'])
result['url'] = section_url.fetch(result['label'],
context['version'],
sectional=True)
context['results'] = results
for version in fetch_grouped_history(context['regulation']):
for notice in version['notices']:
if notice['document_number'] == context['version']:
context['version_by_date'] = notice['effective_on']
self.add_prev_next(page, context)
self.final_context = context
return context
def get_context_data(self, **kwargs):
# We don't want to run the content data of PartialView -- it assumes
# we will be applying layers
context = super(PartialView, self).get_context_data(**kwargs)
context['q'] = self.request.GET.get('q')
context['version'] = self.request.GET.get('version')
context['regulation'] = context['label_id'].split('-')[0]
try:
page = int(self.request.GET.get('page', '0'))
except ValueError:
page = 0
api_page = page // (API_PAGE_SIZE / PAGE_SIZE)
context['warnings'] = []
if not context['q']:
context['warnings'].append('Please provide a query.')
if not context['version']:
context['warnings'].append('Please provide a version.')
if context['warnings']:
results = {'results': [], 'total_hits': 0}
else:
results = api_reader.ApiReader().search(
context['q'], context['version'], context['regulation'],
api_page)
self.reduce_results(results, page)
section_url = SectionUrl()
for result in results['results']:
result['header'] = node_types.label_to_text(result['label'])
if 'title' in result:
result['header'] += ' ' + title(result['title'])
result['section_id'] = section_url.view_label_id(
result['label'], context['version'])
result['url'] = section_url.fetch(
result['label'], context['version'], sectional=True)
context['results'] = results
for version in fetch_grouped_history(context['regulation']):
for notice in version['notices']:
if notice['document_number'] == context['version']:
context['version_by_date'] = notice['effective_on']
self.add_prev_next(page, context)
self.final_context = context
return context
def process_cfr_results(results, version):
"""Modify the results of a search over the CFR by adding a human-readable
label, appropriate links, and version information"""
section_url = SectionUrl()
results = deepcopy(results)
for result in results['results']:
add_cfr_headers(result)
result['section_id'] = section_url.view_label_id(
result['label'], version)
result['url'] = section_url.fetch(result['label'],
version,
sectional=True)
return results
def process_cfr_results(results, version):
"""Modify the results of a search over the CFR by adding a human-readable
label, appropriate links, and version information"""
section_url = SectionUrl()
results = deepcopy(results)
for result in results['results']:
result['header'] = node_types.label_to_text(result['label'])
if 'title' in result:
result['header'] += ' ' + title(result['title'])
result['section_id'] = section_url.view_label_id(
result['label'], version)
result['url'] = section_url.fetch(result['label'],
version,
sectional=True)
return results
class DefinitionsLayer(object):
shorthand = "terms"
def __init__(self, layer):
self.layer = layer
self.template = loader.get_template("regulations/layers/definition_citation.html")
self.sectional = False
self.version = None
self.rev_urls = SectionUrl()
self.rendered = {}
# precomputation
for def_struct in self.layer["referenced"].values():
def_struct["reference_split"] = def_struct["reference"].split("-")
def create_definition_link(self, original_text, citation, term):
""" Create the link that takes you to the definition of the term. """
key = (original_text, tuple(citation))
if key not in self.rendered:
context = {
"citation": {
"url": self.rev_urls.fetch(citation, self.version, self.sectional),
"label": original_text,
"term": term,
"definition_reference": "-".join(to_markup_id(citation)),
}
}
rendered = utils.render_template(self.template, context)
self.rendered[key] = rendered
return self.rendered[key]
def apply_layer(self, text, text_index):
"""Catch all terms which are defined elsewhere and replace them with
a link"""
layer_pairs = []
if text_index in self.layer:
layer_elements = self.layer[text_index]
for layer_element in layer_elements:
ref = layer_element["ref"]
# term = term w/o pluralization
term = self.layer["referenced"][ref]["term"]
ref = self.layer["referenced"][ref]["reference_split"]
for start, end in layer_element["offsets"]:
ot = text[start:end]
rt = self.create_definition_link(ot, ref, term)
layer_pairs.append((ot, rt, (start, end)))
return layer_pairs
class DefinitionsLayer(object):
shorthand = 'terms'
def __init__(self, layer):
self.layer = layer
self.template = loader.get_template(
'regulations/layers/definition_citation.html')
self.sectional = False
self.version = None
self.rev_urls = SectionUrl()
self.rendered = {}
# precomputation
for def_struct in self.layer['referenced'].values():
def_struct['reference_split'] = def_struct['reference'].split('-')
def create_definition_link(self, original_text, citation, term):
""" Create the link that takes you to the definition of the term. """
key = (original_text, tuple(citation))
if key not in self.rendered:
context = {
'citation': {
'url': self.rev_urls.fetch(citation, self.version,
self.sectional),
'label': original_text,
'term': term,
'definition_reference': '-'.join(to_markup_id(citation))}}
rendered = utils.render_template(self.template, context)
self.rendered[key] = rendered
return self.rendered[key]
def apply_layer(self, text, text_index):
"""Catch all terms which are defined elsewhere and replace them with
a link"""
layer_pairs = []
if text_index in self.layer:
layer_elements = self.layer[text_index]
for layer_element in layer_elements:
ref = layer_element['ref']
# term = term w/o pluralization
term = self.layer['referenced'][ref]['term']
ref = self.layer['referenced'][ref]['reference_split']
for start, end in layer_element['offsets']:
ot = text[start:end]
rt = self.create_definition_link(ot, ref, term)
layer_pairs.append((ot, rt, (start, end)))
return layer_pairs
class DefinitionsLayer(InlineLayer):
shorthand = 'terms'
data_source = 'terms'
def __init__(self, layer):
self.layer = layer
self.template = loader.get_template(
'regulations/layers/definition_citation.html')
self.sectional = False
self.version = None
self.rev_urls = SectionUrl()
self.rendered = {}
# precomputation
for def_struct in self.layer['referenced'].values():
def_struct['reference_split'] = def_struct['reference'].split('-')
def replacement_for(self, original, data):
""" Create the link that takes you to the definition of the term. """
citation = data['ref']
# term = term w/o pluralization
term = self.layer['referenced'][citation]['term']
citation = self.layer['referenced'][citation]['reference_split']
key = (original, tuple(citation))
if key not in self.rendered:
context = {
'citation': {
'url':
self.rev_urls.fetch(citation, self.version,
self.sectional),
'label':
original,
'term':
term,
'definition_reference':
'-'.join(to_markup_id(citation))
}
}
rendered = utils.render_template(self.template, context)
self.rendered[key] = rendered
return self.rendered[key]
