kongalib 2.0.0__cp310-cp310-win_amd64.whl → 2.0.2__cp310-cp310-win_amd64.whl

kongalib/__init__.py

@@ -126,6 +126,10 @@ class Log(object):
 			return self.messages
 		return [ msg for msg in self.messages if msg[0] == type ]
 
+	def add_messages(self, messages):
+		for msg in messages:
+			self.add_message(*msg)
+
 	def get_exception(self, klass=RuntimeError):
 		error = self.get_messages(Log.ERROR)[0][1]
 		return klass(error)
@@ -321,14 +325,12 @@ def ensure_text(text, error='replace'):
 
 
 
-from ._kongalib import Decimal, Deferred, JSONEncoder, JSONDecoder, start_timer, hash_password, host_lookup, get_network_interfaces, get_machine_uuid, get_system_info, _cleanup, lock, unlock, set_default_idle_callback, set_power_callbacks, checksum, _apply_stylesheet, regexp_find_all, _check_all
+from _kongalib import Decimal, Deferred, JSONEncoder, JSONDecoder, NamedSemaphore, start_timer, hash_password, host_lookup, get_network_interfaces, get_machine_uuid, get_system_info, _cleanup, lock, unlock, set_default_idle_callback, set_power_callbacks, checksum, _apply_stylesheet, regexp_find_all, _check_all
 from .constants import *
 from .client import *
 from .expression import *
 from .data_dictionary import *
-
-if sys.version_info >= (3, 6):
-	from .async_client import AsyncClient
+from .async_client import AsyncClient
 
 
 class ErrorMessage(object):

kongalib/async_client.py

@@ -16,11 +16,15 @@
 from __future__ import absolute_import
 
 import asyncio
+import nest_asyncio
 import inspect
 
 from kongalib import *
 
 
