prompt
large_stringlengths 72
9.34k
| completion
large_stringlengths 0
7.61k
|
|---|---|
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
# -- Content-Encoding: UTF-8 --
"""
Utility methods, for compatibility between Python version
:author: Thomas Calmant
:copyright: Copyright 2017, Thomas Calmant
:license: Apache License 2.0
:version: 0.3.1
..
Copyright 2017 Thomas Calmant
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
import sys
# ------------------------------------------------------------------------------
# Module version
__version_info__ = (0, 3, 1)
__version__ = ".".join(str(x) for x in __version_info__)
# Documentation strings format
__docformat__ = "restructuredtext en"
# ------------------------------------------------------------------------------
if sys.version_info[0] < 3:
# Python 2
# pylint: disable=E1101
import types
try:
STRING_TYPES = (
types.StringType,
types.UnicodeType
)
except NameError:
# Python built without unicode support
STRING_TYPES = (types.StringType,)
NUMERIC_TYPES = (
types.IntType,
types.LongType,
types.FloatType
)
def to_bytes(string):
"""
Converts the given string into bytes
"""
# pylint: disable=E0602
if type(string) is unicode:
return str(string)
return string
def <|fim_middle|>(data):
"""
Converts the given bytes into a string
"""
if type(data) is str:
return data
return str(data)
else:
# Python 3
# pylint: disable=E1101
STRING_TYPES = (
bytes,
str
)
NUMERIC_TYPES = (
int,
float
)
def to_bytes(string):
"""
Converts the given string into bytes
"""
if type(string) is bytes:
return string
return bytes(string, "UTF-8")
def from_bytes(data):
"""
Converts the given bytes into a string
"""
if type(data) is str:
return data
return str(data, "UTF-8")
# ------------------------------------------------------------------------------
# Enumerations
try:
import enum
def is_enum(obj):
"""
Checks if an object is from an enumeration class
:param obj: Object to test
:return: True if the object is an enumeration item
"""
return isinstance(obj, enum.Enum)
except ImportError:
# Pre-Python 3.4
def is_enum(_):
"""
Before Python 3.4, enumerations didn't exist.
:param _: Object to test
:return: Always False
"""
return False
# ------------------------------------------------------------------------------
# Common
DictType = dict
ListType = list
TupleType = tuple
ITERABLE_TYPES = (
list,
set, frozenset,
tuple
)
VALUE_TYPES = (
bool,
type(None)
)
PRIMITIVE_TYPES = STRING_TYPES + NUMERIC_TYPES + VALUE_TYPES
<｜fim▁end｜> | from_bytes |
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
# -- Content-Encoding: UTF-8 --
"""
Utility methods, for compatibility between Python version
:author: Thomas Calmant
:copyright: Copyright 2017, Thomas Calmant
:license: Apache License 2.0
:version: 0.3.1
..
Copyright 2017 Thomas Calmant
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
import sys
# ------------------------------------------------------------------------------
# Module version
__version_info__ = (0, 3, 1)
__version__ = ".".join(str(x) for x in __version_info__)
# Documentation strings format
__docformat__ = "restructuredtext en"
# ------------------------------------------------------------------------------
if sys.version_info[0] < 3:
# Python 2
# pylint: disable=E1101
import types
try:
STRING_TYPES = (
types.StringType,
types.UnicodeType
)
except NameError:
# Python built without unicode support
STRING_TYPES = (types.StringType,)
NUMERIC_TYPES = (
types.IntType,
types.LongType,
types.FloatType
)
def to_bytes(string):
"""
Converts the given string into bytes
"""
# pylint: disable=E0602
if type(string) is unicode:
return str(string)
return string
def from_bytes(data):
"""
Converts the given bytes into a string
"""
if type(data) is str:
return data
return str(data)
else:
# Python 3
# pylint: disable=E1101
STRING_TYPES = (
bytes,
str
)
NUMERIC_TYPES = (
int,
float
)
def <|fim_middle|>(string):
"""
Converts the given string into bytes
"""
if type(string) is bytes:
return string
return bytes(string, "UTF-8")
def from_bytes(data):
"""
Converts the given bytes into a string
"""
if type(data) is str:
return data
return str(data, "UTF-8")
# ------------------------------------------------------------------------------
# Enumerations
try:
import enum
def is_enum(obj):
"""
Checks if an object is from an enumeration class
:param obj: Object to test
:return: True if the object is an enumeration item
"""
return isinstance(obj, enum.Enum)
except ImportError:
# Pre-Python 3.4
def is_enum(_):
"""
Before Python 3.4, enumerations didn't exist.
:param _: Object to test
:return: Always False
"""
return False
# ------------------------------------------------------------------------------
# Common
DictType = dict
ListType = list
TupleType = tuple
ITERABLE_TYPES = (
list,
set, frozenset,
tuple
)
VALUE_TYPES = (
bool,
type(None)
)
PRIMITIVE_TYPES = STRING_TYPES + NUMERIC_TYPES + VALUE_TYPES
<｜fim▁end｜> | to_bytes |
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
# -- Content-Encoding: UTF-8 --
"""
Utility methods, for compatibility between Python version
:author: Thomas Calmant
:copyright: Copyright 2017, Thomas Calmant
:license: Apache License 2.0
:version: 0.3.1
..
Copyright 2017 Thomas Calmant
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
import sys
# ------------------------------------------------------------------------------
# Module version
__version_info__ = (0, 3, 1)
__version__ = ".".join(str(x) for x in __version_info__)
# Documentation strings format
__docformat__ = "restructuredtext en"
# ------------------------------------------------------------------------------
if sys.version_info[0] < 3:
# Python 2
# pylint: disable=E1101
import types
try:
STRING_TYPES = (
types.StringType,
types.UnicodeType
)
except NameError:
# Python built without unicode support
STRING_TYPES = (types.StringType,)
NUMERIC_TYPES = (
types.IntType,
types.LongType,
types.FloatType
)
def to_bytes(string):
"""
Converts the given string into bytes
"""
# pylint: disable=E0602
if type(string) is unicode:
return str(string)
return string
def from_bytes(data):
"""
Converts the given bytes into a string
"""
if type(data) is str:
return data
return str(data)
else:
# Python 3
# pylint: disable=E1101
STRING_TYPES = (
bytes,
str
)
NUMERIC_TYPES = (
int,
float
)
def to_bytes(string):
"""
Converts the given string into bytes
"""
if type(string) is bytes:
return string
return bytes(string, "UTF-8")
def <|fim_middle|>(data):
"""
Converts the given bytes into a string
"""
if type(data) is str:
return data
return str(data, "UTF-8")
# ------------------------------------------------------------------------------
# Enumerations
try:
import enum
def is_enum(obj):
"""
Checks if an object is from an enumeration class
:param obj: Object to test
:return: True if the object is an enumeration item
"""
return isinstance(obj, enum.Enum)
except ImportError:
# Pre-Python 3.4
def is_enum(_):
"""
Before Python 3.4, enumerations didn't exist.
:param _: Object to test
:return: Always False
"""
return False
# ------------------------------------------------------------------------------
# Common
DictType = dict
ListType = list
TupleType = tuple
ITERABLE_TYPES = (
list,
set, frozenset,
tuple
)
VALUE_TYPES = (
bool,
type(None)
)
PRIMITIVE_TYPES = STRING_TYPES + NUMERIC_TYPES + VALUE_TYPES
<｜fim▁end｜> | from_bytes |
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
# -- Content-Encoding: UTF-8 --
"""
Utility methods, for compatibility between Python version
:author: Thomas Calmant
:copyright: Copyright 2017, Thomas Calmant
:license: Apache License 2.0
:version: 0.3.1
..
Copyright 2017 Thomas Calmant
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
import sys
# ------------------------------------------------------------------------------
# Module version
__version_info__ = (0, 3, 1)
__version__ = ".".join(str(x) for x in __version_info__)
# Documentation strings format
__docformat__ = "restructuredtext en"
# ------------------------------------------------------------------------------
if sys.version_info[0] < 3:
# Python 2
# pylint: disable=E1101
import types
try:
STRING_TYPES = (
types.StringType,
types.UnicodeType
)
except NameError:
# Python built without unicode support
STRING_TYPES = (types.StringType,)
NUMERIC_TYPES = (
types.IntType,
types.LongType,
types.FloatType
)
def to_bytes(string):
"""
Converts the given string into bytes
"""
# pylint: disable=E0602
if type(string) is unicode:
return str(string)
return string
def from_bytes(data):
"""
Converts the given bytes into a string
"""
if type(data) is str:
return data
return str(data)
else:
# Python 3
# pylint: disable=E1101
STRING_TYPES = (
bytes,
str
)
NUMERIC_TYPES = (
int,
float
)
def to_bytes(string):
"""
Converts the given string into bytes
"""
if type(string) is bytes:
return string
return bytes(string, "UTF-8")
def from_bytes(data):
"""
Converts the given bytes into a string
"""
if type(data) is str:
return data
return str(data, "UTF-8")
# ------------------------------------------------------------------------------
# Enumerations
try:
import enum
def <|fim_middle|>(obj):
"""
Checks if an object is from an enumeration class
:param obj: Object to test
:return: True if the object is an enumeration item
"""
return isinstance(obj, enum.Enum)
except ImportError:
# Pre-Python 3.4
def is_enum(_):
"""
Before Python 3.4, enumerations didn't exist.
:param _: Object to test
:return: Always False
"""
return False
# ------------------------------------------------------------------------------
# Common
DictType = dict
ListType = list
TupleType = tuple
ITERABLE_TYPES = (
list,
set, frozenset,
tuple
)
VALUE_TYPES = (
bool,
type(None)
)
PRIMITIVE_TYPES = STRING_TYPES + NUMERIC_TYPES + VALUE_TYPES
<｜fim▁end｜> | is_enum |
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜>#!/usr/bin/python
# -- Content-Encoding: UTF-8 --
"""
Utility methods, for compatibility between Python version
:author: Thomas Calmant
:copyright: Copyright 2017, Thomas Calmant
:license: Apache License 2.0
:version: 0.3.1
..
Copyright 2017 Thomas Calmant
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
import sys
# ------------------------------------------------------------------------------
# Module version
__version_info__ = (0, 3, 1)
__version__ = ".".join(str(x) for x in __version_info__)
# Documentation strings format
__docformat__ = "restructuredtext en"
# ------------------------------------------------------------------------------
if sys.version_info[0] < 3:
# Python 2
# pylint: disable=E1101
import types
try:
STRING_TYPES = (
types.StringType,
types.UnicodeType
)
except NameError:
# Python built without unicode support
STRING_TYPES = (types.StringType,)
NUMERIC_TYPES = (
types.IntType,
types.LongType,
types.FloatType
)
def to_bytes(string):
"""
Converts the given string into bytes
"""
# pylint: disable=E0602
if type(string) is unicode:
return str(string)
return string
def from_bytes(data):
"""
Converts the given bytes into a string
"""
if type(data) is str:
return data
return str(data)
else:
# Python 3
# pylint: disable=E1101
STRING_TYPES = (
bytes,
str
)
NUMERIC_TYPES = (
int,
float
)
def to_bytes(string):
"""
Converts the given string into bytes
"""
if type(string) is bytes:
return string
return bytes(string, "UTF-8")
def from_bytes(data):
"""
Converts the given bytes into a string
"""
if type(data) is str:
return data
return str(data, "UTF-8")
# ------------------------------------------------------------------------------
# Enumerations
try:
import enum
def is_enum(obj):
"""
Checks if an object is from an enumeration class
:param obj: Object to test
:return: True if the object is an enumeration item
"""
return isinstance(obj, enum.Enum)
except ImportError:
# Pre-Python 3.4
def <|fim_middle|>(_):
"""
Before Python 3.4, enumerations didn't exist.
:param _: Object to test
:return: Always False
"""
return False
# ------------------------------------------------------------------------------
# Common
DictType = dict
ListType = list
TupleType = tuple
ITERABLE_TYPES = (
list,
set, frozenset,
tuple
)
VALUE_TYPES = (
bool,
type(None)
)
PRIMITIVE_TYPES = STRING_TYPES + NUMERIC_TYPES + VALUE_TYPES
<｜fim▁end｜> | is_enum |
<|file_name|>BuildAndRun.py<|end_file_name|><｜fim▁begin｜>macimport os
import subprocess
name = "gobuildmaster"
current_hash = ""
for line in os.popen("md5sum " + name).readlines():
current_hash = line.split(' ')[0]
# Move the old version over
for line in os.popen('cp ' + name + ' old' + name).readlines():
print line.strip()
# Rebuild
for line in os.popen('go build').readlines():
print line.strip()
size_1 = os.path.getsize('./old' + name)
size_2 = os.path.getsize('./' + name)
lines = os.popen('ps -ef | grep ' + name).readlines()
running = False
for line in lines:
if "./" + name in line:
running = True
new_hash = ""
for line in os.popen("md5sum " + name).readlines():
new_hash = line.split(' ')[0]
if size_1 != size_2 or new_hash != current_hash or not running:
if not running:
for line in os.popen('cat out.txt | mail -E -s "Crash Report ' + name + '" [email protected]').readlines():<｜fim▁hole｜> pass
subprocess.Popen(['./' + name])<｜fim▁end｜> | pass
for line in os.popen('echo "" > out.txt').readlines():
pass
for line in os.popen('killall ' + name).readlines(): |
<|file_name|>BuildAndRun.py<|end_file_name|><｜fim▁begin｜>macimport os
import subprocess
name = "gobuildmaster"
current_hash = ""
for line in os.popen("md5sum " + name).readlines():
current_hash = line.split(' ')[0]
# Move the old version over
for line in os.popen('cp ' + name + ' old' + name).readlines():
print line.strip()
# Rebuild
for line in os.popen('go build').readlines():
print line.strip()
size_1 = os.path.getsize('./old' + name)
size_2 = os.path.getsize('./' + name)
lines = os.popen('ps -ef | grep ' + name).readlines()
running = False
for line in lines:
if "./" + name in line:
<|fim_middle|>
new_hash = ""
for line in os.popen("md5sum " + name).readlines():
new_hash = line.split(' ')[0]
if size_1 != size_2 or new_hash != current_hash or not running:
if not running:
for line in os.popen('cat out.txt | mail -E -s "Crash Report ' + name + '" [email protected]').readlines():
pass
for line in os.popen('echo "" > out.txt').readlines():
pass
for line in os.popen('killall ' + name).readlines():
pass
subprocess.Popen(['./' + name])
<｜fim▁end｜> | running = True |
<|file_name|>BuildAndRun.py<|end_file_name|><｜fim▁begin｜>macimport os
import subprocess
name = "gobuildmaster"
current_hash = ""
for line in os.popen("md5sum " + name).readlines():
current_hash = line.split(' ')[0]
# Move the old version over
for line in os.popen('cp ' + name + ' old' + name).readlines():
print line.strip()
# Rebuild
for line in os.popen('go build').readlines():
print line.strip()
size_1 = os.path.getsize('./old' + name)
size_2 = os.path.getsize('./' + name)
lines = os.popen('ps -ef | grep ' + name).readlines()
running = False
for line in lines:
if "./" + name in line:
running = True
new_hash = ""
for line in os.popen("md5sum " + name).readlines():
new_hash = line.split(' ')[0]
if size_1 != size_2 or new_hash != current_hash or not running:
<|fim_middle|>
<｜fim▁end｜> | if not running:
for line in os.popen('cat out.txt | mail -E -s "Crash Report ' + name + '" [email protected]').readlines():
pass
for line in os.popen('echo "" > out.txt').readlines():
pass
for line in os.popen('killall ' + name).readlines():
pass
subprocess.Popen(['./' + name]) |
<|file_name|>BuildAndRun.py<|end_file_name|><｜fim▁begin｜>macimport os
import subprocess
name = "gobuildmaster"
current_hash = ""
for line in os.popen("md5sum " + name).readlines():
current_hash = line.split(' ')[0]
# Move the old version over
for line in os.popen('cp ' + name + ' old' + name).readlines():
print line.strip()
# Rebuild
for line in os.popen('go build').readlines():
print line.strip()
size_1 = os.path.getsize('./old' + name)
size_2 = os.path.getsize('./' + name)
lines = os.popen('ps -ef | grep ' + name).readlines()
running = False
for line in lines:
if "./" + name in line:
running = True
new_hash = ""
for line in os.popen("md5sum " + name).readlines():
new_hash = line.split(' ')[0]
if size_1 != size_2 or new_hash != current_hash or not running:
if not running:
<|fim_middle|>
for line in os.popen('echo "" > out.txt').readlines():
pass
for line in os.popen('killall ' + name).readlines():
pass
subprocess.Popen(['./' + name])
<｜fim▁end｜> | for line in os.popen('cat out.txt | mail -E -s "Crash Report ' + name + '" [email protected]').readlines():
pass |
<|file_name|>__init__.py<|end_file_name|><｜fim▁begin｜>"""
Copyright (c) 2012-2016 Ben Croston
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:<｜fim▁hole｜>
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
"""
from RPi._GPIO import *
VERSION = '0.6.3'<｜fim▁end｜> | |
<|file_name|>test_artificial_128_None_LinearTrend_12__20.py<|end_file_name|><｜fim▁begin｜>import pyaf.Bench.TS_datasets as tsds
import tests.artificial.process_artificial_dataset as art
<｜fim▁hole｜><｜fim▁end｜> | art.process_dataset(N = 128 , FREQ = 'D', seed = 0, trendtype = "LinearTrend", cycle_length = 12, transform = "None", sigma = 0.0, exog_count = 20, ar_order = 0); |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)<｜fim▁hole｜> template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)<｜fim▁end｜> | |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
<|fim_middle|>
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | return models.name_to_url(value) |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
<|fim_middle|>
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return '' |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
<|fim_middle|>
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
<|fim_middle|>
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return '' |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
<|fim_middle|>
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | """
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return '' |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
<|fim_middle|>
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0) |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
<|fim_middle|>
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | """ Override this to return content to be included. """
return None |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
<|fim_middle|>
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | """ Override this to return a title or None to omit it. """
return self.name |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
<|fim_middle|>
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return '' |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
<|fim_middle|>
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
<|fim_middle|>
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
<|fim_middle|>
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name)) |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
<|fim_middle|>
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug]) |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
<|fim_middle|>
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
<|fim_middle|>
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | """
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins) |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
<|fim_middle|>
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | """
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False) |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
<|fim_middle|>
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | return IncludePageNode(parser, token) |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
<|fim_middle|>
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | return text[0] == text[-1] and text[0] in ('"', "'") |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
<|fim_middle|>
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist) |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
<|fim_middle|>
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query)) |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
<|fim_middle|>
<｜fim▁end｜> | try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist) |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
<|fim_middle|>
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | raise |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
<|fim_middle|>
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0]) |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
<|fim_middle|>
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | b = unescape_string_literal(b) |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
<|fim_middle|>
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
<|fim_middle|>
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | template_text += '<h2>%s</h2>' % title |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
<|fim_middle|>
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | raise |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
<|fim_middle|>
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | return None |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
<|fim_middle|>
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | slug = self.page.pretty_slug |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
<|fim_middle|>
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | slug = name_to_url(self.name) |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
<|fim_middle|>
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name)) |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
<|fim_middle|>
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name)) |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
<|fim_middle|>
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0]) |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
<|fim_middle|>
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0]) |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def <|fim_middle|>(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | name_to_url |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def <|fim_middle|>(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | __init__ |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def <|fim_middle|>(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | render |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def <|fim_middle|>(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | __init__ |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def <|fim_middle|>(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | get_content |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def <|fim_middle|>(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | get_title |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def <|fim_middle|>(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | render |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def <|fim_middle|>(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | __init__ |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def <|fim_middle|>(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | get_title |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def <|fim_middle|>(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | get_page_url |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def <|fim_middle|>(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | get_content |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def <|fim_middle|>(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | do_render_plugins |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def <|fim_middle|>(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | do_render_tags |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def <|fim_middle|>(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | do_include_page |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def <|fim_middle|>(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | is_quoted |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def <|fim_middle|>(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | do_embed_code |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def <|fim_middle|>(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def do_link(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | do_searchbox |
<|file_name|>pages_tags.py<|end_file_name|><｜fim▁begin｜>from django import template
from django.template.loader_tags import BaseIncludeNode
from django.template import Template
from django.conf import settings
from pages.plugins import html_to_template_text, SearchBoxNode
from pages.plugins import LinkNode, EmbedCodeNode
from pages import models
from django.utils.text import unescape_string_literal
from pages.models import Page, slugify
from django.core.urlresolvers import reverse
register = template.Library()
@register.filter
def name_to_url(value):
return models.name_to_url(value)
name_to_url.is_safe = True
class PageContentNode(BaseIncludeNode):
def __init__(self, html_var, render_plugins=True, *args, **kwargs):
super(PageContentNode, self).__init__(*args, **kwargs)
self.html_var = template.Variable(html_var)
self.render_plugins = render_plugins
def render(self, context):
try:
html = unicode(self.html_var.resolve(context))
t = Template(html_to_template_text(html, context,
self.render_plugins))
return self.render_template(t, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludeContentNode(BaseIncludeNode):
"""
Base class for including some named content inside a other content.
Subclass and override get_content() and get_title() to return HTML or None.
The name of the content to include is stored in self.name
All other parameters are stored in self.args, without quotes (if any).
"""
def __init__(self, parser, token, *args, **kwargs):
super(IncludeContentNode, self).__init__(*args, **kwargs)
bits = token.split_contents()
if len(bits) < 2:
raise template.TemplateSyntaxError, ('%r tag requires at least one'
' argument' % token.contents.split()[0])
self.args = []
for b in bits[1:]:
if is_quoted(b):
b = unescape_string_literal(b)
self.args.append(b)
self.name = self.args.pop(0)
def get_content(self, context):
""" Override this to return content to be included. """
return None
def get_title(self, context):
""" Override this to return a title or None to omit it. """
return self.name
def render(self, context):
try:
template_text = ''
if 'showtitle' in self.args:
title = self.get_title(context)
if title:
template_text += '<h2>%s</h2>' % title
template_text += self.get_content(context)
template = Template(template_text)
return self.render_template(template, context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
class IncludePageNode(IncludeContentNode):
def __init__(self, *args, **kwargs):
super(IncludePageNode, self).__init__(*args, **kwargs)
try:
self.page = Page.objects.get(slug__exact=slugify(self.name))
except Page.DoesNotExist:
self.page = None
def get_title(self, context):
if not self.page:
return None
return ('<a href="%s">%s</a>'
% (self.get_page_url(), self.page.name))
def get_page_url(self):
if self.page:
slug = self.page.pretty_slug
else:
slug = name_to_url(self.name)
return reverse('pages:show', args=[slug])
def get_content(self, context):
if not self.page:
return ('<p class="plugin includepage">Unable to include '
'<a href="%s" class="missing_link">%s</a></p>'
% (self.get_page_url(), self.name))
# prevent endless loops
context_page = context['page']
include_stack = context.get('_include_stack', [])
include_stack.append(context_page.name)
if self.page.name in include_stack:
return ('<p class="plugin includepage">Unable to'
' include <a href="%s">%s</a>: endless include'
' loop.</p>' % (self.get_page_url(),
self.page.name))
context['_include_stack'] = include_stack
context['page'] = self.page
template_text = html_to_template_text(self.page.content, context)
# restore context
context['_include_stack'].pop()
context['page'] = context_page
return template_text
@register.tag(name='render_plugins')
def do_render_plugins(parser, token, render_plugins=True):
"""
Render tags and plugins
"""
try:
tag, html_var = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError, ("%r tag requires one argument" %
token.contents.split()[0])
return PageContentNode(html_var, render_plugins)
@register.tag(name='render_tags')
def do_render_tags(parser, token):
"""
Render tags only, does not render plugins
"""
return do_render_plugins(parser, token, render_plugins=False)
@register.tag(name='include_page')
def do_include_page(parser, token):
return IncludePageNode(parser, token)
def is_quoted(text):
return text[0] == text[-1] and text[0] in ('"', "'")
@register.tag(name='embed_code')
def do_embed_code(parser, token):
nodelist = parser.parse(('endembed_code',))
parser.delete_first_token()
return EmbedCodeNode(nodelist)
@register.tag(name='searchbox')
def do_searchbox(parser, token):
try:
tag, query = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError('%r tag requires one argument' %
token.contents.split()[0])
if not is_quoted(query):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
return SearchBoxNode(query=unescape_string_literal(query))
@register.tag(name='link')
def <|fim_middle|>(parser, token):
try:
tag, href = token.split_contents()
except ValueError:
raise template.TemplateSyntaxError("%r tag requires one argument" %
token.contents.split()[0])
if not is_quoted(href):
raise template.TemplateSyntaxError(
"%r tag's argument should be in quotes" %
token.contents.split()[0])
nodelist = parser.parse(('endlink',))
parser.delete_first_token()
return LinkNode(unescape_string_literal(href), nodelist)
<｜fim▁end｜> | do_link |
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def peek(self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r = None
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def get(self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def put(self, b):
self.write(chr(b))
return
<｜fim▁hole｜> return
# Set buffered contents
def setvalue(self, s):
self.erase()
self.write(s)
return
def hasMore(I):
return (I.peek() != None)
def enc8(x):
if (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
return x
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
if len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | # Erase buffered contents
def erase(self):
self.truncate(0)
self.seek(0, 0) |
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
d<|fim_middle|>
def hasMore(I):
return (I.peek() != None)
def enc8(x):
if (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
return x
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
if len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | ef peek(self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r = None
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def get(self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def put(self, b):
self.write(chr(b))
return
# Erase buffered contents
def erase(self):
self.truncate(0)
self.seek(0, 0)
return
# Set buffered contents
def setvalue(self, s):
self.erase()
self.write(s)
return
|
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def peek(self):
o<|fim_middle|>
# Pop a single byte (as integer representation)
def get(self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def put(self, b):
self.write(chr(b))
return
# Erase buffered contents
def erase(self):
self.truncate(0)
self.seek(0, 0)
return
# Set buffered contents
def setvalue(self, s):
self.erase()
self.write(s)
return
def hasMore(I):
return (I.peek() != None)
def enc8(x):
if (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
return x
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
if len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | ldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r = None
self.seek(oldPos, 0)
return r
|
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def peek(self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r = None
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def get(self):
r<|fim_middle|>
# Push a single byte (as integer representation)
def put(self, b):
self.write(chr(b))
return
# Erase buffered contents
def erase(self):
self.truncate(0)
self.seek(0, 0)
return
# Set buffered contents
def setvalue(self, s):
self.erase()
self.write(s)
return
def hasMore(I):
return (I.peek() != None)
def enc8(x):
if (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
return x
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
if len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | eturn ord(self.read(1))
|
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def peek(self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r = None
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def get(self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def put(self, b):
s<|fim_middle|>
# Erase buffered contents
def erase(self):
self.truncate(0)
self.seek(0, 0)
return
# Set buffered contents
def setvalue(self, s):
self.erase()
self.write(s)
return
def hasMore(I):
return (I.peek() != None)
def enc8(x):
if (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
return x
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
if len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | elf.write(chr(b))
return
|
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def peek(self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r = None
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def get(self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def put(self, b):
self.write(chr(b))
return
# Erase buffered contents
def erase(self):
s<|fim_middle|>
# Set buffered contents
def setvalue(self, s):
self.erase()
self.write(s)
return
def hasMore(I):
return (I.peek() != None)
def enc8(x):
if (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
return x
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
if len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | elf.truncate(0)
self.seek(0, 0)
return
|
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def peek(self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r = None
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def get(self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def put(self, b):
self.write(chr(b))
return
# Erase buffered contents
def erase(self):
self.truncate(0)
self.seek(0, 0)
return
# Set buffered contents
def setvalue(self, s):
s<|fim_middle|>
def hasMore(I):
return (I.peek() != None)
def enc8(x):
if (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
return x
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
if len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | elf.erase()
self.write(s)
return
|
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def peek(self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r = None
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def get(self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def put(self, b):
self.write(chr(b))
return
# Erase buffered contents
def erase(self):
self.truncate(0)
self.seek(0, 0)
return
# Set buffered contents
def setvalue(self, s):
self.erase()
self.write(s)
return
def hasMore(I):
r<|fim_middle|>
def enc8(x):
if (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
return x
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
if len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | eturn (I.peek() != None)
|
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def peek(self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r = None
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def get(self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def put(self, b):
self.write(chr(b))
return
# Erase buffered contents
def erase(self):
self.truncate(0)
self.seek(0, 0)
return
# Set buffered contents
def setvalue(self, s):
self.erase()
self.write(s)
return
def hasMore(I):
return (I.peek() != None)
def enc8(x):
i<|fim_middle|>
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
if len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | f (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
return x
|
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def peek(self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r = None
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def get(self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def put(self, b):
self.write(chr(b))
return
# Erase buffered contents
def erase(self):
self.truncate(0)
self.seek(0, 0)
return
# Set buffered contents
def setvalue(self, s):
self.erase()
self.write(s)
return
def hasMore(I):
return (I.peek() != None)
def enc8(x):
if (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
return x
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
i<|fim_middle|>
<｜fim▁end｜> | f len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0 |
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def peek(self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r <|fim_middle|>
else:
r = None
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def get(self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def put(self, b):
self.write(chr(b))
return
# Erase buffered contents
def erase(self):
self.truncate(0)
self.seek(0, 0)
return
# Set buffered contents
def setvalue(self, s):
self.erase()
self.write(s)
return
def hasMore(I):
return (I.peek() != None)
def enc8(x):
if (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
return x
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
if len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | = ord(b)
|
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def peek(self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r <|fim_middle|>
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def get(self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def put(self, b):
self.write(chr(b))
return
# Erase buffered contents
def erase(self):
self.truncate(0)
self.seek(0, 0)
return
# Set buffered contents
def setvalue(self, s):
self.erase()
self.write(s)
return
def hasMore(I):
return (I.peek() != None)
def enc8(x):
if (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
return x
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
if len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | = None
|
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def peek(self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r = None
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def get(self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def put(self, b):
self.write(chr(b))
return
# Erase buffered contents
def erase(self):
self.truncate(0)
self.seek(0, 0)
return
# Set buffered contents
def setvalue(self, s):
self.erase()
self.write(s)
return
def hasMore(I):
return (I.peek() != None)
def enc8(x):
if (x > 255):
r <|fim_middle|>
else:
return x
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
if len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | aise Exception("The integer %d cannot be encoded on 8 bits." % x)
|
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def peek(self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r = None
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def get(self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def put(self, b):
self.write(chr(b))
return
# Erase buffered contents
def erase(self):
self.truncate(0)
self.seek(0, 0)
return
# Set buffered contents
def setvalue(self, s):
self.erase()
self.write(s)
return
def hasMore(I):
return (I.peek() != None)
def enc8(x):
if (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
r <|fim_middle|>
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
if len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | eturn x
|
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def peek(self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r = None
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def get(self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def put(self, b):
self.write(chr(b))
return
# Erase buffered contents
def erase(self):
self.truncate(0)
self.seek(0, 0)
return
# Set buffered contents
def setvalue(self, s):
self.erase()
self.write(s)
return
def hasMore(I):
return (I.peek() != None)
def enc8(x):
if (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
return x
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
if len(val1) != len(val2):
r <|fim_middle|>
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | eturn False
|
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def p<|fim_middle|>self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r = None
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def get(self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def put(self, b):
self.write(chr(b))
return
# Erase buffered contents
def erase(self):
self.truncate(0)
self.seek(0, 0)
return
# Set buffered contents
def setvalue(self, s):
self.erase()
self.write(s)
return
def hasMore(I):
return (I.peek() != None)
def enc8(x):
if (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
return x
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
if len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | eek( |
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def peek(self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r = None
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def g<|fim_middle|>self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def put(self, b):
self.write(chr(b))
return
# Erase buffered contents
def erase(self):
self.truncate(0)
self.seek(0, 0)
return
# Set buffered contents
def setvalue(self, s):
self.erase()
self.write(s)
return
def hasMore(I):
return (I.peek() != None)
def enc8(x):
if (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
return x
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
if len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | et( |
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def peek(self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r = None
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def get(self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def p<|fim_middle|>self, b):
self.write(chr(b))
return
# Erase buffered contents
def erase(self):
self.truncate(0)
self.seek(0, 0)
return
# Set buffered contents
def setvalue(self, s):
self.erase()
self.write(s)
return
def hasMore(I):
return (I.peek() != None)
def enc8(x):
if (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
return x
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
if len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | ut( |
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def peek(self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r = None
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def get(self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def put(self, b):
self.write(chr(b))
return
# Erase buffered contents
def e<|fim_middle|>self):
self.truncate(0)
self.seek(0, 0)
return
# Set buffered contents
def setvalue(self, s):
self.erase()
self.write(s)
return
def hasMore(I):
return (I.peek() != None)
def enc8(x):
if (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
return x
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
if len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | rase( |
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def peek(self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r = None
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def get(self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def put(self, b):
self.write(chr(b))
return
# Erase buffered contents
def erase(self):
self.truncate(0)
self.seek(0, 0)
return
# Set buffered contents
def s<|fim_middle|>self, s):
self.erase()
self.write(s)
return
def hasMore(I):
return (I.peek() != None)
def enc8(x):
if (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
return x
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
if len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | etvalue( |
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def peek(self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r = None
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def get(self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def put(self, b):
self.write(chr(b))
return
# Erase buffered contents
def erase(self):
self.truncate(0)
self.seek(0, 0)
return
# Set buffered contents
def setvalue(self, s):
self.erase()
self.write(s)
return
def h<|fim_middle|>I):
return (I.peek() != None)
def enc8(x):
if (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
return x
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
if len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | asMore( |
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def peek(self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r = None
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def get(self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def put(self, b):
self.write(chr(b))
return
# Erase buffered contents
def erase(self):
self.truncate(0)
self.seek(0, 0)
return
# Set buffered contents
def setvalue(self, s):
self.erase()
self.write(s)
return
def hasMore(I):
return (I.peek() != None)
def e<|fim_middle|>x):
if (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
return x
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def constant_time_compare(val1, val2):
if len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | nc8( |
<|file_name|>utils.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
# Keyak v2 implementation by Jos Wetzels and Wouter Bokslag
# hereby denoted as "the implementer".
# Based on Keccak Python and Keyak v2 C++ implementations
# by the Keccak, Keyak and Ketje Teams, namely, Guido Bertoni,
# Joan Daemen, Michaël Peeters, Gilles Van Assche and Ronny Van Keer
#
# For more information, feedback or questions, please refer to:
# http://keyak.noekeon.org/
# http://keccak.noekeon.org/
# http://ketje.noekeon.org/
from StringIO import StringIO
class stringStream(StringIO):
# Peek (extract byte without advancing position, return None if no more stream is available)
def peek(self):
oldPos = self.tell()
b = self.read(1)
newPos = self.tell()
if((newPos == (oldPos+1)) and (b != '')):
r = ord(b)
else:
r = None
self.seek(oldPos, 0)
return r
# Pop a single byte (as integer representation)
def get(self):
return ord(self.read(1))
# Push a single byte (as integer representation)
def put(self, b):
self.write(chr(b))
return
# Erase buffered contents
def erase(self):
self.truncate(0)
self.seek(0, 0)
return
# Set buffered contents
def setvalue(self, s):
self.erase()
self.write(s)
return
def hasMore(I):
return (I.peek() != None)
def enc8(x):
if (x > 255):
raise Exception("The integer %d cannot be encoded on 8 bits." % x)
else:
return x
# Constant-time comparison from the Django source: https://github.com/django/django/blob/master/django/utils/crypto.py
# Is constant-time only if both strings are of equal length but given the use-case that is always the case.
def c<|fim_middle|>val1, val2):
if len(val1) != len(val2):
return False
result = 0
for x, y in zip(val1, val2):
result |= ord(x) ^ ord(y)
return result == 0<｜fim▁end｜> | onstant_time_compare( |
<|file_name|>admin.py<|end_file_name|><｜fim▁begin｜># -*- coding: utf-8 -*-
<｜fim▁hole｜>from django.contrib import admin
from ionyweb.plugin_app.plugin_video.models import Plugin_Video
admin.site.register(Plugin_Video)<｜fim▁end｜> | |
<|file_name|>simplifications_explicit.py<|end_file_name|><｜fim▁begin｜>from miasm.core.utils import size2mask
from miasm.expression.expression import ExprInt, ExprCond, ExprCompose, \
TOK_EQUAL
def simp_ext(_, expr):
if expr.op.startswith('zeroExt_'):
arg = expr.args[0]
if expr.size == arg.size:
return arg
return ExprCompose(arg, ExprInt(0, expr.size - arg.size))
if expr.op.startswith("signExt_"):
arg = expr.args[0]
add_size = expr.size - arg.size
new_expr = ExprCompose(
arg,
ExprCond(
arg.msb(),
ExprInt(size2mask(add_size), add_size),
ExprInt(0, add_size)
)
)
return new_expr
return expr
def simp_flags(_, expr):
args = expr.args
if expr.is_op("FLAG_EQ"):
return ExprCond(args[0], ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_EQ_AND"):
op1, op2 = args
return ExprCond(op1 & op2, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_SIGN_SUB"):
return (args[0] - args[1]).msb()
elif expr.is_op("FLAG_EQ_CMP"):
return ExprCond(
args[0] - args[1],
ExprInt(0, 1),
ExprInt(1, 1),
)
<｜fim▁hole｜> op1, op2 = args
res = op1 + op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_CF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADD_OF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_OF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_EQ_ADDWC"):
op1, op2, op3 = args
return ExprCond(
op1 + op2 + op3.zeroExtend(op1.size),
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADDWC_OF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_OF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADDWC_CF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_CF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_SIGN_ADDWC"):
op1, op2, op3 = args
return (op1 + op2 + op3.zeroExtend(op1.size)).msb()
elif expr.is_op("FLAG_SIGN_SUBWC"):
op1, op2, op3 = args
return (op1 - (op2 + op3.zeroExtend(op1.size))).msb()
elif expr.is_op("FLAG_EQ_SUBWC"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return ExprCond(res, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("CC_U<="):
op_cf, op_zf = args
return op_cf | op_zf
elif expr.is_op("CC_U>="):
op_cf, = args
return ~op_cf
elif expr.is_op("CC_S<"):
op_nf, op_of = args
return op_nf ^ op_of
elif expr.is_op("CC_S>"):
op_nf, op_of, op_zf = args
return ~(op_zf | (op_nf ^ op_of))
elif expr.is_op("CC_S<="):
op_nf, op_of, op_zf = args
return op_zf | (op_nf ^ op_of)
elif expr.is_op("CC_S>="):
op_nf, op_of = args
return ~(op_nf ^ op_of)
elif expr.is_op("CC_U>"):
op_cf, op_zf = args
return ~(op_cf | op_zf)
elif expr.is_op("CC_U<"):
op_cf, = args
return op_cf
elif expr.is_op("CC_NEG"):
op_nf, = args
return op_nf
elif expr.is_op("CC_EQ"):
op_zf, = args
return op_zf
elif expr.is_op("CC_NE"):
op_zf, = args
return ~op_zf
elif expr.is_op("CC_POS"):
op_nf, = args
return ~op_nf
return expr<｜fim▁end｜> | elif expr.is_op("FLAG_ADD_CF"): |
<|file_name|>simplifications_explicit.py<|end_file_name|><｜fim▁begin｜>from miasm.core.utils import size2mask
from miasm.expression.expression import ExprInt, ExprCond, ExprCompose, \
TOK_EQUAL
def simp_ext(_, expr):
<|fim_middle|>
def simp_flags(_, expr):
args = expr.args
if expr.is_op("FLAG_EQ"):
return ExprCond(args[0], ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_EQ_AND"):
op1, op2 = args
return ExprCond(op1 & op2, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_SIGN_SUB"):
return (args[0] - args[1]).msb()
elif expr.is_op("FLAG_EQ_CMP"):
return ExprCond(
args[0] - args[1],
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADD_CF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_CF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADD_OF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_OF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_EQ_ADDWC"):
op1, op2, op3 = args
return ExprCond(
op1 + op2 + op3.zeroExtend(op1.size),
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADDWC_OF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_OF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADDWC_CF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_CF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_SIGN_ADDWC"):
op1, op2, op3 = args
return (op1 + op2 + op3.zeroExtend(op1.size)).msb()
elif expr.is_op("FLAG_SIGN_SUBWC"):
op1, op2, op3 = args
return (op1 - (op2 + op3.zeroExtend(op1.size))).msb()
elif expr.is_op("FLAG_EQ_SUBWC"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return ExprCond(res, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("CC_U<="):
op_cf, op_zf = args
return op_cf | op_zf
elif expr.is_op("CC_U>="):
op_cf, = args
return ~op_cf
elif expr.is_op("CC_S<"):
op_nf, op_of = args
return op_nf ^ op_of
elif expr.is_op("CC_S>"):
op_nf, op_of, op_zf = args
return ~(op_zf | (op_nf ^ op_of))
elif expr.is_op("CC_S<="):
op_nf, op_of, op_zf = args
return op_zf | (op_nf ^ op_of)
elif expr.is_op("CC_S>="):
op_nf, op_of = args
return ~(op_nf ^ op_of)
elif expr.is_op("CC_U>"):
op_cf, op_zf = args
return ~(op_cf | op_zf)
elif expr.is_op("CC_U<"):
op_cf, = args
return op_cf
elif expr.is_op("CC_NEG"):
op_nf, = args
return op_nf
elif expr.is_op("CC_EQ"):
op_zf, = args
return op_zf
elif expr.is_op("CC_NE"):
op_zf, = args
return ~op_zf
elif expr.is_op("CC_POS"):
op_nf, = args
return ~op_nf
return expr
<｜fim▁end｜> | if expr.op.startswith('zeroExt_'):
arg = expr.args[0]
if expr.size == arg.size:
return arg
return ExprCompose(arg, ExprInt(0, expr.size - arg.size))
if expr.op.startswith("signExt_"):
arg = expr.args[0]
add_size = expr.size - arg.size
new_expr = ExprCompose(
arg,
ExprCond(
arg.msb(),
ExprInt(size2mask(add_size), add_size),
ExprInt(0, add_size)
)
)
return new_expr
return expr |
<|file_name|>simplifications_explicit.py<|end_file_name|><｜fim▁begin｜>from miasm.core.utils import size2mask
from miasm.expression.expression import ExprInt, ExprCond, ExprCompose, \
TOK_EQUAL
def simp_ext(_, expr):
if expr.op.startswith('zeroExt_'):
arg = expr.args[0]
if expr.size == arg.size:
return arg
return ExprCompose(arg, ExprInt(0, expr.size - arg.size))
if expr.op.startswith("signExt_"):
arg = expr.args[0]
add_size = expr.size - arg.size
new_expr = ExprCompose(
arg,
ExprCond(
arg.msb(),
ExprInt(size2mask(add_size), add_size),
ExprInt(0, add_size)
)
)
return new_expr
return expr
def simp_flags(_, expr):
<|fim_middle|>
<｜fim▁end｜> | args = expr.args
if expr.is_op("FLAG_EQ"):
return ExprCond(args[0], ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_EQ_AND"):
op1, op2 = args
return ExprCond(op1 & op2, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_SIGN_SUB"):
return (args[0] - args[1]).msb()
elif expr.is_op("FLAG_EQ_CMP"):
return ExprCond(
args[0] - args[1],
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADD_CF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_CF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADD_OF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_OF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_EQ_ADDWC"):
op1, op2, op3 = args
return ExprCond(
op1 + op2 + op3.zeroExtend(op1.size),
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADDWC_OF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_OF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADDWC_CF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_CF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_SIGN_ADDWC"):
op1, op2, op3 = args
return (op1 + op2 + op3.zeroExtend(op1.size)).msb()
elif expr.is_op("FLAG_SIGN_SUBWC"):
op1, op2, op3 = args
return (op1 - (op2 + op3.zeroExtend(op1.size))).msb()
elif expr.is_op("FLAG_EQ_SUBWC"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return ExprCond(res, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("CC_U<="):
op_cf, op_zf = args
return op_cf | op_zf
elif expr.is_op("CC_U>="):
op_cf, = args
return ~op_cf
elif expr.is_op("CC_S<"):
op_nf, op_of = args
return op_nf ^ op_of
elif expr.is_op("CC_S>"):
op_nf, op_of, op_zf = args
return ~(op_zf | (op_nf ^ op_of))
elif expr.is_op("CC_S<="):
op_nf, op_of, op_zf = args
return op_zf | (op_nf ^ op_of)
elif expr.is_op("CC_S>="):
op_nf, op_of = args
return ~(op_nf ^ op_of)
elif expr.is_op("CC_U>"):
op_cf, op_zf = args
return ~(op_cf | op_zf)
elif expr.is_op("CC_U<"):
op_cf, = args
return op_cf
elif expr.is_op("CC_NEG"):
op_nf, = args
return op_nf
elif expr.is_op("CC_EQ"):
op_zf, = args
return op_zf
elif expr.is_op("CC_NE"):
op_zf, = args
return ~op_zf
elif expr.is_op("CC_POS"):
op_nf, = args
return ~op_nf
return expr |
<|file_name|>simplifications_explicit.py<|end_file_name|><｜fim▁begin｜>from miasm.core.utils import size2mask
from miasm.expression.expression import ExprInt, ExprCond, ExprCompose, \
TOK_EQUAL
def simp_ext(_, expr):
if expr.op.startswith('zeroExt_'):
<|fim_middle|>
if expr.op.startswith("signExt_"):
arg = expr.args[0]
add_size = expr.size - arg.size
new_expr = ExprCompose(
arg,
ExprCond(
arg.msb(),
ExprInt(size2mask(add_size), add_size),
ExprInt(0, add_size)
)
)
return new_expr
return expr
def simp_flags(_, expr):
args = expr.args
if expr.is_op("FLAG_EQ"):
return ExprCond(args[0], ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_EQ_AND"):
op1, op2 = args
return ExprCond(op1 & op2, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_SIGN_SUB"):
return (args[0] - args[1]).msb()
elif expr.is_op("FLAG_EQ_CMP"):
return ExprCond(
args[0] - args[1],
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADD_CF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_CF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADD_OF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_OF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_EQ_ADDWC"):
op1, op2, op3 = args
return ExprCond(
op1 + op2 + op3.zeroExtend(op1.size),
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADDWC_OF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_OF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADDWC_CF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_CF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_SIGN_ADDWC"):
op1, op2, op3 = args
return (op1 + op2 + op3.zeroExtend(op1.size)).msb()
elif expr.is_op("FLAG_SIGN_SUBWC"):
op1, op2, op3 = args
return (op1 - (op2 + op3.zeroExtend(op1.size))).msb()
elif expr.is_op("FLAG_EQ_SUBWC"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return ExprCond(res, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("CC_U<="):
op_cf, op_zf = args
return op_cf | op_zf
elif expr.is_op("CC_U>="):
op_cf, = args
return ~op_cf
elif expr.is_op("CC_S<"):
op_nf, op_of = args
return op_nf ^ op_of
elif expr.is_op("CC_S>"):
op_nf, op_of, op_zf = args
return ~(op_zf | (op_nf ^ op_of))
elif expr.is_op("CC_S<="):
op_nf, op_of, op_zf = args
return op_zf | (op_nf ^ op_of)
elif expr.is_op("CC_S>="):
op_nf, op_of = args
return ~(op_nf ^ op_of)
elif expr.is_op("CC_U>"):
op_cf, op_zf = args
return ~(op_cf | op_zf)
elif expr.is_op("CC_U<"):
op_cf, = args
return op_cf
elif expr.is_op("CC_NEG"):
op_nf, = args
return op_nf
elif expr.is_op("CC_EQ"):
op_zf, = args
return op_zf
elif expr.is_op("CC_NE"):
op_zf, = args
return ~op_zf
elif expr.is_op("CC_POS"):
op_nf, = args
return ~op_nf
return expr
<｜fim▁end｜> | arg = expr.args[0]
if expr.size == arg.size:
return arg
return ExprCompose(arg, ExprInt(0, expr.size - arg.size)) |
<|file_name|>simplifications_explicit.py<|end_file_name|><｜fim▁begin｜>from miasm.core.utils import size2mask
from miasm.expression.expression import ExprInt, ExprCond, ExprCompose, \
TOK_EQUAL
def simp_ext(_, expr):
if expr.op.startswith('zeroExt_'):
arg = expr.args[0]
if expr.size == arg.size:
<|fim_middle|>
return ExprCompose(arg, ExprInt(0, expr.size - arg.size))
if expr.op.startswith("signExt_"):
arg = expr.args[0]
add_size = expr.size - arg.size
new_expr = ExprCompose(
arg,
ExprCond(
arg.msb(),
ExprInt(size2mask(add_size), add_size),
ExprInt(0, add_size)
)
)
return new_expr
return expr
def simp_flags(_, expr):
args = expr.args
if expr.is_op("FLAG_EQ"):
return ExprCond(args[0], ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_EQ_AND"):
op1, op2 = args
return ExprCond(op1 & op2, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_SIGN_SUB"):
return (args[0] - args[1]).msb()
elif expr.is_op("FLAG_EQ_CMP"):
return ExprCond(
args[0] - args[1],
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADD_CF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_CF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADD_OF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_OF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_EQ_ADDWC"):
op1, op2, op3 = args
return ExprCond(
op1 + op2 + op3.zeroExtend(op1.size),
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADDWC_OF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_OF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADDWC_CF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_CF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_SIGN_ADDWC"):
op1, op2, op3 = args
return (op1 + op2 + op3.zeroExtend(op1.size)).msb()
elif expr.is_op("FLAG_SIGN_SUBWC"):
op1, op2, op3 = args
return (op1 - (op2 + op3.zeroExtend(op1.size))).msb()
elif expr.is_op("FLAG_EQ_SUBWC"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return ExprCond(res, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("CC_U<="):
op_cf, op_zf = args
return op_cf | op_zf
elif expr.is_op("CC_U>="):
op_cf, = args
return ~op_cf
elif expr.is_op("CC_S<"):
op_nf, op_of = args
return op_nf ^ op_of
elif expr.is_op("CC_S>"):
op_nf, op_of, op_zf = args
return ~(op_zf | (op_nf ^ op_of))
elif expr.is_op("CC_S<="):
op_nf, op_of, op_zf = args
return op_zf | (op_nf ^ op_of)
elif expr.is_op("CC_S>="):
op_nf, op_of = args
return ~(op_nf ^ op_of)
elif expr.is_op("CC_U>"):
op_cf, op_zf = args
return ~(op_cf | op_zf)
elif expr.is_op("CC_U<"):
op_cf, = args
return op_cf
elif expr.is_op("CC_NEG"):
op_nf, = args
return op_nf
elif expr.is_op("CC_EQ"):
op_zf, = args
return op_zf
elif expr.is_op("CC_NE"):
op_zf, = args
return ~op_zf
elif expr.is_op("CC_POS"):
op_nf, = args
return ~op_nf
return expr
<｜fim▁end｜> | return arg |
<|file_name|>simplifications_explicit.py<|end_file_name|><｜fim▁begin｜>from miasm.core.utils import size2mask
from miasm.expression.expression import ExprInt, ExprCond, ExprCompose, \
TOK_EQUAL
def simp_ext(_, expr):
if expr.op.startswith('zeroExt_'):
arg = expr.args[0]
if expr.size == arg.size:
return arg
return ExprCompose(arg, ExprInt(0, expr.size - arg.size))
if expr.op.startswith("signExt_"):
<|fim_middle|>
return expr
def simp_flags(_, expr):
args = expr.args
if expr.is_op("FLAG_EQ"):
return ExprCond(args[0], ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_EQ_AND"):
op1, op2 = args
return ExprCond(op1 & op2, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_SIGN_SUB"):
return (args[0] - args[1]).msb()
elif expr.is_op("FLAG_EQ_CMP"):
return ExprCond(
args[0] - args[1],
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADD_CF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_CF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADD_OF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_OF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_EQ_ADDWC"):
op1, op2, op3 = args
return ExprCond(
op1 + op2 + op3.zeroExtend(op1.size),
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADDWC_OF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_OF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADDWC_CF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_CF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_SIGN_ADDWC"):
op1, op2, op3 = args
return (op1 + op2 + op3.zeroExtend(op1.size)).msb()
elif expr.is_op("FLAG_SIGN_SUBWC"):
op1, op2, op3 = args
return (op1 - (op2 + op3.zeroExtend(op1.size))).msb()
elif expr.is_op("FLAG_EQ_SUBWC"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return ExprCond(res, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("CC_U<="):
op_cf, op_zf = args
return op_cf | op_zf
elif expr.is_op("CC_U>="):
op_cf, = args
return ~op_cf
elif expr.is_op("CC_S<"):
op_nf, op_of = args
return op_nf ^ op_of
elif expr.is_op("CC_S>"):
op_nf, op_of, op_zf = args
return ~(op_zf | (op_nf ^ op_of))
elif expr.is_op("CC_S<="):
op_nf, op_of, op_zf = args
return op_zf | (op_nf ^ op_of)
elif expr.is_op("CC_S>="):
op_nf, op_of = args
return ~(op_nf ^ op_of)
elif expr.is_op("CC_U>"):
op_cf, op_zf = args
return ~(op_cf | op_zf)
elif expr.is_op("CC_U<"):
op_cf, = args
return op_cf
elif expr.is_op("CC_NEG"):
op_nf, = args
return op_nf
elif expr.is_op("CC_EQ"):
op_zf, = args
return op_zf
elif expr.is_op("CC_NE"):
op_zf, = args
return ~op_zf
elif expr.is_op("CC_POS"):
op_nf, = args
return ~op_nf
return expr
<｜fim▁end｜> | arg = expr.args[0]
add_size = expr.size - arg.size
new_expr = ExprCompose(
arg,
ExprCond(
arg.msb(),
ExprInt(size2mask(add_size), add_size),
ExprInt(0, add_size)
)
)
return new_expr |
<|file_name|>simplifications_explicit.py<|end_file_name|><｜fim▁begin｜>from miasm.core.utils import size2mask
from miasm.expression.expression import ExprInt, ExprCond, ExprCompose, \
TOK_EQUAL
def simp_ext(_, expr):
if expr.op.startswith('zeroExt_'):
arg = expr.args[0]
if expr.size == arg.size:
return arg
return ExprCompose(arg, ExprInt(0, expr.size - arg.size))
if expr.op.startswith("signExt_"):
arg = expr.args[0]
add_size = expr.size - arg.size
new_expr = ExprCompose(
arg,
ExprCond(
arg.msb(),
ExprInt(size2mask(add_size), add_size),
ExprInt(0, add_size)
)
)
return new_expr
return expr
def simp_flags(_, expr):
args = expr.args
if expr.is_op("FLAG_EQ"):
<|fim_middle|>
elif expr.is_op("FLAG_EQ_AND"):
op1, op2 = args
return ExprCond(op1 & op2, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_SIGN_SUB"):
return (args[0] - args[1]).msb()
elif expr.is_op("FLAG_EQ_CMP"):
return ExprCond(
args[0] - args[1],
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADD_CF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_CF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADD_OF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_OF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_EQ_ADDWC"):
op1, op2, op3 = args
return ExprCond(
op1 + op2 + op3.zeroExtend(op1.size),
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADDWC_OF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_OF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADDWC_CF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_CF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_SIGN_ADDWC"):
op1, op2, op3 = args
return (op1 + op2 + op3.zeroExtend(op1.size)).msb()
elif expr.is_op("FLAG_SIGN_SUBWC"):
op1, op2, op3 = args
return (op1 - (op2 + op3.zeroExtend(op1.size))).msb()
elif expr.is_op("FLAG_EQ_SUBWC"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return ExprCond(res, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("CC_U<="):
op_cf, op_zf = args
return op_cf | op_zf
elif expr.is_op("CC_U>="):
op_cf, = args
return ~op_cf
elif expr.is_op("CC_S<"):
op_nf, op_of = args
return op_nf ^ op_of
elif expr.is_op("CC_S>"):
op_nf, op_of, op_zf = args
return ~(op_zf | (op_nf ^ op_of))
elif expr.is_op("CC_S<="):
op_nf, op_of, op_zf = args
return op_zf | (op_nf ^ op_of)
elif expr.is_op("CC_S>="):
op_nf, op_of = args
return ~(op_nf ^ op_of)
elif expr.is_op("CC_U>"):
op_cf, op_zf = args
return ~(op_cf | op_zf)
elif expr.is_op("CC_U<"):
op_cf, = args
return op_cf
elif expr.is_op("CC_NEG"):
op_nf, = args
return op_nf
elif expr.is_op("CC_EQ"):
op_zf, = args
return op_zf
elif expr.is_op("CC_NE"):
op_zf, = args
return ~op_zf
elif expr.is_op("CC_POS"):
op_nf, = args
return ~op_nf
return expr
<｜fim▁end｜> | return ExprCond(args[0], ExprInt(0, 1), ExprInt(1, 1)) |
<|file_name|>simplifications_explicit.py<|end_file_name|><｜fim▁begin｜>from miasm.core.utils import size2mask
from miasm.expression.expression import ExprInt, ExprCond, ExprCompose, \
TOK_EQUAL
def simp_ext(_, expr):
if expr.op.startswith('zeroExt_'):
arg = expr.args[0]
if expr.size == arg.size:
return arg
return ExprCompose(arg, ExprInt(0, expr.size - arg.size))
if expr.op.startswith("signExt_"):
arg = expr.args[0]
add_size = expr.size - arg.size
new_expr = ExprCompose(
arg,
ExprCond(
arg.msb(),
ExprInt(size2mask(add_size), add_size),
ExprInt(0, add_size)
)
)
return new_expr
return expr
def simp_flags(_, expr):
args = expr.args
if expr.is_op("FLAG_EQ"):
return ExprCond(args[0], ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_EQ_AND"):
<|fim_middle|>
elif expr.is_op("FLAG_SIGN_SUB"):
return (args[0] - args[1]).msb()
elif expr.is_op("FLAG_EQ_CMP"):
return ExprCond(
args[0] - args[1],
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADD_CF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_CF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADD_OF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_OF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_EQ_ADDWC"):
op1, op2, op3 = args
return ExprCond(
op1 + op2 + op3.zeroExtend(op1.size),
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADDWC_OF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_OF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADDWC_CF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_CF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_SIGN_ADDWC"):
op1, op2, op3 = args
return (op1 + op2 + op3.zeroExtend(op1.size)).msb()
elif expr.is_op("FLAG_SIGN_SUBWC"):
op1, op2, op3 = args
return (op1 - (op2 + op3.zeroExtend(op1.size))).msb()
elif expr.is_op("FLAG_EQ_SUBWC"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return ExprCond(res, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("CC_U<="):
op_cf, op_zf = args
return op_cf | op_zf
elif expr.is_op("CC_U>="):
op_cf, = args
return ~op_cf
elif expr.is_op("CC_S<"):
op_nf, op_of = args
return op_nf ^ op_of
elif expr.is_op("CC_S>"):
op_nf, op_of, op_zf = args
return ~(op_zf | (op_nf ^ op_of))
elif expr.is_op("CC_S<="):
op_nf, op_of, op_zf = args
return op_zf | (op_nf ^ op_of)
elif expr.is_op("CC_S>="):
op_nf, op_of = args
return ~(op_nf ^ op_of)
elif expr.is_op("CC_U>"):
op_cf, op_zf = args
return ~(op_cf | op_zf)
elif expr.is_op("CC_U<"):
op_cf, = args
return op_cf
elif expr.is_op("CC_NEG"):
op_nf, = args
return op_nf
elif expr.is_op("CC_EQ"):
op_zf, = args
return op_zf
elif expr.is_op("CC_NE"):
op_zf, = args
return ~op_zf
elif expr.is_op("CC_POS"):
op_nf, = args
return ~op_nf
return expr
<｜fim▁end｜> | op1, op2 = args
return ExprCond(op1 & op2, ExprInt(0, 1), ExprInt(1, 1)) |
<|file_name|>simplifications_explicit.py<|end_file_name|><｜fim▁begin｜>from miasm.core.utils import size2mask
from miasm.expression.expression import ExprInt, ExprCond, ExprCompose, \
TOK_EQUAL
def simp_ext(_, expr):
if expr.op.startswith('zeroExt_'):
arg = expr.args[0]
if expr.size == arg.size:
return arg
return ExprCompose(arg, ExprInt(0, expr.size - arg.size))
if expr.op.startswith("signExt_"):
arg = expr.args[0]
add_size = expr.size - arg.size
new_expr = ExprCompose(
arg,
ExprCond(
arg.msb(),
ExprInt(size2mask(add_size), add_size),
ExprInt(0, add_size)
)
)
return new_expr
return expr
def simp_flags(_, expr):
args = expr.args
if expr.is_op("FLAG_EQ"):
return ExprCond(args[0], ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_EQ_AND"):
op1, op2 = args
return ExprCond(op1 & op2, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_SIGN_SUB"):
<|fim_middle|>
elif expr.is_op("FLAG_EQ_CMP"):
return ExprCond(
args[0] - args[1],
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADD_CF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_CF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADD_OF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_OF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_EQ_ADDWC"):
op1, op2, op3 = args
return ExprCond(
op1 + op2 + op3.zeroExtend(op1.size),
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADDWC_OF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_OF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADDWC_CF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_CF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_SIGN_ADDWC"):
op1, op2, op3 = args
return (op1 + op2 + op3.zeroExtend(op1.size)).msb()
elif expr.is_op("FLAG_SIGN_SUBWC"):
op1, op2, op3 = args
return (op1 - (op2 + op3.zeroExtend(op1.size))).msb()
elif expr.is_op("FLAG_EQ_SUBWC"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return ExprCond(res, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("CC_U<="):
op_cf, op_zf = args
return op_cf | op_zf
elif expr.is_op("CC_U>="):
op_cf, = args
return ~op_cf
elif expr.is_op("CC_S<"):
op_nf, op_of = args
return op_nf ^ op_of
elif expr.is_op("CC_S>"):
op_nf, op_of, op_zf = args
return ~(op_zf | (op_nf ^ op_of))
elif expr.is_op("CC_S<="):
op_nf, op_of, op_zf = args
return op_zf | (op_nf ^ op_of)
elif expr.is_op("CC_S>="):
op_nf, op_of = args
return ~(op_nf ^ op_of)
elif expr.is_op("CC_U>"):
op_cf, op_zf = args
return ~(op_cf | op_zf)
elif expr.is_op("CC_U<"):
op_cf, = args
return op_cf
elif expr.is_op("CC_NEG"):
op_nf, = args
return op_nf
elif expr.is_op("CC_EQ"):
op_zf, = args
return op_zf
elif expr.is_op("CC_NE"):
op_zf, = args
return ~op_zf
elif expr.is_op("CC_POS"):
op_nf, = args
return ~op_nf
return expr
<｜fim▁end｜> | return (args[0] - args[1]).msb() |
<|file_name|>simplifications_explicit.py<|end_file_name|><｜fim▁begin｜>from miasm.core.utils import size2mask
from miasm.expression.expression import ExprInt, ExprCond, ExprCompose, \
TOK_EQUAL
def simp_ext(_, expr):
if expr.op.startswith('zeroExt_'):
arg = expr.args[0]
if expr.size == arg.size:
return arg
return ExprCompose(arg, ExprInt(0, expr.size - arg.size))
if expr.op.startswith("signExt_"):
arg = expr.args[0]
add_size = expr.size - arg.size
new_expr = ExprCompose(
arg,
ExprCond(
arg.msb(),
ExprInt(size2mask(add_size), add_size),
ExprInt(0, add_size)
)
)
return new_expr
return expr
def simp_flags(_, expr):
args = expr.args
if expr.is_op("FLAG_EQ"):
return ExprCond(args[0], ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_EQ_AND"):
op1, op2 = args
return ExprCond(op1 & op2, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_SIGN_SUB"):
return (args[0] - args[1]).msb()
elif expr.is_op("FLAG_EQ_CMP"):
<|fim_middle|>
elif expr.is_op("FLAG_ADD_CF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_CF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADD_OF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_OF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_EQ_ADDWC"):
op1, op2, op3 = args
return ExprCond(
op1 + op2 + op3.zeroExtend(op1.size),
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADDWC_OF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_OF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADDWC_CF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_CF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_SIGN_ADDWC"):
op1, op2, op3 = args
return (op1 + op2 + op3.zeroExtend(op1.size)).msb()
elif expr.is_op("FLAG_SIGN_SUBWC"):
op1, op2, op3 = args
return (op1 - (op2 + op3.zeroExtend(op1.size))).msb()
elif expr.is_op("FLAG_EQ_SUBWC"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return ExprCond(res, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("CC_U<="):
op_cf, op_zf = args
return op_cf | op_zf
elif expr.is_op("CC_U>="):
op_cf, = args
return ~op_cf
elif expr.is_op("CC_S<"):
op_nf, op_of = args
return op_nf ^ op_of
elif expr.is_op("CC_S>"):
op_nf, op_of, op_zf = args
return ~(op_zf | (op_nf ^ op_of))
elif expr.is_op("CC_S<="):
op_nf, op_of, op_zf = args
return op_zf | (op_nf ^ op_of)
elif expr.is_op("CC_S>="):
op_nf, op_of = args
return ~(op_nf ^ op_of)
elif expr.is_op("CC_U>"):
op_cf, op_zf = args
return ~(op_cf | op_zf)
elif expr.is_op("CC_U<"):
op_cf, = args
return op_cf
elif expr.is_op("CC_NEG"):
op_nf, = args
return op_nf
elif expr.is_op("CC_EQ"):
op_zf, = args
return op_zf
elif expr.is_op("CC_NE"):
op_zf, = args
return ~op_zf
elif expr.is_op("CC_POS"):
op_nf, = args
return ~op_nf
return expr
<｜fim▁end｜> | return ExprCond(
args[0] - args[1],
ExprInt(0, 1),
ExprInt(1, 1),
) |
<|file_name|>simplifications_explicit.py<|end_file_name|><｜fim▁begin｜>from miasm.core.utils import size2mask
from miasm.expression.expression import ExprInt, ExprCond, ExprCompose, \
TOK_EQUAL
def simp_ext(_, expr):
if expr.op.startswith('zeroExt_'):
arg = expr.args[0]
if expr.size == arg.size:
return arg
return ExprCompose(arg, ExprInt(0, expr.size - arg.size))
if expr.op.startswith("signExt_"):
arg = expr.args[0]
add_size = expr.size - arg.size
new_expr = ExprCompose(
arg,
ExprCond(
arg.msb(),
ExprInt(size2mask(add_size), add_size),
ExprInt(0, add_size)
)
)
return new_expr
return expr
def simp_flags(_, expr):
args = expr.args
if expr.is_op("FLAG_EQ"):
return ExprCond(args[0], ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_EQ_AND"):
op1, op2 = args
return ExprCond(op1 & op2, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_SIGN_SUB"):
return (args[0] - args[1]).msb()
elif expr.is_op("FLAG_EQ_CMP"):
return ExprCond(
args[0] - args[1],
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADD_CF"):
<|fim_middle|>
elif expr.is_op("FLAG_SUB_CF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADD_OF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_OF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_EQ_ADDWC"):
op1, op2, op3 = args
return ExprCond(
op1 + op2 + op3.zeroExtend(op1.size),
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADDWC_OF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_OF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADDWC_CF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_CF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_SIGN_ADDWC"):
op1, op2, op3 = args
return (op1 + op2 + op3.zeroExtend(op1.size)).msb()
elif expr.is_op("FLAG_SIGN_SUBWC"):
op1, op2, op3 = args
return (op1 - (op2 + op3.zeroExtend(op1.size))).msb()
elif expr.is_op("FLAG_EQ_SUBWC"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return ExprCond(res, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("CC_U<="):
op_cf, op_zf = args
return op_cf | op_zf
elif expr.is_op("CC_U>="):
op_cf, = args
return ~op_cf
elif expr.is_op("CC_S<"):
op_nf, op_of = args
return op_nf ^ op_of
elif expr.is_op("CC_S>"):
op_nf, op_of, op_zf = args
return ~(op_zf | (op_nf ^ op_of))
elif expr.is_op("CC_S<="):
op_nf, op_of, op_zf = args
return op_zf | (op_nf ^ op_of)
elif expr.is_op("CC_S>="):
op_nf, op_of = args
return ~(op_nf ^ op_of)
elif expr.is_op("CC_U>"):
op_cf, op_zf = args
return ~(op_cf | op_zf)
elif expr.is_op("CC_U<"):
op_cf, = args
return op_cf
elif expr.is_op("CC_NEG"):
op_nf, = args
return op_nf
elif expr.is_op("CC_EQ"):
op_zf, = args
return op_zf
elif expr.is_op("CC_NE"):
op_zf, = args
return ~op_zf
elif expr.is_op("CC_POS"):
op_nf, = args
return ~op_nf
return expr
<｜fim▁end｜> | op1, op2 = args
res = op1 + op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb() |
<|file_name|>simplifications_explicit.py<|end_file_name|><｜fim▁begin｜>from miasm.core.utils import size2mask
from miasm.expression.expression import ExprInt, ExprCond, ExprCompose, \
TOK_EQUAL
def simp_ext(_, expr):
if expr.op.startswith('zeroExt_'):
arg = expr.args[0]
if expr.size == arg.size:
return arg
return ExprCompose(arg, ExprInt(0, expr.size - arg.size))
if expr.op.startswith("signExt_"):
arg = expr.args[0]
add_size = expr.size - arg.size
new_expr = ExprCompose(
arg,
ExprCond(
arg.msb(),
ExprInt(size2mask(add_size), add_size),
ExprInt(0, add_size)
)
)
return new_expr
return expr
def simp_flags(_, expr):
args = expr.args
if expr.is_op("FLAG_EQ"):
return ExprCond(args[0], ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_EQ_AND"):
op1, op2 = args
return ExprCond(op1 & op2, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("FLAG_SIGN_SUB"):
return (args[0] - args[1]).msb()
elif expr.is_op("FLAG_EQ_CMP"):
return ExprCond(
args[0] - args[1],
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADD_CF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_CF"):
<|fim_middle|>
elif expr.is_op("FLAG_ADD_OF"):
op1, op2 = args
res = op1 + op2
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUB_OF"):
op1, op2 = args
res = op1 - op2
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_EQ_ADDWC"):
op1, op2, op3 = args
return ExprCond(
op1 + op2 + op3.zeroExtend(op1.size),
ExprInt(0, 1),
ExprInt(1, 1),
)
elif expr.is_op("FLAG_ADDWC_OF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_OF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_ADDWC_CF"):
op1, op2, op3 = args
res = op1 + op2 + op3.zeroExtend(op1.size)
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (~(op1 ^ op2)))).msb()
elif expr.is_op("FLAG_SUBWC_CF"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb()
elif expr.is_op("FLAG_SIGN_ADDWC"):
op1, op2, op3 = args
return (op1 + op2 + op3.zeroExtend(op1.size)).msb()
elif expr.is_op("FLAG_SIGN_SUBWC"):
op1, op2, op3 = args
return (op1 - (op2 + op3.zeroExtend(op1.size))).msb()
elif expr.is_op("FLAG_EQ_SUBWC"):
op1, op2, op3 = args
res = op1 - (op2 + op3.zeroExtend(op1.size))
return ExprCond(res, ExprInt(0, 1), ExprInt(1, 1))
elif expr.is_op("CC_U<="):
op_cf, op_zf = args
return op_cf | op_zf
elif expr.is_op("CC_U>="):
op_cf, = args
return ~op_cf
elif expr.is_op("CC_S<"):
op_nf, op_of = args
return op_nf ^ op_of
elif expr.is_op("CC_S>"):
op_nf, op_of, op_zf = args
return ~(op_zf | (op_nf ^ op_of))
elif expr.is_op("CC_S<="):
op_nf, op_of, op_zf = args
return op_zf | (op_nf ^ op_of)
elif expr.is_op("CC_S>="):
op_nf, op_of = args
return ~(op_nf ^ op_of)
elif expr.is_op("CC_U>"):
op_cf, op_zf = args
return ~(op_cf | op_zf)
elif expr.is_op("CC_U<"):
op_cf, = args
return op_cf
elif expr.is_op("CC_NEG"):
op_nf, = args
return op_nf
elif expr.is_op("CC_EQ"):
op_zf, = args
return op_zf
elif expr.is_op("CC_NE"):
op_zf, = args
return ~op_zf
elif expr.is_op("CC_POS"):
op_nf, = args
return ~op_nf
return expr
<｜fim▁end｜> | op1, op2 = args
res = op1 - op2
return (((op1 ^ op2) ^ res) ^ ((op1 ^ res) & (op1 ^ op2))).msb() |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.