kongalib 2.0.0.post1__cp314-cp314t-win_amd64.whl

kongalib/constants.py

@@ -0,0 +1,187 @@
+# -*- coding: utf-8 -*-
+
+import importlib.resources
+
+from . import json
+
+
+OK = 0                                                         #: Nessun errore
+ERROR = -1                                                     #: Errore generico
+INTERNAL_ERROR = 1                                             #: Errore interno
+OUT_OF_MEMORY = 2                                              #: Memoria esaurita
+ACCESS_DENIED = 3                                              #: Accesso negato
+TIMED_OUT = 4                                                  #: Tempo scaduto
+INTERRUPTED = 5                                                #: Operazione interrotta
+NOT_INITIALIZED = 6                                            #: Oggetto non inizializzato
+ABORTED = 7                                                    #: Operazione annullata
+TOO_MANY_OPEN_FILES = 8                                        #: Troppi file aperti
+FILE_NOT_FOUND = 9                                             #: File non trovato
+IO_ERROR = 10                                                  #: Errore di input/output
+FILE_EXISTS = 11                                               #: Il file già esiste
+RESOURCE_UNAVAILABLE = 12                                      #: La risorsa non è disponibile
+DISK_FULL = 13                                                 #: Disco pieno
+WOULD_BLOCK = 14                                               #: L'operazione sarebbe bloccante
+INVALID_RESOURCE = 15                                          #: Risorsa non valida
+BROKEN_PIPE = 16                                               #: Pipe terminata
+CANNOT_CREATE_SOCKET = 100                                     #: Impossibile creare il socket
+PROTOCOL_NOT_SUPPORTED = 101                                   #: Protocollo non supportato
+BAD_ADDRESS = 102                                              #: Indirizzo dell'host non valido
+CONNECTION_REFUSED = 103                                       #: Connessione rifiutata
+NETWORK_IS_UNREACHABLE = 104                                   #: La rete non è raggiungibile
+HOST_IS_UNREACHABLE = 105                                      #: L'host non è raggiungibile
+ADDRESS_ALREADY_IN_USE = 106                                   #: Indirizzo già in uso
+CANNOT_CONNECT = 107                                           #: Impossibile connettersi
+CANNOT_CONFIGURE_SOCKET = 108                                  #: Impossibile configurare il socket
+CANNOT_BIND_SOCKET = 109                                       #: Impossibile effettuare il bind del socket
+CANNOT_LISTEN_SOCKET = 110                                     #: Impossibile mettere il socket in ascolto
+WINSOCK_VERSION_NOT_SUPPORTED = 111                            #: Versione di Winsock non supportata
+ERROR_READING_SOCKET = 112                                     #: Errore in lettura dal socket
+ERROR_WRITING_SOCKET = 113                                     #: Errore in scrittura sul socket
+NOT_CONNECTED = 114                                            #: Non connesso
+CONNECTION_LOST = 115                                          #: La connessione è stata persa
+ALREADY_CONNECTED = 116                                        #: Connessione già stabilita
+BAD_SOCKET = 117                                               #: Socket non valido
+NO_NICS_FOUND = 118                                            #: Nessuna interfaccia di rete trovata
+BAD_REQUEST = 200                                              #: Richiesta di esecuzione non valida
+BAD_REPLY = 201                                                #: Risposta dal server non valida
+NOT_AUTHORIZED = 202                                           #: Autorizzazione fallita
+AUTHORIZATION_DATA_TOO_BIG = 203                               #: Dati di autorizzazione troppo grandi
+EXECUTE_FAILED = 204                                           #: La richiesta di esecuzione è fallita sul server
+EXECUTE_ABORTED = 205                                          #: Richiesta di esecuzione annullata dall'utente
+LISTENER_PORT_UNAVAILABLE = 206                                #: Porta di ascolto non disponibile
+RESPONDER_PORT_UNAVAILABLE = 207                               #: Porta di risposta non disponibile
+CLIENT_NOT_FOUND = 208                                         #: Client ID non trovato
+SKIP_REQUEST = 209                                             #: Non registrare la richiesta al server
+OK_NO_TRANSACTION = 212                                        #: Completa la richiesta con successo senza commit/rollback di transazione
+ARCHIVE_NOT_FOUND = 300                                        #: Archivio non trovato
+MALFORMED_RESOURCE_INDEX = 301                                 #: Indice delle risorse non valido nell'archivio
+MALFORMED_RESOURCE_DEFINITION = 302                            #: Definizione della risorsa non valida
+CANNOT_FIND_RESOURCE_IN_ARCHIVE = 303                          #: Risorsa non trovata nell'archivio
+CANNOT_READ_RESOURCE = 304                                     #: Impossibile leggere la risorsa
+CONFLICTING_RESOURCE_FILE_NAME = 305                           #: Il nome del file di risorsa è in conflitto con un altro file nell'archivio
+CANNOT_WRITE_RESOURCE = 306                                    #: Impossibile scrivere la risorsa
+ARCHIVE_NOT_LOADED = 307                                       #: Archivio non caricato
+BAD_STREAM = 400                                               #: Flusso dati corrotto
+END_STREAM = 401                                               #: Flusso dati terminato
+NO_MATCH = 500                                                 #: Nessun risultato
+
+
+CMD_GET_PERMISSIONS = 33
+CMD_SET_PERMISSIONS = 34
+CMD_BEGIN_TRANSACTION = 28
+CMD_COMMIT_TRANSACTION = 29
+CMD_ROLLBACK_TRANSACTION = 30
+CMD_LOCK = 48
+CMD_UNLOCK = 49
+CMD_SELECT = 37
+CMD_GET = 39
+CMD_INSERT_FROM_DICT = 44
+CMD_UPDATE_FROM_DICT = 45
+CMD_DELETE_FROM_CODE = 47
+CMD_CODE_EXISTS = 42
+CMD_GET_NEXT_CODE = 43
+CMD_GET_LAST_NPFE = 89
+CMD_START_ELAB = 54
+CMD_LIST_BINARIES = 86
+CMD_FETCH_BINARY = 55
+CMD_STORE_BINARY = 74
+CMD_TRANSLATE = 66
+CMD_SET_DATABASE_LANGUAGE = 67
+
+IN_CHECK = 'CHECK'
+IN_CODE = 'CODE'
+IN_CODE_AZIENDA = 'CODE_AZIENDA'
+IN_COLUMN_NAMES = 'COLUMN_NAMES'
+IN_COMMAND = 'COMMAND'
+IN_COMMAND_NAME = 'COMMAND_NAME'
+IN_DATA = 'DATA'
+IN_DESC = 'DESC'
+IN_DICT_DATA = 'DICT_DATA'
+IN_DRY_RUN = 'DRY_RUN'
+IN_EXTRA_WHERE = 'EXTRA_WHERE'
+IN_FIELD = 'FIELD'
+IN_FIELD_NAME = 'FIELD_NAME'
+IN_FILENAME = 'FILENAME'
+IN_FLAGS = 'FLAGS'
+IN_FORCE_DELETE = 'FORCE_DELETE'
+IN_GET_ROWS_EXIST = 'GET_ROWS_EXIST'
+IN_GET_TOTAL_ROWS = 'GET_TOTAL_ROWS'
+IN_LANGUAGE = 'LANGUAGE'
+IN_NUM_ESERCIZIO = 'NUM_ESERCIZIO'
+IN_OFFSET = 'OFFSET'
+IN_ORDER_BY = 'ORDER_BY'
+IN_ORDER_DESC = 'ORDER_DESC'
+IN_ORIGINAL_FILENAME = 'ORIGINAL_FILENAME'
+IN_PARAMS = 'PARAMS'
+IN_PERMISSIONS = 'PERMISSIONS'
+IN_ROW_COUNT = 'ROW_COUNT'
+IN_ROW_EXTRA_FIELDS = 'ROW_EXTRA_FIELDS'
+IN_ROW_ID = 'ROW_ID'
+IN_TABLE_NAME = 'TABLE_NAME'
+IN_TRANSACTION = 'TRANSACTION'
+IN_TX = 'TX'
+IN_TYPE = 'TYPE'
+IN_USER_ID = 'USER_ID'
+IN_VALUE = 'VALUE'
+IN_WHERE_CLAUSE = 'WHERE_CLAUSE'
+IN_LABEL = 'LABEL'
+IN_METADATA = 'METADATA'
+IN_CODE_TIPOLOGIA = 'CODE_TIPOLOGIA'
+
+OUT_CHECKSUM = 'CHECKSUM'
+OUT_CODE = 'CODE'
+OUT_COLUMN_NAMES = 'COLUMN_NAMES'
+OUT_DATA = 'DATA'
+OUT_DATA_CHECKSUM = 'DATA_CHECKSUM'
+OUT_DICT_DATA = 'DICT_DATA'
+OUT_ERRNO = 'ERRNO'
+OUT_ERROR = 'ERROR'
+OUT_EXIST = 'EXIST'
+OUT_FILENAME = 'FILENAME'
+OUT_ID = 'ID'
+OUT_LIST = 'LIST'
+OUT_LOG = 'LOG'
+OUT_NPFE = 'NPFE'
+OUT_ORIGINAL_FILENAME = 'ORIGINAL_FILENAME'
+OUT_PERMISSIONS = 'PERMISSIONS'
+OUT_RESULT_SET = 'RESULT_SET'
+OUT_TEXT = 'TEXT'
+OUT_TOTAL_ROWS = 'TOTAL_ROWS'
+OUT_METADATA = 'METADATA'
+OUT_CODE_TIPOLOGIA = 'CODE_TIPOLOGIA'
+
+
+_CONSTANTS = { key: value for key, value in locals().items() if key.isupper() }
+
+_EXTERNAL = {}
+
+
+def _ensure():
+	if not _EXTERNAL.get('@fetched', False):
+		try:
+			data = json.loads(importlib.resources.files('kongalib').joinpath('constants.json').read_bytes())
+		except:
+			data = None
+		if isinstance(data, dict):
+			existing = globals()
+			for key, value in data.items():
+				if (key in existing) and (value != existing[key]) and (key not in ('IO_ERROR','DISK_FULL')):
+					raise RuntimeError(f"Value '{value}' for {key} in constants.json mismatch (should be '{existing[key]}')")
+			_EXTERNAL.update(data)
+		_CONSTANTS.update(_EXTERNAL)
+		_EXTERNAL['@fetched'] = True
+	return _CONSTANTS.keys()
+__all__ = list(_ensure())
+
+
+
+def __getattr__(name):
+	if name in _CONSTANTS:
+		return _CONSTANTS[name]
+	else:
+		raise AttributeError(f"module {__name__!r} has no attribute {name!r} (!)")
+
+
+
+def __dir__():
+	return __all__