+nest_asyncio.apply()
+
+
 class AsyncClient(Client):
 	"""La classe AsyncClient, analogamente alla classe :class:`~kongalib.Client`, permette di connettersi ad un server Konga e di eseguire
 	comandi sullo stesso; la differenza è nel fatto che questa classe è costruita esplicitamente per lavorare con *asyncio* di Python, ed
@@ -50,7 +54,7 @@ class AsyncClient(Client):
 			future.set_exception(e)
 	
 	def _make_progress(self, future, progress, userdata):
-		def callback(ptype, completeness, state, data, dummy):
+		def callback(ptype, completeness, state, dummy):
 			loop = future.get_loop()
 			try:
 				if future.cancelled() or (progress is None):
@@ -107,7 +111,7 @@ class AsyncClient(Client):
 			answer = output[OUT_LOG] or []
 			error_list = ErrorList(answer)
 			if output[OUT_ERRNO] == OK:
-				if len(answer) > 0:
+				if error_list.errno != OK:
 					if log is None:
 						loop.call_soon_threadsafe(self._safe_set_exception, future, error_list)
 					else:
@@ -115,13 +119,21 @@ class AsyncClient(Client):
 						if log.has_errors():
 							loop.call_soon_threadsafe(self._safe_set_exception, future, error_list)
 						else:
-							if finalize_output is not None:
-								output = finalize_output(output)
-							loop.call_soon_threadsafe(self._safe_set_result, future, output)
+							try:
+								if finalize_output is not None:
+									output = finalize_output(output)
+							except Exception as e:
+								loop.call_soon_threadsafe(self._safe_set_exception, future, e)
+							else:
+								loop.call_soon_threadsafe(self._safe_set_result, future, output)
 				else:
-					if finalize_output is not None:
-						output = finalize_output(output)
-					loop.call_soon_threadsafe(self._safe_set_result, future, output)
+					try:
+						if finalize_output is not None:
+							output = finalize_output(output)
+					except Exception as e:
+						loop.call_soon_threadsafe(self._safe_set_exception, future, e)
+					else:
+						loop.call_soon_threadsafe(self._safe_set_result, future, output)
 			else:
 				loop.call_soon_threadsafe(self._safe_set_exception, future, ErrorList.from_error(output[OUT_ERRNO], output[OUT_ERROR]))
 		return success
@@ -457,7 +469,7 @@ class AsyncClient(Client):
 	def get_permissions(self, user_id):
 		return self._execute(CMD_GET_PERMISSIONS, {
 			IN_USER_ID: user_id
-		})
+		}, OUT_PERMISSIONS)
 	
 	def set_permissions(self, user_id, permissions):
 		return self._execute(CMD_SET_PERMISSIONS, {
@@ -674,12 +686,13 @@ class AsyncClient(Client):
 			IN_EXTRA_WHERE: where(extra_where),
 		}, OUT_EXISTS)
 	
-	def get_next_available_code(self, tablename, code_azienda, num_esercizio, dry_run=False):
+	def get_next_available_code(self, tablename, code_azienda, num_esercizio, dry_run=False, force=False):
 		return self._execute(CMD_GET_NEXT_CODE, {
 			IN_TABLE_NAME: tablename,
 			IN_CODE_AZIENDA: code_azienda,
 			IN_NUM_ESERCIZIO: num_esercizio,
 			IN_DRY_RUN: dry_run,
+			IN_FORCE: force,
 		}, OUT_CODE)
 
 	def get_last_npfe(self, code_azienda, num_esercizio):
@@ -695,24 +708,28 @@ class AsyncClient(Client):
 			IN_CODE_AZIENDA: code_azienda,
 			IN_NUM_ESERCIZIO: num_esercizio,
 			IN_TX: tx,
-		}, OUT_DATA, progress=progress)
+		}, OUT_DATA, progress=progress, log=log)
 
-	def list_binaries(self, field_or_tablename, id, type=None, progress=None):
+	def list_binaries(self, field_or_tablename, id, type=None, progress=None, full=False):
 		"""Ottiene la lista dei dati binari associati ad una scheda del database, identificata da *field_or_tablename* (che può essere un nome
 		tabella o un campo da cui risolvere il nome tabella) e *id*. La funzione restituisce un oggetto ``asyncio.Future`` il cui risultato
 		una volta completato sarà una lista di tuple, in cui la n-esima tupla ha la forma ``( Tipo, NomeAllegato, NomeOriginale )``; *Tipo*
 		è un intero ed è uno dei valori della *Choice* ``Resources``, *NomeAllegato* è il nome assegnato internamente a Konga per identificare
 		univocamente il contenuto binario, mentre *NomeOriginale* è il nome del file originale da cui è stato caricato il contenuto. Se *type*
-		è specificato, la funzione filtrerà i risultati in baso ad esso, ritornando solo le tuple con il *Tipo* corretto.
+		è specificato, la funzione filtrerà i risultati in base ad esso, ritornando solo le tuple con il *Tipo* corretto. Se *full* è ``True``
+		la n-esima tupla ritornata avrà tre valori in più corrispondenti all'etichetta dell'immagine aggiuntiva (se specificata), al codice
+		della tipologia dell'allegato e ai metadati associati (se presenti), e la tupla avrà quindi la forma
+		``( Tipo, NomeAllegato, NomeOriginale, Etichetta, CodiceTipologia, Metadati )``.
 		"""
 		def get_result(output):
 			return [ tuple(row) for row in output[OUT_LIST] if ((type is None) or (row[0] == type)) ]
 		return self._execute(CMD_LIST_BINARIES, {
 			IN_FIELD_NAME: field_or_tablename,
 			IN_ROW_ID: id,
+			IN_FULL: full,
 		}, get_result, progress=progress)
 
-	def fetch_image(self, fieldname, id, type, progress=None):
+	def fetch_image(self, fieldname, id, type, progress=None, label=None):
 		"""Piccolo wrapper alla funzione :meth:`.fetch_binary`, dedicato alle immagini, con l'unica differenza che l'oggetto ``asyncio.Future``
 		restituito una volta completato avrà come valore di ritorno direttamente il contenuto binario dell'immagine.
 		"""
@@ -720,35 +737,47 @@ class AsyncClient(Client):
 			IN_FIELD_NAME: fieldname,
 			IN_ROW_ID: id,
 			IN_TYPE: type,
+			IN_LABEL: label,
 		}, OUT_DATA, progress=progress)
 
-	def fetch_binary(self, field_or_tablename, id, type, filename=None, check_only=False, progress=None):
+	def fetch_binary(self, field_or_tablename, id, type, filename=None, check_only=False, progress=None, label=None, with_extra=False):
 		"""Carica un contenuto binario dal server. *field_or_tablename* può essere un nome tabella o un campo da cui risolvere il nome tabella;
 		questa tabella unita a *id* identificano la scheda del database da cui caricare la risorsa; *type* è uno dei valori della *Choice*
