libervia-backend: sat_frontends/jp/cmd

comparison sat_frontends/jp/cmd_file.py @ 3028:ab2696e34d29

Python 3 port: /!\ this is a huge commit /!\ starting from this commit, SàT is needs Python 3.6+ /!\ SàT maybe be instable or some feature may not work anymore, this will improve with time This patch port backend, bridge and frontends to Python 3. Roughly this has been done this way: - 2to3 tools has been applied (with python 3.7) - all references to python2 have been replaced with python3 (notably shebangs) - fixed files not handled by 2to3 (notably the shell script) - several manual fixes - fixed issues reported by Python 3 that where not handled in Python 2 - replaced "async" with "async_" when needed (it's a reserved word from Python 3.7) - replaced zope's "implements" with @implementer decorator - temporary hack to handle data pickled in database, as str or bytes may be returned, to be checked later - fixed hash comparison for password - removed some code which is not needed anymore with Python 3 - deactivated some code which needs to be checked (notably certificate validation) - tested with jp, fixed reported issues until some basic commands worked - ported Primitivus (after porting dependencies like urwid satext) - more manual fixes

author	Goffi <goffi@goffi.org>
date	Tue, 13 Aug 2019 19:08:41 +0200
parents	18a98a541f7a
children	fee60f17ebac

comparison

equal deleted inserted replaced

-:ff5bcb12ae60
+:ab2696e34d29
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
-import base
+from . import base
 import sys
 import os
 import os.path
 import tarfile
 from sat.core.i18n import _
 )
 self.need_loop = True
 def add_parser_options(self):
 self.parser.add_argument(
-"files", type=str, nargs="+", metavar="file", help=_(u"a list of file")
+"files", type=str, nargs="+", metavar="file", help=_("a list of file")
 )
 self.parser.add_argument(
-"jid", type=base.unicode_decoder, help=_(u"the destination jid")
+"jid", help=_("the destination jid")
 )
 self.parser.add_argument(
-"-b", "--bz2", action="store_true", help=_(u"make a bzip2 tarball")
+"-b", "--bz2", action="store_true", help=_("make a bzip2 tarball")
 )
 self.parser.add_argument(
 "-d",
 "--path",
-type=base.unicode_decoder,
+help=("path to the directory where the file must be stored"),
-help=(u"path to the directory where the file must be stored"),
 )
 self.parser.add_argument(
 "-N",
 "--namespace",
-type=base.unicode_decoder,
+help=("namespace of the file"),
-help=(u"namespace of the file"),
 )
 self.parser.add_argument(
 "-n",
 "--name",
-type=base.unicode_decoder,
+default="",
-default=u"",
+help=("name to use (DEFAULT: use source file name)"),
-help=(u"name to use (DEFAULT: use source file name)"),
 )
 def start(self):
 """Send files to jabber contact"""
 self.send_files()
 def onProgressStarted(self, metadata):
-self.disp(_(u"File copy started"), 2)
+self.disp(_("File copy started"), 2)
 def onProgressFinished(self, metadata):
-self.disp(_(u"File sent successfully"), 2)
+self.disp(_("File sent successfully"), 2)
 def onProgressError(self, error_msg):
 if error_msg == C.PROGRESS_ERROR_DECLINED:
-self.disp(_(u"The file has been refused by your contact"))
+self.disp(_("The file has been refused by your contact"))
 else:
-self.disp(_(u"Error while sending file: {}").format(error_msg), error=True)
+self.disp(_("Error while sending file: {}").format(error_msg), error=True)
 def gotId(self, data, file_):
 """Called when a progress id has been received
 @param pid(unicode): progress id
 @param file_(str): file path
 """
 # FIXME: this show progress only for last progress_id