kongalib/data_dictionary.py

@@ -0,0 +1,203 @@
+# -*- coding: utf-8 -*-
+#	 _                           _ _ _
+#	| |                         | (_) |
+#	| | _____  _ __   __ _  __ _| |_| |__
+#	| |/ / _ \| '_ \ / _` |/ _` | | | '_ \
+#	|   < (_) | | | | (_| | (_| | | | |_) |
+#	|_|\_\___/|_| |_|\__, |\__,_|_|_|_.__/
+#	                  __/ |
+#	                 |___/
+#
+#	Konga client library, by EasyByte Software
+#
+#	https://github.com/easybyte-software/kongalib
+
+
+from kongalib import Error, ErrorList
+from .constants import *
+
+
+TYPE_TINYINT				= 1				#: Tipo di campo SQL TINYINT; i valori ottenuti dalla :meth:`~kongalib.Client.select_data` saranno di tipo ``int``.
+TYPE_SMALLINT				= 2				#: Tipo di campo SQL SMALLINT; i valori ottenuti dalla :meth:`~kongalib.Client.select_data` saranno di tipo ``int``.
+TYPE_INT					= 3				#: Tipo di campo SQL INT; i valori ottenuti dalla :meth:`~kongalib.Client.select_data` saranno di tipo ``int``.
+TYPE_BIGINT					= 4				#: Tipo di campo SQL BIGINT; i valori ottenuti dalla :meth:`~kongalib.Client.select_data` saranno di tipo ``int``.
+TYPE_FLOAT					= 5				#: Tipo di campo SQL FLOAT; i valori ottenuti dalla :meth:`~kongalib.Client.select_data` saranno di tipo ``float``.
+TYPE_DOUBLE					= 6				#: Tipo di campo SQL DOUBLE; i valori ottenuti dalla :meth:`~kongalib.Client.select_data` saranno di tipo ``float``.
+TYPE_DECIMAL				= 7				#: Tipo di campo SQL DECIMAL; i valori ottenuti dalla :meth:`~kongalib.Client.select_data` saranno di tipo :class:`kongalib.Decimal`.
+TYPE_DATE					= 8				#: Tipo di campo SQL DATE; i valori ottenuti dalla :meth:`~kongalib.Client.select_data` saranno di tipo ``datetime.date``.
+TYPE_TIME					= 9				#: Tipo di campo SQL TIME; i valori ottenuti dalla :meth:`~kongalib.Client.select_data` saranno di tipo ``datetime.time``.
+TYPE_TIMESTAMP				= 10			#: Tipo di campo SQL TIMESTAMP; i valori ottenuti dalla :meth:`~kongalib.Client.select_data` saranno di tipo ``datetime.datetime``.
+TYPE_YEAR					= 11			#: Tipo di campo SQL YEAR; i valori ottenuti dalla :meth:`~kongalib.Client.select_data` saranno di tipo ``int``.
+TYPE_CHAR					= 12			#: Tipo di campo SQL CHAR; i valori ottenuti dalla :meth:`~kongalib.Client.select_data` saranno di tipo ``unicode``.
+TYPE_VARCHAR				= 13			#: Tipo di campo SQL VARCHAR; i valori ottenuti dalla :meth:`~kongalib.Client.select_data` saranno di tipo ``unicode``.
+TYPE_TINYTEXT				= 14			#: Tipo di campo SQL TINYTEXT; i valori ottenuti dalla :meth:`~kongalib.Client.select_data` saranno di tipo ``unicode``.
+TYPE_TEXT					= 15			#: Tipo di campo SQL TEXT; i valori ottenuti dalla :meth:`~kongalib.Client.select_data` saranno di tipo ``unicode``.
+TYPE_LONGTEXT				= 16			#: Tipo di campo SQL LONGTEXT; i valori ottenuti dalla :meth:`~kongalib.Client.select_data` saranno di tipo ``unicode``.
+TYPE_TINYBLOB				= 17			#: Tipo di campo SQL TINYBLOB; i valori ottenuti dalla :meth:`~kongalib.Client.select_data` saranno di tipo ``bytes``.
+TYPE_BLOB					= 18			#: Tipo di campo SQL BLOB; i valori ottenuti dalla :meth:`~kongalib.Client.select_data` saranno di tipo ``bytes``.
+TYPE_LONGBLOB				= 19			#: Tipo di campo SQL LONGBLOB; i valori ottenuti dalla :meth:`~kongalib.Client.select_data` saranno di tipo ``bytes``.
+TYPE_JSON					= 20			#: Tipo di campo SQL JSON; i valori ottenuti dalla :meth:`~kongalib.Client.select_data` saranno di tipo ``unicode``.
+
+
+TABLE_HAS_IMAGES			= 0x1			#: Flag informativo di tabella del data dictionary. Se specificato, i record della tabella possono avere immagini collegate.
+TABLE_IS_INDEXED			= 0x2			#: Flag informativo di tabelle del data dictionary. Se specificato, la tabella è indicizzata per la ricerca full-text.
+
+FIELD_UNSIGNED				= 0x1			#: Flag informativo di campo del data dictionary. Se specificato, il tipo dato è senza segno.
+FIELD_UNIQUE				= 0x2			#: Flag informativo di campo del data dictionary. Se specificato, il campo SQL è UNIQUE.
+FIELD_NOT_NULL				= 0x4			#: Flag informativo di campo del data dictionary. Se specificato, il campo SQL non può essere NULL.
+FIELD_PRIMARY_KEY			= 0x8			#: Flag informativo di campo del data dictionary. Se specificato, il campo SQL è una PRIMARY KEY.
+FIELD_FOREIGN_KEY			= 0x10			#: Flag informativo di campo del data dictionary. Se specificato, il campo SQL è una FOREIGN KEY.
+FIELD_AUTO_INCREMENT		= 0x20			#: Flag informativo di campo del data dictionary. Se specificato, il campo SQL è un intero incrementato automaticamente.
+FIELD_DEFAULT_NULL			= 0x40			#: Flag informativo di campo del data dictionary. Se specificato, il campo SQL ha NULL come valore di default.
+FIELD_DEFAULT_CURRENT_TS	= 0x80			#: Flag informativo di campo del data dictionary. Se specificato, il campo SQL ha il timestamp corrente come valore di default.
+FIELD_DEFAULT				= 0xC0			#: Flag informativo di campo del data dictionary. Se specificato, il campo SQL ha un valore di default.
+FIELD_ON_UPDATE_CURRENT_TS	= 0x100			#: Flag informativo di campo del data dictionary. Se specificato, il campo SQL viene aggiornato automaticamente al timestamp corrente su UPDATE.
+FIELD_ON_DELETE_CASCADE		= 0x200			#: Flag informativo di campo del data dictionary. Se specificato, su cancellazione di un record tutti i record ad esso collegati verranno cancellati a loro volta.
+FIELD_ON_DELETE_SET_NULL	= 0x400			#: Flag informativo di campo del data dictionary. Se specificato, su cancellazione di un record tutti i record ad esso collegati avranno il collegamento impostato a NULL.
+
+FIELD_HIDDEN				= 0x10000
+FIELD_READ_ONLY				= 0x20000
+FIELD_CHOICE				= 0x40000
+FIELD_CODES					= 0x80000
+FIELD_REQUIRED				= 0x100000
+
+
+
+class DataDictionary(object):
+	"""La classe DataDictionary contiene informazioni sul dizionario dei dati usato da un server Konga. Tramite questa classe è possibile
+	ottenere la lista delle tabelle e dei campi, e informazioni specifiche su ogni campo.
+	"""
+
+	class Choice(object):
+		"""Piccola classe che descrive le opzioni associate ad una scelta fissa del dizionario dei dati."""
+
+		def __init__(self, data):
+			self.__data = data
+		
+		def __getattr__(self, key):
+			"""Ottiene il valore associato alla chiave *key*."""
+			return self.__data[key][0]
+		
+		def get_label(self, key):
+			"""Ottiene la descrizione della chiave *key* sotto forma di ``dict`` con le traduzioni corrispondenti a ciascuna lingua."""
+			if isinstance(key, str):
+				return self.__data[key][1]
+			for value, label in self.__data.values():
+				if value == key:
+					return label
+
+		def keys(self):
+			"""Ottiene la lista delle chiavi supportate da questa *Choice*."""
+			return list(self.__data.keys())
+	
+	
+	def __init__(self, data):
+		self.__data = data
+		self.__table_data = {}
+		tables = self.__data['tables']
+		for name, tabledata in tables.items():
+			self.__table_data[name.lower()] = tabledata
+		missing_table = { 'fields': {} }
+
+		self.__views = {
+			'EB_CodiciFissi': {
+				'desc': tables['EB_CodiciFissi1']['desc'],
+				'flags': tables['EB_CodiciFissi1']['flags'],
+				'EB_CodiciFissi1': tables['EB_CodiciFissi1']['fields'].keys(),
+				'EB_CodiciFissi2': list(set(tables['EB_CodiciFissi2']['fields'].keys()) - set(tables['EB_CodiciFissi1']['fields'].keys())),
+				'EB_CodiciFissi3': list(set(tables.get('EB_CodiciFissi3', missing_table)['fields'].keys()) - set(tables['EB_CodiciFissi1']['fields'].keys())),
+			},
+			'EB_Clienti': {
+				'desc': tables['EB_ClientiFornitori']['desc'],
+				'flags': tables['EB_ClientiFornitori']['flags'],
+				'EB_ClientiFornitori': tables['EB_ClientiFornitori']['fields'].keys(),
+			},
+			'EB_Fornitori': {
+				'desc': tables['EB_ClientiFornitori']['desc'],
+				'flags': tables['EB_ClientiFornitori']['flags'],
+				'EB_ClientiFornitori': tables['EB_ClientiFornitori']['fields'].keys(),
+			},
+		}
+		for view in self.__views.values():
+			fields = {}
+			for component, cfields in view.items():
+				if not component.startswith('EB_'):
+					continue
+				fields.update(tables.get(component, missing_table)['fields'])
+			view.update({
+				'fields': fields,
+			})
+		for view, viewinfo in self.__views.items():
+			self.__table_data[view.lower()] = viewinfo
+
+	def get_version(self):
+		"""Ottiene la versione del dizionario dei dati come intero nella forma ``(major << 16) | (minor << 8) | revision``."""
+		return self.__data['version']
+	
+	def get_tables_list(self):
+		"""Ottiene la lista delle tabelle del dizionario dei dati."""
+		return [ table for table in self.__data['tables'].keys() if table not in self.__views ]
+	
+	def get_table_info(self, tablename):
+		"""Ottiene un ``dict`` con le informazioni sulla tabella *tablename*. Le chiavi significative sono *desc* (un ``dict`` con le traduzioni
+		della descrizione della tabella) e *flags* (flag informativi sulla tabella; vedere le costanti :ref:`flag di tabella <table_flags>`).
+		"""
+		data = self.__table_data[tablename.lower()]
+		return {
+			'desc': data['desc'],
+			'flags': data['flags']
+		}
+	
+	def get_fields_list(self, tablename):
+		"""Ottiene la lista dei campi per la tabella *tablename*. I nomi dei campi restituiti non includono il nome tabella."""
+		return list(self.__table_data[tablename.lower()]['fields'].keys())
+	
+	def get_field_info(self, fieldname):
+		"""Ottiene un ``dict`` con le informazioni sul campo *fieldname*. Il nome del campo deve essere nella forma ``<NomeTabella>.<NomeCampo>``.
+		Le chiavi significative sono *desc* (un ``dict`` con le traduzioni della descrizione del campo), *type* (tipo di campo; vedere le
+		costanti :ref:`tipi di campo <field_types>`), *default* (valore di default) e *flags* (flag informativi sul campo; vedere le costanti
+		:ref:`flag di campo <field_flags>`).
+		"""
+		table, field = self.resolve_field(fieldname).split('.')
+		return self.__table_data[table.lower()]['fields'][field].copy()
+	
+	def resolve_field(self, fieldname):
+		"""Converte un nome campo dalla forma ``<NomeTabella>.[<CampoRef>.*]<NomeCampo>`` nella forma ``<NomeTabella>.<NomeCampo>``, risolvendo
+		eventuali campi ref_* intermedi."""
+		parts = fieldname.split('.')
+		table = parts.pop(0)
+		if len(parts) == 0:
+			raise ValueError("Invalid field name")
+		while True:
+			fields_data = self.__table_data[table.lower()]['fields']
+			field = parts.pop(0)
+			if field not in fields_data:
+				raise ValueError("Field '%s' not found in table '%s'" % (field, table))
+			if len(parts) == 0:
+				break
+			table = fields_data[field]['reference']['table']
+		return '%s.%s' % (table, field)
+	
+	def get_choice(self, choicename):
+		"""Ottiene un oggetto ``Choice`` a partire dal nome della scelta *choicename*. L'oggetto può successivamente essere interrogato per
+		ottenere informazioni su ogni opzione disponibile nella scelta."""
+		data = {}
+		options = self.__data['choices'][choicename]['options']
+		for value, option_data in options.items():
+			data[option_data['define']] = (int(value), option_data['option'])
+		return DataDictionary.Choice(data)
+	
+	def get_translation_context(self, fieldname):
+		try:
+			table, fieldname = self.resolve_field(fieldname).split('.')
+			context = '%s(%s)' % (table, fieldname)
+			if context in self.__data['contexts']:
+				return '%s.%s' % (table, fieldname)
+		except:
+			pass
+		return None
+	
+	def get_data(self):
+		return self.__data
+	
+