-		``Resources``, mentre *filename* ha senso solo per identificare le risorse di tipo documento.
+		``Resources``, mentre *filename* e *label* hanno senso solo per identificare rispettivamente le risorse di tipo documento ed immagine
+		aggiuntiva.
 		La funzione restituisce un oggetto ``asyncio.Future`` il cui risultato una volta completato sarà una tupla di quattro elementi:
 		( *dati*, *filename*, *original_filename*, *checksum* ). *dati* sono i dati binari che sono stati caricati dal server; *filename* è
 		il nome file interno con cui è identificata la risorsa, *original_filename* è il nome del file originale che è stato specificato
-		all'atto del salvataggio della risorsa sul server, mentre *checksum* è un checksum dei dati. Se *check_only* è ``True``, i dati
-		binari della risorsa non verranno effettivamente caricati dal dispositivo di archiviazione in cui sono depositati, e *dati* sarà
-		``None``; questa modalità è utile per verificare l'esistenza di una risorsa e il suo checksum senza effettivamente caricarla da remoto
-		(nel caso di archiviazione su cloud il caricamento potrebbe essere lento)."""
+		all'atto del salvataggio della risorsa sul server, mentre *checksum* è un checksum dei dati. Se *with_extra* è ``True``, la funzione
+		ritorna sei elementi, e gli elementi aggiuntivi sono un ``dict`` con i metadata associati alla risorsa, o ``None`` se non ci sono
+		metadati associati, e il codice della tipologia allegato se presente. Se *check_only* è ``True``, i dati binari della risorsa non
+		verranno effettivamente caricati dal dispositivo di archiviazione in cui sono depositati, e *dati* sarà ``None``; questa modalità è
+		utile per verificare l'esistenza di una risorsa e il suo checksum senza effettivamente caricarla da remoto (nel caso di archiviazione
+		su cloud il caricamento potrebbe essere lento)."""
 		if (type == 0) and (not filename):
 			raise ValueError('filename must be specified for document type resources')
+		if with_extra:
+			out_params = ( OUT_DATA, OUT_FILENAME, OUT_ORIGINAL_FILENAME, OUT_DATA_CHECKSUM, OUT_METADATA, OUT_CODE_TIPOLOGIA )
+		else:
+			out_params = ( OUT_DATA, OUT_FILENAME, OUT_ORIGINAL_FILENAME, OUT_DATA_CHECKSUM )
 		return self._execute(CMD_FETCH_BINARY, {
 			IN_FIELD_NAME: field_or_tablename,
 			IN_ROW_ID: id,
 			IN_TYPE: type,
 			IN_FILENAME: filename,
+			IN_LABEL: label,
 			IN_CHECK: check_only,
-		}, ( OUT_DATA, OUT_FILENAME, OUT_ORIGINAL_FILENAME, OUT_DATA_CHECKSUM ), progress=progress)
+		}, out_params, progress=progress)
 
