'''
Parser
======
Class used for the parsing of .kv files into rules.
'''
import os
import re
import sys
import traceback
from re import sub, findall
from types import CodeType
from functools import partial
from collections import OrderedDict, defaultdict
import kivy.lang.builder # imported as absolute to avoid circular import
from kivy.logger import Logger
from kivy.cache import Cache
from kivy import require
from kivy.resources import resource_find
from kivy.utils import rgba
import kivy.metrics as Metrics
__all__ = ('Parser', 'ParserException')
trace = Logger.trace
global_idmap = {}
# register cache for creating new classtype (template)
Cache.register('kv.lang')
# all previously included files
__KV_INCLUDES__ = []
# precompile regexp expression
lang_str = re.compile(
"((?:'''.*?''')|"
"(?:(?:(?<!')|''')'(?:[^']|\\\\')+?'(?:(?!')|'''))|"
'(?:""".*?""")|'
'(?:(?:(?<!")|""")"(?:[^"]|\\\\")+?"(?:(?!")|""")))', re.DOTALL)
lang_key = re.compile('([a-zA-Z_]+)')
lang_keyvalue = re.compile('([a-zA-Z_][a-zA-Z0-9_.]*\.[a-zA-Z0-9_.]+)')
lang_tr = re.compile('(_\()')
lang_cls_split_pat = re.compile(', *')
# all the widget handlers, used to correctly unbind all the callbacks then the
# widget is deleted
_handlers = defaultdict(partial(defaultdict, list))
class ProxyApp(object):
# proxy app object
# taken from http://code.activestate.com/recipes/496741-object-proxying/
__slots__ = ['_obj']
def __init__(self):
object.__init__(self)
object.__setattr__(self, '_obj', None)
def _ensure_app(self):
app = object.__getattribute__(self, '_obj')
if app is None:
from kivy.app import App
app = App.get_running_app()
object.__setattr__(self, '_obj', app)
# Clear cached application instance, when it stops
app.bind(on_stop=lambda instance:
object.__setattr__(self, '_obj', None))
return app
def __getattribute__(self, name):
object.__getattribute__(self, '_ensure_app')()
return getattr(object.__getattribute__(self, '_obj'), name)
def __delattr__(self, name):
object.__getattribute__(self, '_ensure_app')()
delattr(object.__getattribute__(self, '_obj'), name)
def __setattr__(self, name, value):
object.__getattribute__(self, '_ensure_app')()
setattr(object.__getattribute__(self, '_obj'), name, value)
def __bool__(self):
object.__getattribute__(self, '_ensure_app')()
return bool(object.__getattribute__(self, '_obj'))
def __str__(self):
object.__getattribute__(self, '_ensure_app')()
return str(object.__getattribute__(self, '_obj'))
def __repr__(self):
object.__getattribute__(self, '_ensure_app')()
return repr(object.__getattribute__(self, '_obj'))
global_idmap['app'] = ProxyApp()
global_idmap['pt'] = Metrics.pt
global_idmap['inch'] = Metrics.inch
global_idmap['cm'] = Metrics.cm
global_idmap['mm'] = Metrics.mm
global_idmap['dp'] = Metrics.dp
global_idmap['sp'] = Metrics.sp
global_idmap['rgba'] = rgba
[ドキュメント]class ParserException(Exception):
'''Exception raised when something wrong happened in a kv file.
'''
def __init__(self, context, line, message, cause=None):
self.filename = context.filename or '<inline>'
self.line = line
sourcecode = context.sourcecode
sc_start = max(0, line - 2)
sc_stop = min(len(sourcecode), line + 3)
sc = ['...']
for x in range(sc_start, sc_stop):
if x == line:
sc += ['>> %4d:%s' % (line + 1, sourcecode[line][1])]
else:
sc += [' %4d:%s' % (x + 1, sourcecode[x][1])]
sc += ['...']
sc = '\n'.join(sc)
message = 'Parser: File "%s", line %d:\n%s\n%s' % (
self.filename, self.line + 1, sc, message)
if cause:
message += '\n' + ''.join(traceback.format_tb(cause))
super(ParserException, self).__init__(message)
class ParserRuleProperty(object):
'''Represent a property inside a rule.
'''
__slots__ = ('ctx', 'line', 'name', 'value', 'co_value',
'watched_keys', 'mode', 'count', 'ignore_prev')
def __init__(self, ctx, line, name, value, ignore_prev=False):
super(ParserRuleProperty, self).__init__()
#: Associated parser
self.ctx = ctx
#: Line of the rule
self.line = line
#: Name of the property
self.name = name
#: Value of the property
self.value = value
#: Compiled value
self.co_value = None
#: Compilation mode
self.mode = None
#: Watched keys
self.watched_keys = None
#: Stats
self.count = 0
#: whether previous rules targeting name should be cleared
self.ignore_prev = ignore_prev
def precompile(self):
name = self.name
value = self.value
# first, remove all the string from the value
tmp = sub(lang_str, '', self.value)
# detecting how to handle the value according to the key name
mode = self.mode
if self.mode is None:
self.mode = mode = 'exec' if name[:3] == 'on_' else 'eval'
if mode == 'eval':
# if we don't detect any string/key in it, we can eval and give the
# result
if re.search(lang_key, tmp) is None:
self.co_value = eval(value)
return
# ok, we can compile.
value = '\n' * self.line + value
self.co_value = compile(value, self.ctx.filename or '<string>', mode)
# for exec mode, we don't need to watch any keys.
if mode == 'exec':
return
# now, detect obj.prop
# first, remove all the string from the value
tmp = sub(lang_str, '', value)
idx = tmp.find('#')
if idx != -1:
tmp = tmp[:idx]
# detect key.value inside value, and split them
wk = list(set(findall(lang_keyvalue, tmp)))
if len(wk):
self.watched_keys = [x.split('.') for x in wk]
if findall(lang_tr, tmp):
if self.watched_keys:
self.watched_keys += [['_']]
else:
self.watched_keys = [['_']]
def __repr__(self):
return '<ParserRuleProperty name=%r filename=%s:%d ' \
'value=%r watched_keys=%r>' % (
self.name, self.ctx.filename, self.line + 1,
self.value, self.watched_keys)
class ParserRule(object):
'''Represents a rule, in terms of the Kivy internal language.
'''
__slots__ = ('ctx', 'line', 'name', 'children', 'id', 'properties',
'canvas_before', 'canvas_root', 'canvas_after',
'handlers', 'level', 'cache_marked', 'avoid_previous_rules')
def __init__(self, ctx, line, name, level):
super(ParserRule, self).__init__()
#: Level of the rule in the kv
self.level = level
#: Associated parser
self.ctx = ctx
#: Line of the rule
self.line = line
#: Name of the rule
self.name = name
#: List of children to create
self.children = []
#: Id given to the rule
self.id = None
#: Properties associated to the rule
self.properties = OrderedDict()
#: Canvas normal
self.canvas_root = None
#: Canvas before
self.canvas_before = None
#: Canvas after
self.canvas_after = None
#: Handlers associated to the rule
self.handlers = []
#: Properties cache list: mark which class have already been checked
self.cache_marked = []
#: Indicate if any previous rules should be avoided.
self.avoid_previous_rules = False
if level == 0:
self._detect_selectors()
else:
self._forbid_selectors()
def precompile(self):
for x in self.properties.values():
x.precompile()
for x in self.handlers:
x.precompile()
for x in self.children:
x.precompile()
if self.canvas_before:
self.canvas_before.precompile()
if self.canvas_root:
self.canvas_root.precompile()
if self.canvas_after:
self.canvas_after.precompile()
def create_missing(self, widget):
# check first if the widget class already been processed by this rule
cls = widget.__class__
if cls in self.cache_marked:
return
self.cache_marked.append(cls)
for name in self.properties:
if hasattr(widget, name):
continue
value = self.properties[name].co_value
if type(value) is CodeType:
value = None
widget.create_property(name, value)
def _forbid_selectors(self):
c = self.name[0]
if c == '<' or c == '[':
raise ParserException(
self.ctx, self.line,
'Selectors rules are allowed only at the first level')
def _detect_selectors(self):
c = self.name[0]
if c == '<':
self._build_rule()
elif c == '[':
self._build_template()
else:
if self.ctx.root is not None:
raise ParserException(
self.ctx, self.line,
'Only one root object is allowed by .kv')
self.ctx.root = self
def _build_rule(self):
name = self.name
if __debug__:
trace('Builder: build rule for %s' % name)
if name[0] != '<' or name[-1] != '>':
raise ParserException(self.ctx, self.line,
'Invalid rule (must be inside <>)')
# if the very first name start with a -, avoid previous rules
name = name[1:-1]
if name[:1] == '-':
self.avoid_previous_rules = True
name = name[1:]
for rule in re.split(lang_cls_split_pat, name):
crule = None
if not len(rule):
raise ParserException(self.ctx, self.line,
'Empty rule detected')
if '@' in rule:
# new class creation ?
# ensure the name is correctly written
rule, baseclasses = rule.split('@', 1)
if not re.match(lang_key, rule):
raise ParserException(self.ctx, self.line,
'Invalid dynamic class name')
# save the name in the dynamic classes dict.
self.ctx.dynamic_classes[rule] = baseclasses
crule = ParserSelectorName(rule)
else:
# classical selectors.
if rule[0] == '.':
crule = ParserSelectorClass(rule[1:])
elif rule[0] == '#':
crule = ParserSelectorId(rule[1:])
else:
crule = ParserSelectorName(rule)
self.ctx.rules.append((crule, self))
def _build_template(self):
name = self.name
if __debug__:
trace('Builder: build template for %s' % name)
if name[0] != '[' or name[-1] != ']':
raise ParserException(self.ctx, self.line,
'Invalid template (must be inside [])')
item_content = name[1:-1]
if '@' not in item_content:
raise ParserException(self.ctx, self.line,
'Invalid template name (missing @)')
template_name, template_root_cls = item_content.split('@')
self.ctx.templates.append((template_name, template_root_cls, self))
def __repr__(self):
return '<ParserRule name=%r>' % (self.name, )
[ドキュメント]class Parser(object):
'''Create a Parser object to parse a Kivy language file or Kivy content.
'''
PROP_ALLOWED = ('canvas.before', 'canvas.after')
CLASS_RANGE = list(range(ord('A'), ord('Z') + 1))
PROP_RANGE = (
list(range(ord('A'), ord('Z') + 1)) +
list(range(ord('a'), ord('z') + 1)) +
list(range(ord('0'), ord('9') + 1)) + [ord('_')])
__slots__ = ('rules', 'templates', 'root', 'sourcecode',
'directives', 'filename', 'dynamic_classes')
def __init__(self, **kwargs):
super(Parser, self).__init__()
self.rules = []
self.templates = []
self.root = None
self.sourcecode = []
self.directives = []
self.dynamic_classes = {}
self.filename = kwargs.get('filename', None)
content = kwargs.get('content', None)
if content is None:
raise ValueError('No content passed')
self.parse(content)
def execute_directives(self):
global __KV_INCLUDES__
for ln, cmd in self.directives:
cmd = cmd.strip()
if __debug__:
trace('Parser: got directive <%s>' % cmd)
if cmd[:5] == 'kivy ':
version = cmd[5:].strip()
if len(version.split('.')) == 2:
version += '.0'
require(version)
elif cmd[:4] == 'set ':
try:
name, value = cmd[4:].strip().split(' ', 1)
except:
Logger.exception('')
raise ParserException(self, ln, 'Invalid directive syntax')
try:
value = eval(value, global_idmap)
except:
Logger.exception('')
raise ParserException(self, ln, 'Invalid value')
global_idmap[name] = value
elif cmd[:8] == 'include ':
ref = cmd[8:].strip()
force_load = False
if ref[:6] == 'force ':
ref = ref[6:].strip()
force_load = True
# if #:include [force] "path with quotes around"
if ref[0] == ref[-1] and ref[0] in ('"', "'"):
c = ref[:3].count(ref[0])
ref = ref[c:-c] if c != 2 else ref
if ref[-3:] != '.kv':
Logger.warn('Lang: {0} does not have a valid Kivy'
'Language extension (.kv)'.format(ref))
break
if ref in __KV_INCLUDES__:
if not os.path.isfile(resource_find(ref) or ref):
raise ParserException(self, ln,
'Invalid or unknown file: {0}'
.format(ref))
if not force_load:
Logger.warn('Lang: {0} has already been included!'
.format(ref))
continue
else:
Logger.debug('Lang: Reloading {0} ' +
'because include was forced.'
.format(ref))
kivy.lang.builder.Builder.unload_file(ref)
kivy.lang.builder.Builder.load_file(ref)
continue
Logger.debug('Lang: Including file: {0}'.format(0))
__KV_INCLUDES__.append(ref)
kivy.lang.builder.Builder.load_file(ref)
elif cmd[:7] == 'import ':
package = cmd[7:].strip()
z = package.split()
if len(z) != 2:
raise ParserException(self, ln, 'Invalid import syntax')
alias, package = z
try:
if package not in sys.modules:
try:
mod = __import__(package)
except ImportError:
mod = __import__('.'.join(package.split('.')[:-1]))
# resolve the whole thing
for part in package.split('.')[1:]:
mod = getattr(mod, part)
else:
mod = sys.modules[package]
global_idmap[alias] = mod
except ImportError:
Logger.exception('')
raise ParserException(self, ln,
'Unable to import package %r' %
package)
else:
raise ParserException(self, ln, 'Unknown directive')
[ドキュメント] def parse(self, content):
'''Parse the contents of a Parser file and return a list
of root objects.
'''
# Read and parse the lines of the file
lines = content.splitlines()
if not lines:
return
num_lines = len(lines)
lines = list(zip(list(range(num_lines)), lines))
self.sourcecode = lines[:]
if __debug__:
trace('Parser: parsing %d lines' % num_lines)
# Strip all comments
self.strip_comments(lines)
# Execute directives
self.execute_directives()
# Get object from the first level
objects, remaining_lines = self.parse_level(0, lines)
# Precompile rules tree
for rule in objects:
rule.precompile()
# After parsing, there should be no remaining lines
# or there's an error we did not catch earlier.
if remaining_lines:
ln, content = remaining_lines[0]
raise ParserException(self, ln, 'Invalid data (not parsed)')
[ドキュメント] def parse_level(self, level, lines, spaces=0):
'''Parse the current level (level * spaces) indentation.
'''
indent = spaces * level if spaces > 0 else 0
objects = []
current_object = None
current_property = None
current_propobject = None
i = 0
while i < len(lines):
line = lines[i]
ln, content = line
# Get the number of space
tmp = content.lstrip(' \t')
# Replace any tab with 4 spaces
tmp = content[:len(content) - len(tmp)]
tmp = tmp.replace('\t', ' ')
# first indent designates the indentation
if spaces == 0:
spaces = len(tmp)
count = len(tmp)
if spaces > 0 and count % spaces != 0:
raise ParserException(self, ln,
'Invalid indentation, '
'must be a multiple of '
'%s spaces' % spaces)
content = content.strip()
rlevel = count // spaces if spaces > 0 else 0
# Level finished
if count < indent:
return objects, lines[i - 1:]
# Current level, create an object
elif count == indent:
x = content.split(':', 1)
if not len(x[0]):
raise ParserException(self, ln, 'Identifier missing')
if (len(x) == 2 and len(x[1]) and
not x[1].lstrip().startswith('#')):
raise ParserException(self, ln,
'Invalid data after declaration')
name = x[0].rstrip()
# if it's not a root rule, then we got some restriction
# aka, a valid name, without point or everything else
if count != 0:
if False in [ord(z) in Parser.PROP_RANGE for z in name]:
raise ParserException(self, ln, 'Invalid class name')
current_object = ParserRule(self, ln, name, rlevel)
current_property = None
objects.append(current_object)
# Next level, is it a property or an object ?
elif count == indent + spaces:
x = content.split(':', 1)
if not len(x[0]):
raise ParserException(self, ln, 'Identifier missing')
# It's a class, add to the current object as a children
current_property = None
name = x[0].rstrip()
ignore_prev = name[0] == '-'
if ignore_prev:
name = name[1:]
if ord(name[0]) in Parser.CLASS_RANGE:
if ignore_prev:
raise ParserException(
self, ln, 'clear previous, `-`, not allowed here')
_objects, _lines = self.parse_level(
level + 1, lines[i:], spaces)
current_object.children = _objects
lines = _lines
i = 0
# It's a property
else:
if name not in Parser.PROP_ALLOWED:
if not all(ord(z) in Parser.PROP_RANGE for z in name):
raise ParserException(self, ln,
'Invalid property name')
if len(x) == 1:
raise ParserException(self, ln, 'Syntax error')
value = x[1].strip()
if name == 'id':
if len(value) <= 0:
raise ParserException(self, ln, 'Empty id')
if value in ('self', 'root'):
raise ParserException(
self, ln,
'Invalid id, cannot be "self" or "root"')
current_object.id = value
elif len(value):
rule = ParserRuleProperty(
self, ln, name, value, ignore_prev)
if name[:3] == 'on_':
current_object.handlers.append(rule)
else:
ignore_prev = False
current_object.properties[name] = rule
else:
current_property = name
current_propobject = None
if ignore_prev: # it wasn't consumed
raise ParserException(
self, ln, 'clear previous, `-`, not allowed here')
# Two more levels?
elif count == indent + 2 * spaces:
if current_property in (
'canvas', 'canvas.after', 'canvas.before'):
_objects, _lines = self.parse_level(
level + 2, lines[i:], spaces)
rl = ParserRule(self, ln, current_property, rlevel)
rl.children = _objects
if current_property == 'canvas':
current_object.canvas_root = rl
elif current_property == 'canvas.before':
current_object.canvas_before = rl
else:
current_object.canvas_after = rl
current_property = None
lines = _lines
i = 0
else:
if current_propobject is None:
current_propobject = ParserRuleProperty(
self, ln, current_property, content)
if current_property[:3] == 'on_':
current_object.handlers.append(current_propobject)
else:
current_object.properties[current_property] = \
current_propobject
else:
current_propobject.value += '\n' + content
# Too much indentation, invalid
else:
raise ParserException(self, ln,
'Invalid indentation (too many levels)')
# Check the next line
i += 1
return objects, []
class ParserSelector(object):
def __init__(self, key):
self.key = key.lower()
def match(self, widget):
raise NotImplemented()
def __repr__(self):
return '<%s key=%s>' % (self.__class__.__name__, self.key)
class ParserSelectorId(ParserSelector):
def match(self, widget):
if widget.id:
return widget.id.lower() == self.key
class ParserSelectorClass(ParserSelector):
def match(self, widget):
return self.key in widget.cls
class ParserSelectorName(ParserSelector):
parents = {}
def get_bases(self, cls):
for base in cls.__bases__:
if base.__name__ == 'object':
break
yield base
if base.__name__ == 'Widget':
break
for cbase in self.get_bases(base):
yield cbase
def match(self, widget):
parents = ParserSelectorName.parents
cls = widget.__class__
if cls not in parents:
classes = [x.__name__.lower() for x in
[cls] + list(self.get_bases(cls))]
parents[cls] = classes
return self.key in parents[cls]
def match_rule_name(self, rule_name):
return self.key == rule_name.lower()
