kongalib 1.12.0__cp39-cp39-win_amd64.whl → 2.0.0.post1__cp39-cp39-win_amd64.whl

kongaui.py

@@ -28,14 +28,6 @@ import kongautil
 from kongalib.scripting import _TimeoutBlocker
 from kongalib.scripting import proxy as _proxy
 
-PY3 = (sys.version_info[0] >= 3)
-
-
-if PY3:
-	basestring = str
-else:
-	input = raw_input
-
 
 
 BUTTON_OK							= 0x0001		#: Bottone "Ok"
@@ -75,47 +67,8 @@ if not _proxy.is_valid():
 
 
 def _get_term_width():
-	if PY3:
-		import shutil
-		return shutil.get_terminal_size(fallback=(80, 24))[0]
-	else:
-		# from https://stackoverflow.com/questions/566746/how-to-get-linux-console-window-width-in-python
-		if sys.platform == 'win32':
-			try:
-				from ctypes import windll, create_string_buffer
-				h = windll.kernel32.GetStdHandle(-12)
-				csbi = create_string_buffer(22)
-				res = windll.kernel32.GetConsoleScreenBufferInfo(h, csbi)
-			except:
-				res = None
-			if res:
-				import struct
-				(bufx, bufy, curx, cury, wattr, left, top, right, bottom, maxx, maxy) = struct.unpack("hhhhHhhhhhh", csbi.raw)
-				return right - left + 1
-			else:
-				return 80
-		else:
-			def ioctl_GWINSZ(fd):
-				try:
-					import fcntl, termios, struct
-					cr = struct.unpack('hh', fcntl.ioctl(fd, termios.TIOCGWINSZ, '1234'))
-				except:
-					return None
-				return cr
-			cr = ioctl_GWINSZ(0) or ioctl_GWINSZ(1) or ioctl_GWINSZ(2)
-			if not cr:
-				try:
-					fd = os.open(os.ctermid(), os.O_RDONLY)
-					cr = ioctl_GWINSZ(fd)
-					os.close(fd)
-				except:
-					pass
-			if not cr:
-				try:
-					cr = (env['LINES'], env['COLUMNS'])
-				except:
-					return 80
-			return int(cr[1])
+	import shutil
+	return shutil.get_terminal_size(fallback=(80, 24))[0]
 
 
 
@@ -338,11 +291,7 @@ def set_progress(progress=None, message=None, state=None):
 			tick = ('\\', '|', '/', '-')[int(time.time() * 5) % 4]
 			bar = '%s %s' % (elide(', '.join(text), term_width - 3), tick)
 		else:
-			if PY3:
-				block = u'\u2588'
-			else:
-				block = '#'
-			progress = (block * int((progress * 30) // 100))
+			progress = ('\u2588' * int((progress * 30) // 100))
 			bar = '|%-30s| %s' % (progress, elide(', '.join(text), term_width - 34))
 		print('\033[2K\r' + bar, end='')
 		sys.stdout.flush()
@@ -494,7 +443,7 @@ def execute_form(form_data, title=None, message=None, condition=None):
 						raise InvalidInput('Expected iso date (YYYY-MM-DD)')
 			elif wtype in ('choice', 'listbox', 'combobox'):
 				items = entry.get('items', [])
-				if (not isinstance(items, (tuple, list))) or (not all([ isinstance(item, basestring) for item in items ])):
+				if (not isinstance(items, (tuple, list))) or (not all([ isinstance(item, str) for item in items ])):
 					raise RuntimeError("Expected list of strings as 'items' value")
 				print(label)
 				for index, item in enumerate(items):

kongautil.py

@@ -53,13 +53,8 @@ class PrintError(RuntimeError):
 	"""Eccezione lanciata se ci sono errori nell'esecuzione di una stampa con la funzione :func:`print_layout`."""
 	def __init__(self, log):
 		self._log = log
-	def __unicode__(self):
-		return u'Log:\n%s' % ('\n'.join([ ('  %s' % line) for line in kongalib.ensure_text(self._log.dumps()).split(u'\n') ]))
 	def __str__(self):
-		if kongalib.PY3:
-			return self.__unicode__()
-		else:
-			return self.__unicode__().encode('utf-8')
+		return 'Log:\n%s' % ('\n'.join([ ('  %s' % line) for line in kongalib.ensure_text(self._log.dumps()).split(u'\n') ]))
 	def get_log(self):
 		"""Ottiene un oggetto di classe :class:`kongalib.Log` contenente gli errori di stampa."""
 		return self._log
@@ -144,7 +139,7 @@ def connect(host=None, port=None, driver=None, database=None, username=None, pas
 	parametri come variabili all'interno di un file di configurazione, nella sezione ``[kongautil.connect]``; tale file deve avere
 	il nome passato a questa funzione con il parametro ``config``, altrimenti verranno ricercati nell'ordine anche il file con lo
 	stesso nome dello script lanciato da terminale, ma con estensione ``.cfg``, il file ``kongalib.cfg`` sempre nella stessa directory
-	da cui si esegue lo script e infine il file ``~/.kongalib`` (sotto Unix) o ``%userprofile%\kongalib.cfg`` (sotto Windows)."""
+	da cui si esegue lo script e infine il file ``~/.kongalib`` (sotto Unix) o ``%userprofile%\\kongalib.cfg`` (sotto Windows)."""
 	if _proxy.is_valid():
 		info = _proxy.util.get_connection_info()
 		if info is not None:
@@ -162,10 +157,7 @@ def connect(host=None, port=None, driver=None, database=None, username=None, pas
 		client = kongalib.Client()
 		if host is None:
 			import argparse
-			try:
-				import configparser
-			except:
-				import ConfigParser as configparser
+			import configparser
 			files = [
 				os.path.abspath(os.path.expanduser(os.path.join('~', 'kongalib.cfg' if sys.platform == 'win32' else '.kongalib'))),
 				os.path.join(os.path.abspath(os.path.dirname(sys.argv[0])), 'kongalib.cfg'),
@@ -394,7 +386,7 @@ def print_layout(command_or_layout, builtins=None, code_azienda=None, code_eserc
 		log = kongalib.Log()
 		if not filename:
 			raise ValueError("Output filename must be specified")
-		if isinstance(command_or_layout, kongalib.text_base_types) and (command_or_layout.strip().startswith('<?xml') or command_or_layout.strip().startswith('<layout')):
+		if isinstance(command_or_layout, str) and (command_or_layout.strip().startswith('<?xml') or command_or_layout.strip().startswith('<layout')):
 			import tempfile
 			temp = tempfile.NamedTemporaryFile(mode='w', delete=False)
 			with temp:
@@ -431,7 +423,7 @@ def print_log(log, title, target=PRINT_TARGET_PREVIEW, filename=None):
 	:func:`print_layout`, passando i parametri *target* e *filename*; viceversa se si esegue fuori da Konga, il log verrà stampato su terminale."""
 	if _proxy.is_valid():
 		template = """<?xml version='1.0' encoding='utf-8'?>
-			<layout version="2" name="%(title)s" title="%(title)s" orientation="vertical" margin_top="75" margin_right="75" margin_bottom="75" margin_left="75">
+			<layout version="3" name="%(title)s" title="%(title)s" orientation="vertical" margin_top="75" margin_right="75" margin_bottom="75" margin_left="75">
 				<init>
 					<![CDATA[set_datasource(Datasource(['id', 'type', 'message'], DATA, 'Master'))
 ]]></init>
@@ -497,6 +489,18 @@ def print_log(log, title, target=PRINT_TARGET_PREVIEW, filename=None):
 
 
 
+def show_log(log, title, size=None, iconsize=32):
+	"""Visualizza il contenuto dell'oggetto *log* di classe :class:`kongalib.Log`; se si esegue questa funzione dall'interno di Konga, il log verrà
+	visualizzato in una finestra dedicata; viceversa se si esegue fuori da Konga, il comportamento di questa funzione equivale a chiamare
+	:func:`print_log` con gli stessi argomenti. La finestra del log mostrerà *title* come messaggio informativo e se specificato avrà dimensione *size*;
+	è possibile specificare anche la dimensione delle icone dei singoli messaggi tramite il parametro *iconsize*."""
+	if _proxy.is_valid():
+		log = _proxy.util.show_log(log.get_messages(), title, size, iconsize)
+	else:
+		print_log(log, title)
+
+
+
 def suspend_timeout():
 	"""Sospende il timeout di esecuzione dello script. La funzione non comporta eccezioni ma non ha alcun effetto se eseguita al di fuori di Konga."""
 	if _proxy.is_valid():

kongalib/compat.py

@@ -1,492 +0,0 @@
-# -*- coding: utf-8 -*-
-#	 _                           _ _ _
-#	| |                         | (_) |
-#	| | _____  _ __   __ _  __ _| |_| |__
-#	| |/ / _ \| '_ \ / _` |/ _` | | | '_ \
-#	|   < (_) | | | | (_| | (_| | | | |_) |
-#	|_|\_\___/|_| |_|\__, |\__,_|_|_|_.__/
-#	                  __/ |
-#	                 |___/
-#
-#	Konga client library, by EasyByte Software
-#
-#	https://github.com/easybyte-software/kongalib
-
-
-from __future__ import print_function
-
-import sys
-import io
-
-from xml.etree import ElementTree as ET
-
-
-
-PY3 = (sys.version_info[0] > 2)
-
-if PY3:
-	text_base_types = (str,)
-	text_type = str
-	data_base_types = (bytes,)
-	data_type = bytes
-	int_base_types = (int,)
-	int_type = int
-	file_type = io.IOBase
-	def reraise(tp, value, tb=None):
-		if value is None:
-			value = tp()
-		if value.__traceback__ is not tb:
-			raise value.with_traceback(tb)
-		raise value
-	unichr = chr
-	buffer = bytes
-else:
-	text_base_types = (basestring,)
-	text_type = unicode
-	data_base_types = (basestring, buffer)
-	data_type = bytes
-	int_base_types = (int, long)
-	int_type = long
-	file_type = file
-	exec("def reraise(tp, value, tb=None):\n  raise tp, value, tb\n")
-
-
-
-def ensure_text(text, error='replace'):
-	if not isinstance(text, text_base_types):
-		try:
-			text = unicode(text)
-		except:
-			if isinstance(text, data_base_types):
-				text = str(text, 'utf-8', 'replace')
-			else:
-				text = str(text)
-	if isinstance(text, data_type):
-		text = text_type(text, 'utf-8', error)
-	return text
-
-
-
-def _patch_etree():
-	OriginalElementTree = ET.ElementTree
-	Original_serialize_xml = ET._serialize_xml
-
-	if PY3:
-		import warnings
-		import collections
-		import collections.abc
-
-		Original_iterparse = ET.iterparse
-		Original_parse = ET.parse
-
-		def OriginalSubElement(parent, tag, attrib={}, **extra):
-			"""Subelement factory which creates an element instance, and appends it
-			to an existing parent.
-
-			The element tag, attribute names, and attribute values can be either
-			bytes or Unicode strings.
-
-			*parent* is the parent element, *tag* is the subelements name, *attrib* is
-			an optional directory containing element attributes, *extra* are
-			additional attributes given as keyword arguments.
-
-			"""
-			attrib = attrib.copy()
-			attrib.update(extra)
-			element = parent.makeelement(tag, attrib)
-			parent.append(element)
-			return element
-
-		class OriginalTreeBuilder:
-			"""Generic element structure builder.
-
-			This builder converts a sequence of start, data, and end method
-			calls to a well-formed element structure.
-
-			You can use this class to build an element structure using a custom XML
-			parser, or a parser for some other XML-like format.
-
-			*element_factory* is an optional element factory which is called
-			to create new Element instances, as necessary.
-
-			"""
-			def __init__(self, element_factory=None):
-				self._data = [] # data collector
-				self._elem = [] # element stack
-				self._last = None # last element
-				self._tail = None # true if we're after an end tag
-				if element_factory is None:
-					element_factory = ET._Element_Py
-				self._factory = element_factory
-
-			def close(self):
-				"""Flush builder buffers and return toplevel document Element."""
-				assert len(self._elem) == 0, "missing end tags"
-				assert self._last is not None, "missing toplevel element"
-				return self._last
-
-			def _flush(self):
-				if self._data:
-					if self._last is not None:
-						text = "".join(self._data)
-						if self._tail:
-							assert self._last.tail is None, "internal error (tail)"
-							self._last.tail = text
-						else:
-							assert self._last.text is None, "internal error (text)"
-							self._last.text = text
-					self._data = []
-
-			def data(self, data):
-				"""Add text to current element."""
-				self._data.append(data)
-
-			def start(self, tag, attrs):
-				"""Open new element and return it.
-
-				*tag* is the element name, *attrs* is a dict containing element
-				attributes.
-
-				"""
-				self._flush()
-				self._last = elem = self._factory(tag, attrs)
-				if self._elem:
-					self._elem[-1].append(elem)
-				self._elem.append(elem)
-				self._tail = 0
-				return elem
-
-			def end(self, tag):
-				"""Close and return current Element.
-
-				*tag* is the element name.
-
-				"""
-				self._flush()
-				self._last = self._elem.pop()
-				assert self._last.tag == tag,\
-					   "end tag mismatch (expected %s, got %s)" % (
-						   self._last.tag, tag)
-				self._tail = 1
-				return self._last
-
-		class OriginalXMLTreeBuilder(object):
-			def __init__(self, html=0, target=None, encoding=None):
-				try:
-					from xml.parsers import expat
-				except ImportError:
-					try:
-						import pyexpat as expat
-					except ImportError:
-						raise ImportError(
-							"No module named expat; use SimpleXMLTreeBuilder instead"
-							)
-				parser = expat.ParserCreate(encoding, "}")
-				if target is None:
-					target = OriginalTreeBuilder(ET._Element_Py)
-
-				self.parser = self._parser = parser
-				self.target = self._target = target
-				self._error = expat.error
-				self._names = {}
-				parser.DefaultHandlerExpand = self._default
-				if hasattr(target, 'start'):
-					parser.StartElementHandler = self._start
-				if hasattr(target, 'end'):
-					parser.EndElementHandler = self._end
-				if hasattr(target, 'data'):
-					parser.CharacterDataHandler = target.data
-				if hasattr(target, 'comment'):
-					parser.CommentHandler = target.comment
-				if hasattr(target, 'pi'):
-					parser.ProcessingInstructionHandler = target.pi
-				parser.buffer_text = 1
-				parser.ordered_attributes = 1
-				parser.specified_attributes = 1
-				self._doctype = None
-				self.entity = {}
-				try:
-					self.version = "Expat %d.%d.%d" % expat.version_info
-				except AttributeError:
-					pass
-
-			def _setevents(self, events_queue, events_to_report):
-				parser = self._parser
-				append = events_queue.append
-				for event_name in events_to_report:
-					if event_name == "start":
-						parser.ordered_attributes = 1
-						parser.specified_attributes = 1
-						def handler(tag, attrib_in, event=event_name, append=append, start=self._start):
-							append((event, start(tag, attrib_in)))
-						parser.StartElementHandler = handler
-					elif event_name == "end":
-						def handler(tag, event=event_name, append=append, end=self._end):
-							append((event, end(tag)))
-						parser.EndElementHandler = handler
-					elif event_name == "start-ns":
-						def handler(prefix, uri, event=event_name, append=append):
-							append((event, (prefix or "", uri or "")))
-						parser.StartNamespaceDeclHandler = handler
-					elif event_name == "end-ns":
-						def handler(prefix, event=event_name, append=append):
-							append((event, None))
-						parser.EndNamespaceDeclHandler = handler
-					else:
-						raise ValueError("unknown event %r" % event_name)
-
-			def _raiseerror(self, value):
-				err = ET.ParseError(value)
-				err.code = value.code
-				err.position = value.lineno, value.offset
-				raise err
-
-			def _fixname(self, key):
-				try:
-					name = self._names[key]
-				except KeyError:
-					name = key
-					if "}" in name:
-						name = "{" + name
-					self._names[key] = name
-				return name
-
-			def _fixtext(self, text):
-				return text
-
-			def _start(self, tag, attr_list):
-				fixname = self._fixname
-				tag = fixname(tag)
-				attrib = {}
-				if attr_list:
-					for i in range(0, len(attr_list), 2):
-						attrib[fixname(attr_list[i])] = attr_list[i+1]
-				e = self.target.start(tag, attrib)
-				return e
-
-			def _end(self, tag):
-				return self.target.end(self._fixname(tag))
-
-			def _default(self, text):
-				prefix = text[:1]
-				if prefix == "&":
-					try:
-						data_handler = self.target.data
-					except AttributeError:
-						return
-					try:
-						data_handler(self.entity[text[1:-1]])
-					except KeyError:
-						from xml.parsers import expat
-						err = expat.error(
-							"undefined entity %s: line %d, column %d" %
-							(text, self.parser.ErrorLineNumber,
-							self.parser.ErrorColumnNumber)
-							)
-						err.code = 11 # XML_ERROR_UNDEFINED_ENTITY
-						err.lineno = self.parser.ErrorLineNumber
-						err.offset = self.parser.ErrorColumnNumber
-						raise err
-				elif prefix == "<" and text[:9] == "<!DOCTYPE":
-					self._doctype = []
-				elif self._doctype is not None:
-					if prefix == ">":
-						self._doctype = None
-						return
-					text = text.strip()
-					if not text:
-						return
-					self._doctype.append(text)
-					n = len(self._doctype)
-					if n > 2:
-						type = self._doctype[1]
-						if type == "PUBLIC" and n == 4:
-							name, type, pubid, system = self._doctype
-							if pubid:
-								pubid = pubid[1:-1]
-						elif type == "SYSTEM" and n == 3:
-							name, type, system = self._doctype
-							pubid = None
-						else:
-							return
-						if hasattr(self.target, "doctype"):
-							self.target.doctype(name, pubid, system[1:-1])
-						elif self.doctype != self._XMLParser__doctype:
-							# warn about deprecated call
-							# self._XMLParser__doctype(name, pubid, system[1:-1])
-							self.doctype(name, pubid, system[1:-1])
-						self._doctype = None
-
-			def doctype(self, name, pubid, system):
-				warnings.warn("This method of XMLParser is deprecated.  Define doctype() method on the TreeBuilder target.", DeprecationWarning)
-
-			__doctype = doctype
-			_XMLParser__doctype = doctype
-
-			def feed(self, data):
-				try:
-					self.parser.Parse(data, 0)
-				except self._error as v:
-					self._raiseerror(v)
-
-			def close(self):
-				try:
-					self.parser.Parse("", 1) # end of data
-				except self._error as v:
-					self._raiseerror(v)
-				try:
-					close_handler = self.target.close
-				except AttributeError:
-					pass
-				else:
-					return close_handler()
-				finally:
-					del self.parser, self._parser
-					del self.target, self._target
-
-		def XML(text, parser=None):
-			"""Parse XML document from string constant.
-
-			This function can be used to embed "XML Literals" in Python code.
-
-			*text* is a string containing XML data, *parser* is an
-			optional parser instance, defaulting to the standard XMLParser.
-
-			Returns an Element instance.
-
-			"""
-			if not parser:
-				parser = PatchedXMLTreeBuilder(OriginalTreeBuilder(ET._Element_Py))
-			parser.feed(text)
-			return parser.close()
-
-		def iterparse(source, events=None, parser=None):
-			if parser is None:
-				parser = PatchedXMLTreeBuilder(OriginalTreeBuilder(ET._Element_Py))
-			return Original_iterparse(source, events, parser)
-
-		def parse(source, parser=None):
-			if parser is None:
-				parser = PatchedXMLTreeBuilder(OriginalTreeBuilder(ET._Element_Py))
-			return Original_parse(source, parser)
-
-		def serialize_xml(write, elem, qnames, namespaces, short_empty_elements, **kwargs):
-			if getattr(elem, '_is_cdata', False):
-				if elem.text:
-					write("<![CDATA[%s]]>" % elem.text)
-				if elem.tail:
-					write(elem.tail)
-			else:
-				Original_serialize_xml(write, elem, qnames, namespaces, short_empty_elements, **kwargs)
-
-		ET.Element = ET._Element_Py
-		ET.SubElement = OriginalSubElement
-		ET.XML = ET.fromstring = XML
-		ET.iterparse = iterparse
-		ET.parse = parse
-		ET._serialize_xml = serialize_xml
-
-	else:
-		def serialize_xml(write, elem, encoding, qnames, namespaces, **kwargs):
-			if getattr(elem, '_is_cdata', False):
-				if elem.text:
-					text = elem.text.encode(encoding)
-					write("<![CDATA[%s]]>" % text)
-				if elem.tail:
-					write(elem.tail)
-			else:
-				Original_serialize_xml(write, elem, encoding, qnames, namespaces, **kwargs)
-
-		OriginalXMLTreeBuilder = ET.XMLTreeBuilder
-		ET._serialize_xml = serialize_xml
-		ET._Element_Py = ET.Element
-		
-	class PatchedXMLTreeBuilder(OriginalXMLTreeBuilder):
-		def __init__(self, html=0, target=None, remove_comments=True, parse_comments=False, strip_cdata=True):
-			OriginalXMLTreeBuilder.__init__(self, html, target)
-			self._parser.StartCdataSectionHandler = self._start_cdata
-			self._parser.EndCdataSectionHandler = self._end_cdata
-			self._parser.CharacterDataHandler = self._data
-			if (not parse_comments) or remove_comments:
-				self._parser.CommentHandler = None
-			else:
-				self._parser.CommentHandler = self._handle_comment
-			self._parser.ProcessingInstructionHandler = self._handle_pi
-			self._cdataSection = False
-			self._cdataBuffer = None
-			self._strip_cdata = strip_cdata
-		
-		def _start(self, tag, attrib_in):
-			elem = OriginalXMLTreeBuilder._start(self, tag, attrib_in)
-			if isinstance(elem, ET._Element_Py):
-				elem.sourceline = elem.lineno = self._parser.CurrentLineNumber
-				elem.offset = elem.column = self._parser.CurrentColumnNumber
-			return elem
-		
-		def _start_list(self, tag, attrib_in):
-			elem = OriginalXMLTreeBuilder._start_list(self, tag, attrib_in)
-			if isinstance(elem, ET._Element_Py):
-				elem.sourceline = elem.lineno = self._parser.CurrentLineNumber
-				elem.offset = elem.column = self._parser.CurrentColumnNumber
-			return elem
-			
-		def _start_cdata(self):
-			"""
-			A CDATA section beginning has been recognized - start collecting
-			character data.
-			"""
-			self._cdataSection = True
-			self._cdataBuffer = []
-			
-		def _end_cdata(self):
-			"""
-			The CDATA section has ended - join the character data we collected
-			and add a CDATA element to the target tree.
-			"""
-			self._cdataSection = False
-			if not self._strip_cdata:
-				text = "".join(self._cdataBuffer)
-				if not PY3:
-					text = self._fixtext(text)
-				elem = self._target.start(None, {})
-				elem._is_cdata = True
-				self._target.data(text)
-				self._target.end(None)
-				elem.text = text
-			self._cdataBuffer = []
-	# 		print("created cdata with content:\n---\n%s\n---" % text)
-			
-		def _handle_comment(self, data):
-			return ET.Comment(self._fixtext(data))
-		
-		def _handle_pi(self, target, data):
-			return ET.PI(self._fixtext(target), self._fixtext(data))
-		
-		def _data(self, text):
-			"""
-			If we are in the middle of a CDATA section, collect the data into a
-			special buffer, otherwise treat it as before.
-			"""
-			if self._cdataSection:
-				self._cdataBuffer.append(text)
-			else:
-				self._target.data(text)
-	
-	def CDATA(text=None):
-		element = ET.Element(None)
-		element.text = text
-		element._is_cdata = True
-		return element
-	
-	ET.XMLTreeBuilder = ET.XMLParser = PatchedXMLTreeBuilder
-	ET._serialize['xml'] = ET._serialize_xml
-	ET.CDATA = CDATA
-
-
-
-try:
-	from xml.etree.ElementTree import CDATA
-except:
-	_patch_etree()
-
-

kongalib/parsetab.py

@@ -1,41 +0,0 @@
-
-# parsetab.py
-# This file is automatically generated. Do not edit.
-_tabversion = '3.2'
-
-_lr_method = 'LALR'
-
-_lr_signature = '\xa4\x8ah\xbf\x8b\xde\x16d;\x84\xd8\x0b\xf7}\x1b\x86'
-    
-_lr_action_items = {'AND':([4,10,11,14,16,19,20,21,22,23,24,27,],[12,-4,12,-8,-6,-3,-5,-1,12,-7,-9,-10,]),'RPAREN':([10,11,14,16,19,20,21,22,23,24,25,26,27,29,],[-4,20,-8,-6,-3,-5,-1,-2,-7,-9,27,-11,-10,-12,]),'LIKE':([1,7,],[5,17,]),'IS':([1,],[6,]),'VALUE':([5,9,17,18,28,],[14,19,24,26,26,]),'OR':([4,10,11,14,16,19,20,21,22,23,24,27,],[13,-4,13,-8,-6,-3,-5,-1,-2,-7,-9,-10,]),'OPERAND':([1,],[9,]),'COMMA':([26,],[28,]),'LPAREN':([0,2,3,8,12,13,],[3,3,3,18,3,3,]),'IN':([1,],[8,]),'NOT':([0,1,2,3,6,12,13,],[2,7,2,2,15,2,2,]),'NULL':([6,15,],[16,23,]),'ID':([0,2,3,12,13,],[1,1,1,1,1,]),'$end':([4,10,14,16,19,20,21,22,23,24,27,],[0,-4,-8,-6,-3,-5,-1,-2,-7,-9,-10,]),}
-
-_lr_action = { }
-for _k, _v in _lr_action_items.items():
-   for _x,_y in zip(_v[0],_v[1]):
-      if not _x in _lr_action:  _lr_action[_x] = { }
-      _lr_action[_x][_k] = _y
-del _lr_action_items
-
-_lr_goto_items = {'valueslist':([18,28,],[25,29,]),'expression':([0,2,3,12,13,],[4,10,11,21,22,]),}
-
-_lr_goto = { }
-for _k, _v in _lr_goto_items.items():
-   for _x,_y in zip(_v[0],_v[1]):
-       if not _x in _lr_goto: _lr_goto[_x] = { }
-       _lr_goto[_x][_k] = _y
-del _lr_goto_items
-_lr_productions = [
-  ("S' -> expression","S'",1,None,None,None),
-  ('expression -> expression AND expression','expression',3,'p_expression_and','expression.py',66),
-  ('expression -> expression OR expression','expression',3,'p_expression_or','expression.py',70),
-  ('expression -> ID OPERAND VALUE','expression',3,'p_expression_binop','expression.py',74),
-  ('expression -> NOT expression','expression',2,'p_expression_not','expression.py',78),
-  ('expression -> LPAREN expression RPAREN','expression',3,'p_expression_paren','expression.py',82),
-  ('expression -> ID IS NULL','expression',3,'p_expression_is_null','expression.py',86),
-  ('expression -> ID IS NOT NULL','expression',4,'p_expression_is_not_null','expression.py',90),
-  ('expression -> ID LIKE VALUE','expression',3,'p_expression_like','expression.py',94),
-  ('expression -> ID NOT LIKE VALUE','expression',4,'p_expression_not_like','expression.py',98),
-  ('expression -> ID IN LPAREN valueslist RPAREN','expression',5,'p_expression_in','expression.py',102),
-  ('valueslist -> VALUE','valueslist',1,'p_valueslist_single','expression.py',111),
-  ('valueslist -> VALUE COMMA valueslist','valueslist',3,'p_valueslist_multi','expression.py',115),
-]