-	def store_binary(self, field_or_tablename, id, type, filename=None, original_filename=None, data=None, desc=None, force_delete=False, code_azienda=None, progress=None):
+	def store_binary(self, field_or_tablename, id, type, filename=None, original_filename=None, data=None, desc=None, force_delete=False, code_azienda=None, progress=None, label=None, metadata=None, code_tipologia=None, log=None):
 		"""Salva un contenuto binario sul server. *field_or_tablename* può essere un nome tabella o un campo da cui risolvere il nome tabella;
 		questa tabella unita a *id* identificano la scheda a cui abbinare la risorsa; *type* è uno dei valori della *Choice*``Resources``;
 		*filename* permette di specificare un nome file interno con cui identificare la risorsa (se ``None`` il server genererà un nome univoco
 		automaticamente); *original_filename* è il nome file originale i cui dati si stanno salvando sul server; *data* sono i dati binari
-		effettivi; *desc* è la descrizione da abbinare alla risorsa; *code_azienda* infine identifica l'azienda su cui si sta operando.
+		effettivi; *desc* è la descrizione da abbinare alla risorsa; *code_azienda* infine identifica l'azienda su cui si sta operando, mentre
+		*code_tipologia* permette di specificare una tipologia da abbinare al dati. Per le risorse di tipo immagine aggiuntiva è necessario
+		specificare una *label* da abbinare all'immagine per identificarla univocamente. *metadata* può essere un ``dict`` in cui sia chiavi che
+		valori siano delle semplici stringhe, e permette di specificare dei metadati aggiuntivi associati alla risorsa binaria che si sta inserendo.
 		La funzione restituisce un oggetto ``asyncio.Future`` il cui risultato una volta completato sarà il nome del file interno usato dal
 		server per identificare la risorsa, che come detto sopra è uguale a *filename* se quest'ultimo è diverso da ``None``, altrimenti sarà
 		il nome file generato dal server.
@@ -764,13 +793,17 @@ class AsyncClient(Client):
 			IN_DATA: data,
 			IN_DESC: desc,
 			IN_FORCE_DELETE: force_delete,
-		}, OUT_FILENAME, progress=progress)
+			IN_LABEL: label,
+			IN_METADATA: metadata,
+			IN_CODE_TIPOLOGIA: code_tipologia,
+		}, OUT_FILENAME, progress=progress, log=log)
 
-	def translate(self, field, value, language):
+	def translate(self, field, value, language, code_azienda=None):
 		return self._execute(CMD_TRANSLATE, {
 			IN_FIELD: field,
 			IN_VALUE: value,
-			IN_LANGUAGE: language
+			IN_LANGUAGE: language,
+			IN_CODE_AZIENDA: code_azienda,
 		}, OUT_TEXT)
 
 	def set_database_language(self, language, progress=None):

kongalib/client.py

@@ -23,8 +23,8 @@ from .constants import *
 from .expression import *
 from .data_dictionary import *
 
-from ._kongalib import Client as ClientImpl
-from ._kongalib import start_timer
+from _kongalib import Client as ClientImpl
+from _kongalib import start_timer
 
 
 DEFAULT_DISCOVER_TIMEOUT		= 5000
@@ -55,6 +55,7 @@ GET_FLAG_DEFAULT				= GET_FLAG_GET_IMAGES | GET_FLAG_GET_ATTACHMENTS | GET_FLAG_
 IMAGE_NORMAL					= 1
 IMAGE_WEB						= 2
 IMAGE_THUMBNAIL					= 3
+IMAGE_EXTRA						= 4
 
 
 def make_callbacks(success, error, log=None):
@@ -768,12 +769,13 @@ class Client(object):
 		})
 		return output['EXISTS']
 	
-	def get_next_available_code(self, tablename, code_azienda, num_esercizio, dry_run=False):
+	def get_next_available_code(self, tablename, code_azienda, num_esercizio, dry_run=False, force=False):
 		return self.execute(CMD_GET_NEXT_CODE, {
 			IN_TABLE_NAME: tablename,
 			IN_CODE_AZIENDA: code_azienda,
 			IN_NUM_ESERCIZIO: num_esercizio,
 			IN_DRY_RUN: dry_run,
+			IN_FORCE: force,
 		})[OUT_CODE]
 
 	def get_last_npfe(self, code_azienda, num_esercizio):
@@ -828,13 +830,15 @@ class Client(object):
 				return output[OUT_DATA]
 			raise Error(output[OUT_ERRNO], output[OUT_ERROR])
 	
-	def list_binaries(self, field_or_tablename, id, type=None, success=None, error=None, progress=None):
+	def list_binaries(self, field_or_tablename, id, type=None, success=None, error=None, progress=None, full=False):
 		"""Ottiene la lista dei dati binari associati ad una scheda del database, identificata da *field_or_tablename* (che può essere un nome
 		tabella o un campo da cui risolvere il nome tabella) e *id*. La funzione ritorna una lista di tuple, in cui la n-esima tupla ha la
 		forma ``( Tipo, NomeAllegato, NomeOriginale )``; *Tipo* è un intero ed è uno dei valori della *Choice* ``Resources``, *NomeAllegato* è
 		il nome assegnato internamente a Konga per identificare univocamente il contenuto binario, mentre *NomeOriginale* è il nome del file