-self.disp(_(u"File request sent to {jid}".format(jid=self.full_dest_jid)), 1)
+self.disp(_("File request sent to {jid}".format(jid=self.full_dest_jid)), 1)
 try:
 self.progress_id = data["progress"]
 except KeyError:
 # TODO: if 'xmlui' key is present, manage xmlui message display
 self.disp(
-_(u"Can't send file to {jid}".format(jid=self.full_dest_jid)), error=True
+_("Can't send file to {jid}".format(jid=self.full_dest_jid)), error=True
 )
 self.host.quit(2)
 def error(self, failure):
 self.disp(
 self.host.quit(1)
 def send_files(self):
 for file_ in self.args.files:
 if not os.path.exists(file_):
-self.disp(_(u"file [{}] doesn't exist !").format(file_), error=True)
+self.disp(_("file [{}] doesn't exist !").format(file_), error=True)
 self.host.quit(1)
 if not self.args.bz2 and os.path.isdir(file_):
 self.disp(
 _(
-u"[{}] is a dir ! Please send files inside or use compression"
+"[{}] is a dir ! Please send files inside or use compression"
 ).format(file_)
 )
 self.host.quit(1)
 self.full_dest_jid = self.host.get_full_jid(self.args.jid)
 extra = {}
 if self.args.path:
-extra[u"path"] = self.args.path
+extra["path"] = self.args.path
 if self.args.namespace:
-extra[u"namespace"] = self.args.namespace
+extra["namespace"] = self.args.namespace
 if self.args.bz2:
 with tempfile.NamedTemporaryFile("wb", delete=False) as buf:
 self.host.addOnQuitCallback(os.unlink, buf.name)
-self.disp(_(u"bz2 is an experimental option, use with caution"))
+self.disp(_("bz2 is an experimental option, use with caution"))
 # FIXME: check free space
-self.disp(_(u"Starting compression, please wait..."))
+self.disp(_("Starting compression, please wait..."))
 sys.stdout.flush()
 bz2 = tarfile.open(mode="w:bz2", fileobj=buf)
-archive_name = u"{}.tar.bz2".format(
+archive_name = "{}.tar.bz2".format(
-os.path.basename(self.args.files[0]) or u"compressed_files"
+os.path.basename(self.args.files[0]) or "compressed_files"
 )
 for file_ in self.args.files:
-self.disp(_(u"Adding {}").format(file_), 1)
+self.disp(_("Adding {}").format(file_), 1)
 bz2.add(file_)
 bz2.close()
-self.disp(_(u"Done !"), 1)
+self.disp(_("Done !"), 1)
 self.host.bridge.fileSend(
 self.full_dest_jid,
 buf.name,
 self.args.name or archive_name,
 )
 self.need_loop = True
 @property
 def filename(self):
-return self.args.name or self.args.hash or u"output"
+return self.args.name or self.args.hash or "output"
 def add_parser_options(self):
 self.parser.add_argument(
-"jid", type=base.unicode_decoder, help=_(u"the destination jid")
+"jid", help=_("the destination jid")
 )
 self.parser.add_argument(
 "-D",
 "--dest",
-type=base.unicode_decoder,
 help=_(
-u"destination path where the file will be saved (default: [current_dir]/[name|hash])"
+"destination path where the file will be saved (default: [current_dir]/[name|hash])"
 ),
 )
 self.parser.add_argument(
 "-n",
 "--name",
-type=base.unicode_decoder,
+default="",
-default=u"",
+help=_("name of the file"),
-help=_(u"name of the file"),
 )
 self.parser.add_argument(
 "-H",
 "--hash",
-type=base.unicode_decoder,
+default="",
-default=u"",
+help=_("hash of the file"),
-help=_(u"hash of the file"),
 )
 self.parser.add_argument(
 "-a",
 "--hash-algo",
-type=base.unicode_decoder,
+default="sha-256",
-default=u"sha-256",
+help=_("hash algorithm use for --hash (default: sha-256)"),
-help=_(u"hash algorithm use for --hash (default: sha-256)"),
 )
 self.parser.add_argument(
 "-d",
 "--path",
-type=base.unicode_decoder,
+help=("path to the directory containing the file"),
-help=(u"path to the directory containing the file"),
 )
 self.parser.add_argument(
 "-N",
 "--namespace",
-type=base.unicode_decoder,
+help=("namespace of the file"),
-help=(u"namespace of the file"),
 )
 self.parser.add_argument(
 "-f",
 "--force",
 action="store_true",
-help=_(u"overwrite existing file without confirmation"),
+help=_("overwrite existing file without confirmation"),
 )
 def onProgressStarted(self, metadata):
-self.disp(_(u"File copy started"), 2)
+self.disp(_("File copy started"), 2)
 def onProgressFinished(self, metadata):
-self.disp(_(u"File received successfully"), 2)
+self.disp(_("File received successfully"), 2)
 def onProgressError(self, error_msg):
 if error_msg == C.PROGRESS_ERROR_DECLINED:
-self.disp(_(u"The file request has been refused"))
+self.disp(_("The file request has been refused"))
 else:
-self.disp(_(u"Error while requesting file: {}").format(error_msg), error=True)
+self.disp(_("Error while requesting file: {}").format(error_msg), error=True)
 def gotId(self, progress_id):
 """Called when a progress id has been received
 @param progress_id(unicode): progress id
 )
 self.host.quit(1)
 def start(self):
 if not self.args.name and not self.args.hash:
-self.parser.error(_(u"at least one of --name or --hash must be provided"))
+self.parser.error(_("at least one of --name or --hash must be provided"))
 #  extra = dict(self.args.extra)
 if self.args.dest:
 path = os.path.abspath(os.path.expanduser(self.args.dest))
 if os.path.isdir(path):
 path = os.path.join(path, self.filename)
 else:
 path = os.path.abspath(self.filename)
 if os.path.exists(path) and not self.args.force:
-message = _(u"File {path} already exists! Do you want to overwrite?").format(
+message = _("File {path} already exists! Do you want to overwrite?").format(
 path=path
 )
-confirm = raw_input(u"{} (y/N) ".format(message).encode("utf-8"))
+confirm = input("{} (y/N) ".format(message).encode("utf-8"))
-if confirm not in (u"y", u"Y"):
+if confirm not in ("y", "Y"):
-self.disp(_(u"file request cancelled"))
+self.disp(_("file request cancelled"))
 self.host.quit(2)
 self.full_dest_jid = self.host.get_full_jid(self.args.jid)
 extra = {}
 if self.args.path:
-extra[u"path"] = self.args.path
+extra["path"] = self.args.path
 if self.args.namespace:
-extra[u"namespace"] = self.args.namespace
+extra["namespace"] = self.args.namespace
 self.host.bridge.fileJingleRequest(
 self.full_dest_jid,
 path,
 self.args.name,
 self.args.hash,
-self.args.hash_algo if self.args.hash else u"",
+self.args.hash_algo if self.args.hash else "",
 extra,
 self.profile,
 callback=self.gotId,
 errback=partial(
 self.errback,
-msg=_(u"can't request file: {}"),
+msg=_("can't request file: {}"),
 exit_code=C.EXIT_BRIDGE_ERRBACK,
 ),
 )
 C.META_TYPE_FILE: self.onFileAction,
 C.META_TYPE_OVERWRITE: self.onOverwriteAction,
 }
 def onProgressStarted(self, metadata):
-self.disp(_(u"File copy started"), 2)
+self.disp(_("File copy started"), 2)
 def onProgressFinished(self, metadata):
-self.disp(_(u"File received successfully"), 2)
+self.disp(_("File received successfully"), 2)
 if metadata.get("hash_verified", False):
 try:
 self.disp(
-_(u"hash checked: {algo}:{checksum}").format(
+_("hash checked: {algo}:{checksum}").format(
 algo=metadata["hash_algo"], checksum=metadata["hash"]
 ),
 1,
 )
 except KeyError:
-self.disp(_(u"hash is checked but hash value is missing", 1), error=True)
+self.disp(_("hash is checked but hash value is missing", 1), error=True)
 else:
-self.disp(_(u"hash can't be verified"), 1)
+self.disp(_("hash can't be verified"), 1)
 def onProgressError(self, error_msg):
-self.disp(_(u"Error while receiving file: {}").format(error_msg), error=True)
+self.disp(_("Error while receiving file: {}").format(error_msg), error=True)
 def getXmluiId(self, action_data):
 # FIXME: we temporarily use ElementTree, but a real XMLUI managing module
 #        should be available in the futur
 # TODO: XMLUI module
 try:
 xml_ui = action_data["xmlui"]
 except KeyError:
-self.disp(_(u"Action has no XMLUI"), 1)
+self.disp(_("Action has no XMLUI"), 1)
 else:
 ui = ET.fromstring(xml_ui.encode("utf-8"))
 xmlui_id = ui.get("submit")
 if not xmlui_id:
-self.disp(_(u"Invalid XMLUI received"), error=True)
+self.disp(_("Invalid XMLUI received"), error=True)
 return xmlui_id
 def onFileAction(self, action_data, action_id, security_limit, profile):
 xmlui_id = self.getXmluiId(action_data)
 if xmlui_id is None:
 return self.host.quitFromSignal(1)
 try:
 from_jid = jid.JID(action_data["meta_from_jid"])
 except KeyError:
-self.disp(_(u"Ignoring action without from_jid data"), 1)
+self.disp(_("Ignoring action without from_jid data"), 1)
 return
 try:
 progress_id = action_data["meta_progress_id"]
 except KeyError:
-self.disp(_(u"ignoring action without progress id"), 1)
+self.disp(_("ignoring action without progress id"), 1)
 return
 if not self.bare_jids or from_jid.bare in self.bare_jids:
 if self._overwrite_refused:
-self.disp(_(u"File refused because overwrite is needed"), error=True)
+self.disp(_("File refused because overwrite is needed"), error=True)
 self.host.bridge.launchAction(
 xmlui_id, {"cancelled": C.BOOL_TRUE}, profile_key=profile
 )
 return self.host.quitFromSignal(2)
 self.progress_id = progress_id
 if xmlui_id is None:
 return self.host.quitFromSignal(1)
 try:
 progress_id = action_data["meta_progress_id"]
 except KeyError:
-self.disp(_(u"ignoring action without progress id"), 1)
+self.disp(_("ignoring action without progress id"), 1)
 return
-self.disp(_(u"Overwriting needed"), 1)
+self.disp(_("Overwriting needed"), 1)
 if progress_id == self.progress_id:
 if self.args.force:
-self.disp(_(u"Overwrite accepted"), 2)
+self.disp(_("Overwrite accepted"), 2)
 else:
-self.disp(_(u"Refused to overwrite"), 2)
+self.disp(_("Refused to overwrite"), 2)
 self._overwrite_refused = True
 xmlui_data = {"answer": C.boolConst(self.args.force)}
 self.host.bridge.launchAction(xmlui_id, xmlui_data, profile_key=profile)
 def add_parser_options(self):
 self.parser.add_argument(
 "jids",
-type=base.unicode_decoder,
 nargs="*",
-help=_(u"jids accepted (accept everything if none is specified)"),
+help=_("jids accepted (accept everything if none is specified)"),
 )
 self.parser.add_argument(
 "-m",
 "--multiple",
 action="store_true",
-help=_(u"accept multiple files (you'll have to stop manually)"),
+help=_("accept multiple files (you'll have to stop manually)"),
 )
 self.parser.add_argument(
 "-f",
 "--force",
 action="store_true",
 help=_(
-u"force overwritting of existing files (/!\\ name is choosed by sender)"
+"force overwritting of existing files (/!\\ name is choosed by sender)"
 ),
 )
 self.parser.add_argument(
 "--path",
 default=".",
 metavar="DIR",
-help=_(u"destination path (default: working directory)"),
+help=_("destination path (default: working directory)"),
 )
 def start(self):
 self.bare_jids = [jid.JID(jid_).bare for jid_ in self.args.jids]
 self.path = os.path.abspath(self.args.path)
 if not os.path.isdir(self.path):
-self.disp(_(u"Given path is not a directory !", error=True))
+self.disp(_("Given path is not a directory !", error=True))
 self.host.quit(2)
 if self.args.multiple:
 self.host.quit_on_progress_end = False
-self.disp(_(u"waiting for incoming file request"), 2)
+self.disp(_("waiting for incoming file request"), 2)
 class Upload(base.CommandBase):
 def __init__(self, host):
 super(Upload, self).__init__(
 def add_parser_options(self):
 self.parser.add_argument("file", type=str, help=_("file to upload"))
 self.parser.add_argument(
 "jid",
-type=base.unicode_decoder,
 nargs="?",
 help=_("jid of upload component (nothing to autodetect)"),
 )
 self.parser.add_argument(
 "--ignore-tls-errors",
 action="store_true",
 help=_("ignore invalide TLS certificate"),
 )
 def onProgressStarted(self, metadata):
-self.disp(_(u"File upload started"), 2)
+self.disp(_("File upload started"), 2)
 def onProgressFinished(self, metadata):
-self.disp(_(u"File uploaded successfully"), 2)
+self.disp(_("File uploaded successfully"), 2)
 try:
 url = metadata["url"]
 except KeyError:
-self.disp(u"download URL not found in metadata")
+self.disp("download URL not found in metadata")
 else:
-self.disp(_(u"URL to retrieve the file:"), 1)
+self.disp(_("URL to retrieve the file:"), 1)
 # XXX: url is display alone on a line to make parsing easier
 self.disp(url)
 def onProgressError(self, error_msg):
-self.disp(_(u"Error while uploading file: {}").format(error_msg), error=True)
+self.disp(_("Error while uploading file: {}").format(error_msg), error=True)
 def gotId(self, data, file_):
 """Called when a progress id has been received
 @param pid(unicode): progress id
 """
 try:
 self.progress_id = data["progress"]
 except KeyError:
 # TODO: if 'xmlui' key is present, manage xmlui message display
-self.disp(_(u"Can't upload file"), error=True)
+self.disp(_("Can't upload file"), error=True)
 self.host.quit(2)
 def error(self, failure):
 self.disp(
 _("Error while trying to upload a file: {reason}").format(reason=failure),
 self.host.quit(1)
 def start(self):
 file_ = self.args.file
 if not os.path.exists(file_):
-self.disp(_(u"file [{}] doesn't exist !").format(file_), error=True)
+self.disp(_("file [{}] doesn't exist !").format(file_), error=True)
 self.host.quit(1)
 if os.path.isdir(file_):
-self.disp(_(u"[{}] is a dir! Can't upload a dir").format(file_))
+self.disp(_("[{}] is a dir! Can't upload a dir").format(file_))
 self.host.quit(1)
 self.full_dest_jid = (
 self.host.get_full_jid(self.args.jid) if self.args.jid is not None else ""
 )
 super(ShareList, self).__init__(
 host,
 "list",
 use_output=C.OUTPUT_LIST_DICT,
 extra_outputs=extra_outputs,
-help=_(u"retrieve files shared by an entity"),
+help=_("retrieve files shared by an entity"),
 use_verbose=True,
 )
 self.need_loop = True
 def add_parser_options(self):
 self.parser.add_argument(
 "-d",
 "--path",
-default=u"",
+default="",
-help=_(u"path to the directory containing the files"),
+help=_("path to the directory containing the files"),
 )
 self.parser.add_argument(
 "jid",
-type=base.unicode_decoder,
 nargs="?",
 default="",
 help=_("jid of sharing entity (nothing to check our own jid)"),
 )
 def file_gen(self, files_data):
 for file_data in files_data:
-yield file_data[u"name"]
+yield file_data["name"]
-yield file_data.get(u"size", "")
+yield file_data.get("size", "")
-yield file_data.get(u"hash", "")
+yield file_data.get("hash", "")
 def _name_filter(self, name, row):
 if row.type == C.FILE_TYPE_DIRECTORY:
 return A.color(C.A_DIRECTORY, name)
 elif row.type == C.FILE_TYPE_FILE:
 return A.color(C.A_FILE, name)
 else:
-self.disp(_(u"unknown file type: {type}").format(type=row.type), error=True)
+self.disp(_("unknown file type: {type}").format(type=row.type), error=True)
 return name
 def _size_filter(self, size, row):
 if not size:
-return u""
+return ""
 size = int(size)
 #  cf. https://stackoverflow.com/a/1094933 (thanks)
-suffix = u"o"
+suffix = "o"
-for unit in [u"", u"Ki", u"Mi", u"Gi", u"Ti", u"Pi", u"Ei", u"Zi"]:
+for unit in ["", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi"]:
 if abs(size) < 1024.0:
-return A.color(A.BOLD, u"{:.2f}".format(size), unit, suffix)
+return A.color(A.BOLD, "{:.2f}".format(size), unit, suffix)
 size /= 1024.0
-return A.color(A.BOLD, u"{:.2f}".format(size), u"Yi", suffix)
+return A.color(A.BOLD, "{:.2f}".format(size), "Yi", suffix)
 def default_output(self, files_data):
 """display files a way similar to ls"""
 files_data.sort(key=lambda d: d["name"].lower())
 show_header = False
 if self.verbosity == 0:
-headers = (u"name", u"type")
+headers = ("name", "type")
 elif self.verbosity == 1:
-headers = (u"name", u"type", u"size")
+headers = ("name", "type", "size")
 elif self.verbosity > 1:
 show_header = True
-headers = (u"name", u"type", u"size", u"hash")
+headers = ("name", "type", "size", "hash")
 table = common.Table.fromDict(
 self.host,
 files_data,
 headers,
-filters={u"name": self._name_filter, u"size": self._size_filter},
+filters={"name": self._name_filter, "size": self._size_filter},
-defaults={u"size": u"", u"hash": u""},
+defaults={"size": "", "hash": ""},
 )
 table.display_blank(show_header=show_header, hide_cols=["type"])
 def _FISListCb(self, files_data):
 self.output(files_data)
 {},
 self.profile,
 callback=self._FISListCb,
 errback=partial(
 self.errback,
-msg=_(u"can't retrieve shared files: {}"),
+msg=_("can't retrieve shared files: {}"),
 exit_code=C.EXIT_BRIDGE_ERRBACK,
 ),
 )
 class SharePath(base.CommandBase):
 def __init__(self, host):
 super(SharePath, self).__init__(
-host, "path", help=_(u"share a file or directory"), use_verbose=True
+host, "path", help=_("share a file or directory"), use_verbose=True
 )
 self.need_loop = True
 def add_parser_options(self):
 self.parser.add_argument(
 "-n",
 "--name",
-type=base.unicode_decoder,
+default="",
-default=u"",
+help=_("virtual name to use (default: use directory/file name)"),
-help=_(u"virtual name to use (default: use directory/file name)"),
 )
 perm_group = self.parser.add_mutually_exclusive_group()
 perm_group.add_argument(
 "-j",
 "--jid",
-type=base.unicode_decoder,
 action="append",
 dest="jids",
 default=[],
-help=_(u"jid of contacts allowed to retrieve the files"),
+help=_("jid of contacts allowed to retrieve the files"),
 )
 perm_group.add_argument(
 "--public",
 action="store_true",
 help=_(
-u"share publicly the file(s) (/!\\ *everybody* will be able to access them)"
+"share publicly the file(s) (/!\\ *everybody* will be able to access them)"
 ),
 )
 self.parser.add_argument(
 "path",
-type=base.unicode_decoder,
+help=_("path to a file or directory to share"),
-help=_(u"path to a file or directory to share"),
 )
 def _FISSharePathCb(self, name):
 self.disp(
-_(u'{path} shared under the name "{name}"').format(path=self.path, name=name)
+_('{path} shared under the name "{name}"').format(path=self.path, name=name)
 )
 self.host.quit()
 def start(self):
 self.path = os.path.abspath(self.args.path)
 if self.args.public:
-access = {u"read": {u"type": u"public"}}
+access = {"read": {"type": "public"}}
 else:
 jids = self.args.jids
 if jids:
-access = {u"read": {u"type": "whitelist", u"jids": jids}}
+access = {"read": {"type": "whitelist", "jids": jids}}
 else:
 access = {}
 self.host.bridge.FISSharePath(
 self.args.name,
 self.path,
 json.dumps(access, ensure_ascii=False),
 self.profile,
 callback=self._FISSharePathCb,
 errback=partial(
 self.errback,
-msg=_(u"can't share path: {}"),
+msg=_("can't share path: {}"),
 exit_code=C.EXIT_BRIDGE_ERRBACK,
 ),
 )
 class ShareInvite(base.CommandBase):
 def __init__(self, host):
 super(ShareInvite, self).__init__(
-host, "invite", help=_(u"send invitation for a shared repository")
+host, "invite", help=_("send invitation for a shared repository")
 )
 self.need_loop = True
 def add_parser_options(self):
 self.parser.add_argument(
 "-n",
 "--name",
-type=base.unicode_decoder,
+default="",
-default=u"",
+help=_("name of the repository"),
-help=_(u"name of the repository"),
 )
 self.parser.add_argument(
 "-N",
 "--namespace",
-type=base.unicode_decoder,
+default="",
-default=u"",
+help=_("namespace of the repository"),
-help=_(u"namespace of the repository"),
 )
 self.parser.add_argument(
 "-P",
 "--path",
-type=base.unicode_decoder,
+help=_("path to the repository"),
-help=_(u"path to the repository"),
 )
 self.parser.add_argument(
 "-t",
 "--type",
-choices=[u"files", u"photos"],
+choices=["files", "photos"],
-default=u"files",
+default="files",
-help=_(u"type of the repository"),
+help=_("type of the repository"),
 )
 self.parser.add_argument(
 "-T",
 "--thumbnail",
-type=base.unicode_decoder,
+help=_("https URL of a image to use as thumbnail"),
-help=_(u"https URL of a image to use as thumbnail"),
 )
 self.parser.add_argument(
 "service",
-type=base.unicode_decoder,
+help=_("jid of the file sharing service hosting the repository"),
-help=_(u"jid of the file sharing service hosting the repository"),
 )
 self.parser.add_argument(
 "jid",
-type=base.unicode_decoder,
+help=_("jid of the person to invite"),
-help=_(u"jid of the person to invite"),
 )
 def _FISInviteCb(self):
 self.disp(
-_(u'invitation sent to {entity}').format(entity=self.args.jid)
+_('invitation sent to {entity}').format(entity=self.args.jid)
 )
 self.host.quit()
 def start(self):
-self.path = os.path.normpath(self.args.path) if self.args.path else u""
+self.path = os.path.normpath(self.args.path) if self.args.path else ""
 extra = {}
 if self.args.thumbnail is not None:
-if not self.args.thumbnail.startswith(u'http'):
+if not self.args.thumbnail.startswith('http'):
-self.parser.error(_(u"only http(s) links are allowed with --thumbnail"))
+self.parser.error(_("only http(s) links are allowed with --thumbnail"))
 else:
-extra[u'thumb_url'] = self.args.thumbnail
+extra['thumb_url'] = self.args.thumbnail
 self.host.bridge.FISInvite(
 self.args.jid,
 self.args.service,
 self.args.type,
 self.args.namespace,
 data_format.serialise(extra),
 self.profile,
 callback=self._FISInviteCb,
 errback=partial(
 self.errback,
-msg=_(u"can't send invitation: {}"),
+msg=_("can't send invitation: {}"),
 exit_code=C.EXIT_BRIDGE_ERRBACK,
 ),
 )
 class Share(base.CommandBase):
 subcommands = (ShareList, SharePath, ShareInvite)
 def __init__(self, host):
 super(Share, self).__init__(
-host, "share", use_profile=False, help=_(u"files sharing management")
+host, "share", use_profile=False, help=_("files sharing management")
 )
 class File(base.CommandBase):
 subcommands = (Send, Request, Receive, Upload, Share)
 def __init__(self, host):
 super(File, self).__init__(
-host, "file", use_profile=False, help=_(u"files sending/receiving/management")
+host, "file", use_profile=False, help=_("files sending/receiving/management")
 )

Mercurial > libervia-backend

comparison sat_frontends/jp/cmd_file.py @ 3028:ab2696e34d29