kongalib/db.py

@@ -0,0 +1,267 @@
+# -*- coding: utf-8 -*-
+#	 _                           _ _ _
+#	| |                         | (_) |
+#	| | _____  _ __   __ _  __ _| |_| |__
+#	| |/ / _ \| '_ \ / _` |/ _` | | | '_ \
+#	|   < (_) | | | | (_| | (_| | | | |_) |
+#	|_|\_\___/|_| |_|\__, |\__,_|_|_|_.__/
+#	                  __/ |
+#	                 |___/
+#
+#	Konga client library, by EasyByte Software
+#
+#	https://github.com/easybyte-software/kongalib
+
+
+import time
+import datetime
+
+from kongalib import Client, Decimal, Error as _Error, ErrorList
+from .constants import *
+
+
+apilevel = "2.0"			#: Versione delle API, come da specifica
+threadsafety = 2			#: E' possibile usare le funzioni di modulo e gli oggetti :class:`.Connection` da thread diversi
+paramstyle = "format"		#: Il formato dei parametri nelle query deve essere nello stile printf (WHERE name=%s)
+
+
+class Error(Exception):
+	"""Eccezione base, come da specifica."""
+	def __init__(self, msg):
+		self.msg = msg
+	def __str__(self):
+		return self.msg
+
+class Warning(Exception):
+	pass
+
+class InterfaceError(Error):
+	pass
+
+class DatabaseError(Error):
+	pass
+
+class InternalError(DatabaseError):
+	"""Errore interno."""
+	pass
+
+class OperationalError(DatabaseError):
+	"""Eccezione che viene lanciata su errori di connessione e/o comunicazione con il server Konga."""
+	pass
+
+class ProgrammingError(DatabaseError):
+	"""Eccezione che viene lanciata se l'esecuzione di una query SQL ha generato un errore."""
+	pass
+
+class IntegrityError(DatabaseError):
+	pass
+
+class DataError(DatabaseError):
+	pass
+
+class NotSupportedError(DatabaseError):
+	pass
+
+
+class STRING(object):
+	def __init__(self, string):
+		self.string = string
+
+class BINARY(object):
+	def __init__(self, binary):
+		self.binary = binary
+
+class NUMBER(object):
+	def __init__(self, number):
+		self.number = number
+
+class DATETIME(object):
+	def __init__(self, datetime):
+		self.datetime = datetime
+
+class ROWID(object):
+	pass
+
+
+class Connection(Client):
+	"""Classe che gestisce una connessione ad un server Konga. Viene usata per instanziare oggetti :class:`.Cursor` su cui poi operare, oppure
+	per gestire le transazioni.
+	"""
+	def close(self):
+		"""Chiude la connessione con il server Konga."""
+		self.disconnect()
+	
+	def commit(self):
+		"""Esegue una ``COMMIT`` per la transazione SQL corrente."""
+		self.query("COMMIT")
+	
+	def rollback(self):
+		"""Esegue una ``ROLLBACK`` per la transazione SQL corrente."""
+		self.query("ROLLBACK")
+	
+	def cursor(self):
+		"""Crea un nuovo oggetto :class:`Cursor` associato a questa connessione."""
+		return Cursor(self)
+
+
+class Cursor(object):
+	"""Questa classe permette di eseguire query SQL sulla connessione *conn* ad essa associata. Per instanziare oggetti di classe :class:`Cursor`
+	si usa il metodo :meth:`.Connection.cursor`.
+	La classe può essere anche usato come iteratore; in tal caso per ogni ciclo verrà restituita la prossima riga del result set derivante
+	dall'ultima query eseguita sul cursore stesso.
+	"""
+	def __init__(self, conn):
+		self.__connection = conn
+		self.__description = None
+		self.__rowcount = -1
+		self.__rownumber = 0
+		self.__arraysize = 1
+		self.__result = None
+		self.__valid = True
+	
+	def close(self):
+		"""Termina l'utilizzo di questo cursore; chiamate successive ai metodi di questo oggetto lanceranno un eccezione di tipo :exc:`.InternalError`."""
+		self.__valid = False
+	
+	def execute(self, command, *args):
+		"""Esegue la query SQL *command* sulla connessione associata al cursore; *command* può essere nel formato printf, e in tal caso
+		*args* sono gli argomenti che vengono sostituiti nella stringa di formato.
+		"""
+		if not self.__valid:
+			raise InternalError('cursor is not valid anymore')
+		try:
+			self.__rowcount, fields, self.__result = self.__connection.query(command % args)
+		except _Error as e:
+			if e.errno in (NOT_CONNECTED, CONNECTION_LOST, TIMED_OUT, BAD_REPLY):
+				raise OperationalError(str(e))
+			else:
+				raise ProgrammingError(str(e))
+		if len(self.__result) > 0:
+			self.__rowcount = len(self.__result)
+			self.__description = []
+			row = self.__result[0]
+			for field, data in zip(fields, row):
+				if isinstance(data, (int, float, Decimal)):
+					t = NUMBER
+				elif isinstance(data, (datetime.date, datetime.datetime)):
+					t = DATETIME
+				elif isinstance(data, str):
+					t = STRING
+				else:
+					t = BINARY
+				self.__description.append((field, t, None, None, None, None, None))
+			self.__rownumber = 0
+		else:
+			self.__result = None
+			self.__description = None
+			self.__rownumber = None
+	
+	def executemany(self, operation, seq):
+		"""Esegue la stessa query SQL tante volte quanta la lunghezza della sequenza *seq*; l'elemento *N* di *seq* deve essere una tupla
+		di argomenti da passare come *args* al metodo :meth:`execute` per eseguire la query *N*-esima.
+		"""
+		for args in seq:
+			self.execute(operation, *tuple(args))
+	
+	def fetchone(self):
+		"""Restituisce la prossima riga del result set ottenuto dall'ultima query eseguita su questo cursore. La riga è restituita sotto forma di
+		tupla di valori."""
+		if self.__result is None:
+			raise InternalError('no valid result set')
+		if self.__rownumber >= len(self.__result):
+			return None
+		self.__rownumber += 1
+		return tuple(self.__result[self.__rownumber - 1])
+	
+	def fetchmany(self, size=None):
+		"""Restituisce una lista di righe in cui ogni riga è nello stesso formato restituito da :meth:`fetchone`. La lista includerà al massimo
+		*size* righe; se *size* è ``None``, verranno incluse al massimo :attr:`arraysize` righe.
+		"""
+		if size is None:
+			size = self.__arraysize
+		result = []
+		for c in range(0, size):
+			result.append(self.fetchone())
+		return result
+	
+	def fetchall(self):
+		"""Restituisce tutte le righe del result set corrente."""
+		size = len(self.__result or []) - (self.__rownumber or 0)
+		return self.fetchmany(size)
+	
+	def __iter__(self):
+		return self
+	
+	def __next__(self):
+		row = self.fetchone()
+		if row is None:
+			raise StopIteration
+		return row
+
+	def next(self):
+		return self.__next__()
+	
+	def setinputsizes(self, sizes):
+		pass
+	
+	def setoutputsize(self, size, column):
+		pass
+	
+	@property
+	def connection(self):
+		"""Proprietà in sola lettura che restituisce l'oggetto :class:`Connection` associato a questo cursore."""
+		return self.__connection
+	
+	@property
+	def rowcount(self):
+		"""Proprietà in sola lettura che restituisce il numero di righe del result set corrente."""
+		return self.__rowcount
+	
+	@property
+	def rownumber(self):
+		"""Proprietà in sola lettura che restituisce il numero di riga corrente all'interno del result set."""
+		return self.__rownumber
+	
+	@property
+	def arraysize(self):
+		"""Proprietà in lettura/scrittura che specifica il numero massimo di righe da includere nel risultato di :meth:`fetchmany` se *size* è ``None``."""
+		return self.__arraysize
+	
+	@arraysize.setter
+	def arraysize(self, size):
+		self.__arraysize = size
+
+
+def Date(year, month, day):
+	return datetime.date(year, month, day)
+
+def Time(hour, minute, second):
+	return datetime.time(hour, minute, second)
+
+def Timestamp(year, month, day, hour, minute, second):
+	return datetime.datetime(year, month, day, hour, minute, second)
+
+def DateFromTicks(ticks):
+	return Date(*time.localtime(ticks)[:3])
+
+def TimeFromTicks(ticks):
+	return Time(*time.localtime(ticks)[3:6])
+
+def TimestampFromTicks(ticks):
+	return Timestamp(*time.localtime(ticks)[:6])
+
+def connect(host, port=0, driver=None, database=None, user=None, password=None, tenant_key=None):
+	"""Esegue una connessione al server Konga identificato da *host* e *port*, usando l'eventuale chiave tenant *tenant_key*, apre *database*
+	usando il *driver* specificato, ed infine si autentica usando *user* e *password*. Restituisce un oggetto :class:`Connection`; da questo
+	è possibile ottenere un oggetto :class:`Cursor` che permette di eseguire query SQL sul database aperto sulla connessione.
+	"""
+	conn = Connection()
+	try:
+		conn.connect({ 'host': host, 'port': port }, options={ 'tenant_key': tenant_key })
+		conn.open_database(driver, database)
+		conn.authenticate(user, password)
+	except _Error as e:
+		raise OperationalError(str(e))
+	return conn
+
+