-		originale da cui è stato caricato il contenuto. Se *type* è specificato, la funzione filtrerà i risultati in baso ad esso, ritornando
-		solo le tuple con il *Tipo* corretto.
+		originale da cui è stato caricato il contenuto. Se *type* è specificato, la funzione filtrerà i risultati in base ad esso, ritornando
+		solo le tuple con il *Tipo* corretto. Se *full* è ``True`` la n-esima tupla ritornata avrà tre valori in più corrispondenti all'etichetta
+		dell'immagine aggiuntiva (se specificata), al codice della tipologia dell'allegato e ai metadati associati (se presenti), e la tupla avrà
+		quindi la forma ``( Tipo, NomeAllegato, NomeOriginale, Etichetta, CodiceTipologia, Metadati )``.
 		Se *success* è diverso da ``None``, la callback verrà invocata in caso di successo con la lista di tuple di cui sopra.
 		"""
 		if success is not None:
@@ -850,17 +854,19 @@ class Client(object):
 			return self.execute(CMD_LIST_BINARIES, {
 				IN_FIELD_NAME: field_or_tablename,
 				IN_ROW_ID: id,
+				IN_FULL: full,
 			}, success=callback, error=errback, progress=progress)
 		else:
 			output = self.execute(CMD_LIST_BINARIES, {
 				IN_FIELD_NAME: field_or_tablename,
 				IN_ROW_ID: id,
+				IN_FULL: full,
 			})
 			if output[OUT_ERRNO] == OK:
 				return [ tuple(row) for row in output[OUT_LIST] if ((type is None) or (row[0] == type)) ]
 			raise Error(output[OUT_ERRNO], output[OUT_ERROR])
 
-	def fetch_image(self, fieldname, id, type, success=None, error=None, progress=None):
+	def fetch_image(self, fieldname, id, type, success=None, error=None, progress=None, label=None):
 		"""Piccolo wrapper alla funzione :meth:`.fetch_binary`, dedicato alle immagini, con l'unica differenza che il valore di ritorno sarà
 		direttamente il contenuto binario dell'immagine in caso di successo (e questo sarà anche l'unico parametro passato alla callback
 		*success*)"""
@@ -878,25 +884,30 @@ class Client(object):
 				IN_FIELD_NAME: fieldname,
 				IN_ROW_ID: id,
 				IN_TYPE: type,
+				IN_LABEL: label,
 			}, success=callback, error=errback, progress=progress)
 		else:
 			output = self.execute(CMD_FETCH_BINARY, {
 				IN_FIELD_NAME: fieldname,
 				IN_ROW_ID: id,
 				IN_TYPE: type,
+				IN_LABEL: label,
 			})
 			if output[OUT_ERRNO] == OK:
 				return output[OUT_DATA]
 			raise Error(output[OUT_ERRNO], output[OUT_ERROR])
 	
-	def fetch_binary(self, field_or_tablename, id, type, filename=None, check_only=False, success=None, error=None, progress=None):
+	def fetch_binary(self, field_or_tablename, id, type, filename=None, check_only=False, success=None, error=None, progress=None, label=None, with_extra=False):
 		"""Carica un contenuto binario dal server. *field_or_tablename* può essere un nome tabella o un campo da cui risolvere il nome tabella;
 		questa tabella unita a *id* identificano la scheda del database da cui caricare la risorsa; *type* è uno dei valori della *Choice*
-		``Resources``, mentre *filename* ha senso solo per identificare le risorse di tipo documento.
+		``Resources``, mentre *filename* e *label* hanno senso solo per identificare rispettivamente le risorse di tipo documento ed immagine
+		aggiuntiva.
 		La funzione ritorna una tupla di quattro elementi: ( *dati*, *filename*, *original_filename*, *checksum* ). Questi quattro elementi
 		sono anche i parametri passati alla callback *success* in caso di successo. *dati* sono i dati binari che sono stati caricati dal
 		server; *filename* è il nome file interno con cui è identificata la risorsa, *original_filename* è il nome del file originale che è
-		stato specificato all'atto del salvataggio della risorsa sul server, mentre *checksum* è un checksum dei dati.
+		stato specificato all'atto del salvataggio della risorsa sul server, mentre *checksum* è un checksum dei dati. Se *with_extra* è
+		``True``, la funzione ritorna sei elementi, e gli elementi aggiuntivi sono un ``dict`` con i metadata associati alla risorsa, o ``None``
+		se non ci sono metadati associati, e il codice della tipologia allegato se presente.
 		Se *check_only* è ``True``, i dati binari della risorsa non verranno effettivamente caricati dal dispositivo di archiviazione in cui
 		sono depositati, e *dati* sarà ``None``; questa modalità è utile per verificare l'esistenza di una risorsa e il suo checksum senza
 		effettivamente caricarla da remoto (nel caso di archiviazione su cloud il caricamento potrebbe essere lento)."""
@@ -905,7 +916,10 @@ class Client(object):
 		if success is not None:
 			def callback(output, dummy):
 				if output[OUT_ERRNO] == OK:
-					success(output[OUT_DATA], output[OUT_FILENAME], output[OUT_ORIGINAL_FILENAME], output[OUT_DATA_CHECKSUM])
+					if with_extra:
+						success(output[OUT_DATA], output[OUT_FILENAME], output[OUT_ORIGINAL_FILENAME], output[OUT_DATA_CHECKSUM], output[OUT_METADATA], output[OUT_CODE_TIPOLOGIA])
+					else:
+						success(output[OUT_DATA], output[OUT_FILENAME], output[OUT_ORIGINAL_FILENAME], output[OUT_DATA_CHECKSUM])
 				elif error is not None:
 					error(Error(output[OUT_ERRNO], output[OUT_ERROR]))
 			def errback(errno, errstr, dummy):
@@ -917,6 +931,7 @@ class Client(object):
 				IN_ROW_ID: id,
 				IN_TYPE: type,
 				IN_FILENAME: filename,
+				IN_LABEL: label,
 				IN_CHECK: check_only,
 			}, success=callback, error=errback, progress=progress)
 		else:
@@ -925,18 +940,25 @@ class Client(object):
 				IN_ROW_ID: id,
 				IN_TYPE: type,
 				IN_FILENAME: filename,
+				IN_LABEL: label,
 				IN_CHECK: check_only,
 			})
 			if output[OUT_ERRNO] == OK:
-				return output[OUT_DATA], output[OUT_FILENAME], output[OUT_ORIGINAL_FILENAME], output[OUT_DATA_CHECKSUM]
+				if with_extra:
+					return output[OUT_DATA], output[OUT_FILENAME], output[OUT_ORIGINAL_FILENAME], output[OUT_DATA_CHECKSUM], output[OUT_METADATA], output[OUT_CODE_TIPOLOGIA]
+				else:
+					return output[OUT_DATA], output[OUT_FILENAME], output[OUT_ORIGINAL_FILENAME], output[OUT_DATA_CHECKSUM]
 			raise Error(output[OUT_ERRNO], output[OUT_ERROR])
 
-	def store_binary(self, field_or_tablename, id, type, filename=None, original_filename=None, data=None, desc=None, force_delete=False, code_azienda=None, success=None, error=None, progress=None):
+	def store_binary(self, field_or_tablename, id, type, filename=None, original_filename=None, data=None, desc=None, force_delete=False, code_azienda=None, success=None, error=None, progress=None, label=None, metadata=None, code_tipologia=None, log=None):
 		"""Salva un contenuto binario sul server. *field_or_tablename* può essere un nome tabella o un campo da cui risolvere il nome tabella;
 		questa tabella unita a *id* identificano la scheda a cui abbinare la risorsa; *type* è uno dei valori della *Choice*``Resources``;
 		*filename* permette di specificare un nome file interno con cui identificare la risorsa (se ``None`` il server genererà un nome univoco
 		automaticamente); *original_filename* è il nome file originale i cui dati si stanno salvando sul server; *data* sono i dati binari
-		effettivi; *desc* è la descrizione da abbinare alla risorsa; *code_azienda* infine identifica l'azienda su cui si sta operando.
+		effettivi; *desc* è la descrizione da abbinare alla risorsa; *code_azienda* infine identifica l'azienda su cui si sta operando, mentre
+		*code_tipologia* permette di specificare una tipologia da abbinare al dati. Per le risorse di tipo immagine aggiuntiva è necessario
+		specificare una *label* da abbinare all'immagine per identificarla univocamente. *metadata* può essere un ``dict`` in cui sia chiavi che
+		valori siano delle semplici stringhe, e permette di specificare dei metadati aggiuntivi associati alla risorsa binaria che si sta inserendo.
 		La funzione ritorna il nome del file interno usato dal server per identificare la risorsa, che come detto sopra è uguale a *filename* se
 		quest'ultimo è diverso da ``None``, altrimenti verrà ritornato il nome file generato dal server. La callback *success* se specificata
 		riceverà *filename* come unico parametro.
@@ -945,6 +967,8 @@ class Client(object):
 		if success is not None:
 			def callback(output, dummy):
 				if output[OUT_ERRNO] == OK:
+					if log is not None:
+						ErrorList(output[OUT_LOG] or []).prepare_log(log)
 					success(output[OUT_FILENAME])
 				elif error is not None:
 					error(Error(output[OUT_ERRNO], output[OUT_ERROR]))
@@ -962,6 +986,9 @@ class Client(object):
 				IN_DATA: data,
 				IN_DESC: desc,
 				IN_FORCE_DELETE: force_delete,
+				IN_LABEL: label,
+				IN_METADATA: metadata,
+				IN_CODE_TIPOLOGIA: code_tipologia,
 			}, success=callback, error=errback, progress=progress)
 		else:
 			output = self.execute(CMD_STORE_BINARY, {
@@ -974,16 +1001,22 @@ class Client(object):
 				IN_DATA: data,
 				IN_DESC: desc,
 				IN_FORCE_DELETE: force_delete,
+				IN_LABEL: label,
+				IN_METADATA: metadata,
+				IN_CODE_TIPOLOGIA: code_tipologia,
 			})
 			if output[OUT_ERRNO] == OK:
+				if log is not None:
+					ErrorList(output[OUT_LOG] or []).prepare_log(log)
 				return output[OUT_FILENAME]
 			raise Error(output[OUT_ERRNO], output[OUT_ERROR])
 
-	def translate(self, field, value, language):
+	def translate(self, field, value, language, code_azienda=None):
 		output = self.execute(CMD_TRANSLATE, {
 			IN_FIELD: field,
 			IN_VALUE: value,
-			IN_LANGUAGE: language
+			IN_LANGUAGE: language,
+			IN_CODE_AZIENDA: code_azienda,
 		})
 		if output[OUT_ERRNO] != OK:
 			raise Error(output[OUT_ERRNO], output[OUT_ERROR])