libervia-backend: sat_frontends/jp/cmd

comparison sat_frontends/jp/cmd_blog.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	d603550d5e99
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
 from sat.core.i18n import _
 from sat_frontends.jp.constants import Const as C
 from sat_frontends.jp import common
 from sat.tools.common.ansi import ANSI as A
 from sat.tools.common import data_objects
 from sat.tools.common import uri
 from sat.tools import config
-from ConfigParser import NoSectionError, NoOptionError
+from configparser import NoSectionError, NoOptionError
 from functools import partial
 import json
 import sys
 import os.path
 import os
 import codecs
 from sat.tools.common import data_format
 __commands__ = ["Blog"]
-SYNTAX_XHTML = u"xhtml"
+SYNTAX_XHTML = "xhtml"
 # extensions to use with known syntaxes
 SYNTAX_EXT = {
 # FIXME: default syntax doesn't sounds needed, there should always be a syntax set
 #        by the plugin.
 "": "txt",  # used when the syntax is not found
 SYNTAX_XHTML: "xhtml",
 "markdown": "md",
 }
-CONF_SYNTAX_EXT = u"syntax_ext_dict"
+CONF_SYNTAX_EXT = "syntax_ext_dict"
-BLOG_TMP_DIR = u"blog"
+BLOG_TMP_DIR = "blog"
 # key to remove from metadata tmp file if they exist
 KEY_TO_REMOVE_METADATA = (
 "id",
 "content",
 "content_xhtml",
 )
 URL_REDIRECT_PREFIX = "url_redirect_"
 INOTIFY_INSTALL = '"pip install inotify"'
 MB_KEYS = (
-u"id",
+"id",
-u"url",
+"url",
-u"atom_id",
+"atom_id",
-u"updated",
+"updated",
-u"published",
+"published",
-u"language",
+"language",
-u"comments",  # this key is used for all comments* keys
+"comments",  # this key is used for all comments* keys
-u"tags",  # this key is used for all tag* keys
+"tags",  # this key is used for all tag* keys
-u"author",
+"author",
-u"author_jid",
+"author_jid",
-u"author_email",
+"author_email",
-u"author_jid_verified",
+"author_jid_verified",
-u"content",
+"content",
-u"content_xhtml",
+"content_xhtml",
-u"title",
+"title",
-u"title_xhtml",
+"title_xhtml",
 )
-OUTPUT_OPT_NO_HEADER = u"no-header"
+OUTPUT_OPT_NO_HEADER = "no-header"
 def guessSyntaxFromPath(host, sat_conf, path):
 """Return syntax guessed according to filename extension
 @return(unicode): syntax to use
 """
 # we first try to guess syntax with extension
 ext = os.path.splitext(path)[1][1:]  # we get extension without the '.'
 if ext:
-for k, v in SYNTAX_EXT.iteritems():
+for k, v in SYNTAX_EXT.items():
 if k and ext == v:
 return k
 # if not found, we use current syntax
 return host.bridge.getParamA("Syntax", "Composition", "value", host.profile)
 )
 return self._current_syntax
 def add_parser_options(self):
 self.parser.add_argument(
-"-T", "--title", type=base.unicode_decoder, help=_(u"title of the item")
+"-T", "--title", help=_("title of the item")
 )
 self.parser.add_argument(
 "-t",
 "--tag",
-type=base.unicode_decoder,
 action="append",
-help=_(u"tag (category) of your item"),
+help=_("tag (category) of your item"),
 )
 comments_group = self.parser.add_mutually_exclusive_group()
 comments_group.add_argument(
 "-C", "--comments", action="store_const", const=True, dest="comments",
-help=_(u"enable comments (default: comments not enabled except if they "
+help=_("enable comments (default: comments not enabled except if they "
-u"already exist)")
+"already exist)")
 )
 comments_group.add_argument(
 "--no-comments", action="store_const", const=False, dest="comments",
-help=_(u"disable comments (will remove comments node if it exist)")
+help=_("disable comments (will remove comments node if it exist)")
 )
 self.parser.add_argument(
 "-S",
 "--syntax",
-type=base.unicode_decoder,
+help=_("syntax to use (default: get profile's default syntax)"),
-help=_(u"syntax to use (default: get profile's default syntax)"),
 )
 def setMbDataContent(self, content, mb_data):
 if self.args.syntax is None:
 # default syntax has been used
 if metadata already exist, it will be overwritten
 """
 if self.args.comments is not None:
 mb_data["allow_comments"] = self.args.comments
 if self.args.tag:
-mb_data[u'tags'] = self.args.tag
+mb_data['tags'] = self.args.tag
 if self.args.title is not None:
 mb_data["title"] = self.args.title
 class Set(base.CommandBase, BlogPublishCommon):
 self,
 host,
 "set",
 use_pubsub=True,
 pubsub_flags={C.SINGLE_ITEM},
-help=_(u"publish a new blog item or update an existing one"),
+help=_("publish a new blog item or update an existing one"),
 )
 BlogPublishCommon.__init__(self)
 self.need_loop = True
 def add_parser_options(self):
 BlogPublishCommon.add_parser_options(self)
 def mbSendCb(self):
-self.disp(u"Item published")
+self.disp("Item published")
 self.host.quit(C.EXIT_OK)
 def start(self):
 self._current_syntax = self.args.syntax
 self.pubsub_item = self.args.item
 data_format.serialise(mb_data),
 self.profile,
 callback=self.exitCb,
 errback=partial(
 self.errback,
-msg=_(u"can't send item: {}"),
+msg=_("can't send item: {}"),
 exit_code=C.EXIT_BRIDGE_ERRBACK,
 ),
 )
 class Get(base.CommandBase):
-TEMPLATE = u"blog/articles.html"
+TEMPLATE = "blog/articles.html"
 def __init__(self, host):
 extra_outputs = {"default": self.default_output, "fancy": self.fancy_output}
 base.CommandBase.__init__(
 self,
 use_verbose=True,
 use_pubsub=True,
 pubsub_flags={C.MULTI_ITEMS},
 use_output=C.OUTPUT_COMPLEX,
 extra_outputs=extra_outputs,
-help=_(u"get blog item(s)"),
+help=_("get blog item(s)"),
 )
 self.need_loop = True
 def add_parser_options(self):
 #  TODO: a key(s) argument to select keys to display
 self.parser.add_argument(
 "-k",
 "--key",
-type=base.unicode_decoder,
 action="append",
 dest="keys",
-help=_(u"microblog data key(s) to display (default: depend of verbosity)"),
+help=_("microblog data key(s) to display (default: depend of verbosity)"),
 )
 # TODO: add MAM filters
 def template_data_mapping(self, data):
-return {u"items": data_objects.BlogItems(data, deserialise=False)}
+return {"items": data_objects.BlogItems(data, deserialise=False)}
 def format_comments(self, item, keys):
 comments_data = data_format.dict2iterdict(
-u"comments", item, (u"node", u"service"), pop=True
+"comments", item, ("node", "service"), pop=True
 )
 lines = []
 for data in comments_data:
-lines.append(data[u"comments"])
+lines.append(data["comments"])
-for k in (u"node", u"service"):
+for k in ("node", "service"):
 if OUTPUT_OPT_NO_HEADER in self.args.output_opts:
-header = u""
+header = ""
 else:
-header = C.A_HEADER + k + u": " + A.RESET
+header = C.A_HEADER + k + ": " + A.RESET
 lines.append(header + data[k])
-return u"\n".join(lines)
+return "\n".join(lines)
 def format_tags(self, item, keys):
-tags = item.pop(u'tags', [])
+tags = item.pop('tags', [])
-return u", ".join(tags)
+return ", ".join(tags)
 def format_updated(self, item, keys):
 return self.format_time(item["updated"])
 def format_published(self, item, keys):
 return self.format_time(item["published"])
 def format_url(self, item, keys):
 return uri.buildXMPPUri(
-u"pubsub",
+"pubsub",
-subtype=u"microblog",
+subtype="microblog",
-path=self.metadata[u"service"],
+path=self.metadata["service"],
-node=self.metadata[u"node"],
+node=self.metadata["node"],
-item=item[u"id"],
+item=item["id"],
 )
 def get_keys(self):
 """return keys to display according to verbosity or explicit key request"""
 verbosity = self.args.verbose
 if self.args.keys:
 if not set(MB_KEYS).issuperset(self.args.keys):
 self.disp(
-u"following keys are invalid: {invalid}.\n"
+"following keys are invalid: {invalid}.\n"
-u"Valid keys are: {valid}.".format(
+"Valid keys are: {valid}.".format(
-invalid=u", ".join(set(self.args.keys).difference(MB_KEYS)),
+invalid=", ".join(set(self.args.keys).difference(MB_KEYS)),
-valid=u", ".join(sorted(MB_KEYS)),
+valid=", ".join(sorted(MB_KEYS)),
 ),
 error=True,
 )
 self.host.quit(C.EXIT_BAD_ARG)
 return self.args.keys
 else:
 if verbosity == 0:
-return (u"title", u"content")
+return ("title", "content")
 elif verbosity == 1:
 return (
-u"title",
+"title",
-u"tags",
+"tags",
-u"author",
+"author",
-u"author_jid",
+"author_jid",
-u"author_email",
+"author_email",
-u"author_jid_verified",
+"author_jid_verified",
-u"published",
+"published",
-u"updated",
+"updated",
-u"content",
+"content",
 )
 else:
 return MB_KEYS
 def default_output(self, data):
 if k not in item and k not in k_cb:
 continue
 if OUTPUT_OPT_NO_HEADER in self.args.output_opts:
 header = ""
 else:
-header = u"{k_fmt}{key}:{k_fmt_e} {sep}".format(
+header = "{k_fmt}{key}:{k_fmt_e} {sep}".format(
 k_fmt=C.A_HEADER,
 key=k,
 k_fmt_e=A.RESET,
-sep=u"\n" if "content" in k else u"",
+sep="\n" if "content" in k else "",
 )
 value = k_cb[k](item, keys) if k in k_cb else item[k]
 if isinstance(value, bool):
-value = unicode(value).lower()
+value = str(value).lower()
 self.disp(header + value)
 # we want a separation line after each item but the last one
 if idx < len(items) - 1:
-print(u"")
+print("")
 def format_time(self, timestamp):
 """return formatted date for timestamp
 @param timestamp(str,int,float): unix timestamp
 @return (unicode): formatted date
 """
-fmt = u"%d/%m/%Y %H:%M:%S"
+fmt = "%d/%m/%Y %H:%M:%S"
 return time.strftime(fmt, time.localtime(float(timestamp)))
 def fancy_output(self, data):
 """display blog is a nice to read way
 this output doesn't use keys filter
 """
 # thanks to http://stackoverflow.com/a/943921
-rows, columns = map(int, os.popen("stty size", "r").read().split())
+rows, columns = list(map(int, os.popen("stty size", "r").read().split()))
 items, metadata = data
 verbosity = self.args.verbose
-sep = A.color(A.FG_BLUE, columns * u"▬")
+sep = A.color(A.FG_BLUE, columns * "▬")
 if items:
-print(u"\n" + sep + "\n")
+print(("\n" + sep + "\n"))
 for idx, item in enumerate(items):
-title = item.get(u"title")
+title = item.get("title")
 if verbosity > 0:
-author = item[u"author"]
+author = item["author"]
-published, updated = item[u"published"], item.get("updated")
+published, updated = item["published"], item.get("updated")
 else:
 author = published = updated = None
 if verbosity > 1:
 tags = item.pop('tags', [])
 else:
 tags = None
-content = item.get(u"content")
+content = item.get("content")
 if title:
-print(A.color(A.BOLD, A.FG_CYAN, item[u"title"]))
+print((A.color(A.BOLD, A.FG_CYAN, item["title"])))
 meta = []
 if author:
 meta.append(A.color(A.FG_YELLOW, author))
 if published:
-meta.append(A.color(A.FG_YELLOW, u"on ", self.format_time(published)))
+meta.append(A.color(A.FG_YELLOW, "on ", self.format_time(published)))
 if updated != published:
 meta.append(
-A.color(A.FG_YELLOW, u"(updated on ", self.format_time(updated), u")")
+A.color(A.FG_YELLOW, "(updated on ", self.format_time(updated), ")")
 )
-print(u" ".join(meta))
+print((" ".join(meta)))
 if tags:
-print(A.color(A.FG_MAGENTA, u", ".join(tags)))
+print((A.color(A.FG_MAGENTA, ", ".join(tags))))
 if (title or tags) and content:
 print("")
 if content:
 self.disp(content)
-print(u"\n" + sep + "\n")
+print(("\n" + sep + "\n"))
 def mbGetCb(self, mb_result):
 items, metadata = mb_result
 items = [data_format.deserialise(i) for i in items]
 mb_result = items, metadata
 self.output(mb_result)
 self.host.quit(C.EXIT_OK)
 def mbGetEb(self, failure_):
-self.disp(u"can't get blog items: {reason}".format(reason=failure_), error=True)
+self.disp("can't get blog items: {reason}".format(reason=failure_), error=True)
 self.host.quit(C.EXIT_BRIDGE_ERRBACK)
 def start(self):
 self.host.bridge.mbGet(
 self.args.service,
 "edit",
 use_pubsub=True,
 pubsub_flags={C.SINGLE_ITEM},
 use_draft=True,
 use_verbose=True,
-help=_(u"edit an existing or new blog post"),
+help=_("edit an existing or new blog post"),
 )
 BlogPublishCommon.__init__(self)
 common.BaseEdit.__init__(self, self.host, BLOG_TMP_DIR, use_metadata=True)
 def add_parser_options(self):
 BlogPublishCommon.add_parser_options(self)
 self.parser.add_argument(
 "-P",
 "--preview",
 action="store_true",
-help=_(u"launch a blog preview in parallel"),
+help=_("launch a blog preview in parallel"),
 )
 def buildMetadataFile(self, content_file_path, mb_data=None):
 """Build a metadata file using json
 """
 # we first construct metadata from edited item ones and CLI argumments
 # or re-use the existing one if it exists
 meta_file_path = os.path.splitext(content_file_path)[0] + common.METADATA_SUFF
 if os.path.exists(meta_file_path):
-self.disp(u"Metadata file already exists, we re-use it")
+self.disp("Metadata file already exists, we re-use it")
 try:
 with open(meta_file_path, "rb") as f:
 mb_data = json.load(f)
 except (OSError, IOError, ValueError) as e:
 self.disp(
-u"Can't read existing metadata file at {path}, aborting: {reason}".format(
+"Can't read existing metadata file at {path}, aborting: {reason}".format(
 path=meta_file_path, reason=e
 ),
 error=True,
 )
 self.host.quit(1)
 # we first create metadata file
 meta_ori, meta_file_path = self.buildMetadataFile(content_file_path, mb_data)
 # do we need a preview ?
 if self.args.preview:
-self.disp(u"Preview requested, launching it", 1)
+self.disp("Preview requested, launching it", 1)
 # we redirect outputs to /dev/null to avoid console pollution in editor
 # if user wants to see messages, (s)he can call "blog preview" directly
 DEVNULL = open(os.devnull, "wb")
 subprocess.Popen(
 [
 mb_data = data_format.serialise(mb_data)
 self.host.bridge.mbSend(
 self.pubsub_service, self.pubsub_node, mb_data, self.profile
 )
-self.disp(u"Blog item published")
+self.disp("Blog item published")
 def getTmpSuff(self):
 # we get current syntax to determine file extension
 return SYNTAX_EXT.get(self.current_syntax, SYNTAX_EXT[""])
 content, SYNTAX_XHTML, self.current_syntax, False, self.profile
 )
 if content and self.current_syntax == SYNTAX_XHTML:
 content = content.strip()
 if not content.startswith('<div>'):
-content = u'<div>' + content + u'</div>'
+content = '<div>' + content + '</div>'
 try:
 from lxml import etree
 except ImportError:
-self.disp(_(u"You need lxml to edit pretty XHTML"))
+self.disp(_("You need lxml to edit pretty XHTML"))
 else:
 parser = etree.XMLParser(remove_blank_text=True)
 root = etree.fromstring(content, parser)
-content = etree.tostring(root, encoding=unicode, pretty_print=True)
+content = etree.tostring(root, encoding=str, pretty_print=True)
 return content, mb_data, mb_data["id"]
 def start(self):
 # if there are user defined extension, we use them
 try:
 self._current_syntax = self.args.syntax = self.host.bridge.syntaxGet(
 self.current_syntax
 )
 except Exception as e:
-if "NotFound" in unicode(
+if "NotFound" in str(
 e
 ):  #  FIXME: there is not good way to check bridge errors
 self.parser.error(
-_(u"unknown syntax requested ({syntax})").format(
+_("unknown syntax requested ({syntax})").format(
 syntax=self.args.syntax
 )
 )
 else:
 raise e
 class Preview(base.CommandBase, common.BaseEdit):
 # TODO: need to be rewritten with template output
 def __init__(self, host):
 base.CommandBase.__init__(
-self, host, "preview", use_verbose=True, help=_(u"preview a blog content")
+self, host, "preview", use_verbose=True, help=_("preview a blog content")
 )
 common.BaseEdit.__init__(self, self.host, BLOG_TMP_DIR, use_metadata=True)
 def add_parser_options(self):
 self.parser.add_argument(
 "--inotify",
 type=str,
 choices=("auto", "true", "false"),
-default=u"auto",
+default="auto",
-help=_(u"use inotify to handle preview"),
+help=_("use inotify to handle preview"),
 )
 self.parser.add_argument(
 "file",
-type=base.unicode_decoder,
 nargs="?",
-default=u"current",
+default="current",
-help=_(u"path to the content file"),
+help=_("path to the content file"),
 )
 def showPreview(self):
 # we implement showPreview here so we don't have to import webbrowser and urllib
 # when preview is not used
 args = common.parse_args(
 self.host, cmd_line, url=url, preview_file=self.preview_file_path
 )
 if not args:
 self.disp(
-u'Couln\'t find command in "{name}", abording'.format(name=opt_name),
+'Couln\'t find command in "{name}", abording'.format(name=opt_name),
 error=True,
 )
 self.host.quit(1)
 subprocess.Popen(args)
 content = self.host.bridge.syntaxConvert(
 content, self.syntax, SYNTAX_XHTML, True, self.profile
 )
 xhtml = (
-u'<html xmlns="http://www.w3.org/1999/xhtml">'
+'<html xmlns="http://www.w3.org/1999/xhtml">'
-u'<head><meta http-equiv="Content-Type" content="text/html;charset=utf-8" />'
+'<head><meta http-equiv="Content-Type" content="text/html;charset=utf-8" />'
-u"</head>"
+"</head>"
-u"<body>{}</body>"
+"<body>{}</body>"
-u"</html>"
+"</html>"
 ).format(content)
 with open(self.preview_file_path, "wb") as f:
 f.write(xhtml.encode("utf-8"))
 def start(self):
 import webbrowser
-import urllib
+import urllib.request, urllib.parse, urllib.error
 self.webbrowser, self.urllib = webbrowser, urllib
 if self.args.inotify != "false":
 try:
 from inotify.calls import InotifyError
 except ImportError:
 if self.args.inotify == "auto":
 inotify = None
 self.disp(
-u"inotify module not found, deactivating feature. You can install"
+"inotify module not found, deactivating feature. You can install"
-u" it with {install}".format(install=INOTIFY_INSTALL)
+" it with {install}".format(install=INOTIFY_INSTALL)
 )
 else:
 self.disp(
-u"inotify not found, can't activate the feature! Please install "
+"inotify not found, can't activate the feature! Please install "
-u"it with {install}".format(install=INOTIFY_INSTALL),
+"it with {install}".format(install=INOTIFY_INSTALL),
 error=True,
 )
 self.host.quit(1)
 else:
 # we deactivate logging in inotify, which is quite annoying
 try:
 inotify.adapters._LOGGER.setLevel(40)
 except AttributeError:
 self.disp(
-u"Logger doesn't exists, inotify may have chanded", error=True
+"Logger doesn't exists, inotify may have chanded", error=True
 )
 else:
 inotify = None
 sat_conf = config.parseMainConf()
 if inotify is None:
 # XXX: we don't delete file automatically because browser need it
 #      (and webbrowser.open can return before it is read)
 self.disp(
-u"temporary file created at {}\nthis file will NOT BE DELETED "
+"temporary file created at {}\nthis file will NOT BE DELETED "
-u"AUTOMATICALLY, please delete it yourself when you have finished".format(
+"AUTOMATICALLY, please delete it yourself when you have finished".format(
 self.preview_file_path
 )
 )
 open_cb()
 else:
 add_watch()
 try:
 for event in i.event_gen():
 if event is not None:
-self.disp(u"Content updated", 1)
+self.disp("Content updated", 1)
 if {"IN_DELETE_SELF", "IN_MOVE_SELF"}.intersection(event[1]):
 self.disp(
-u"{} event catched, changing the watch".format(
+"{} event catched, changing the watch".format(
 ", ".join(event[1])
 ),
 2,
 )
 i.remove_watch(self.content_file_path)
 add_watch()
 self.updateContent()
 update_cb()
 except InotifyError:
 self.disp(
-u"Can't catch inotify events, as the file been deleted?", error=True
+"Can't catch inotify events, as the file been deleted?", error=True
 )
 finally:
 os.unlink(self.preview_file_path)
 try:
 i.remove_watch(self.content_file_path)
 super(Import, self).__init__(
 host,
 "import",
 use_pubsub=True,
 use_progress=True,
-help=_(u"import an external blog"),
+help=_("import an external blog"),
 )
 self.need_loop = True
 def add_parser_options(self):
 self.parser.add_argument(
 "importer",
-type=base.unicode_decoder,
 nargs="?",
-help=_(u"importer name, nothing to display importers list"),
+help=_("importer name, nothing to display importers list"),
 )
 self.parser.add_argument(
-"--host", type=base.unicode_decoder, help=_(u"original blog host")
+"--host", help=_("original blog host")
 )
 self.parser.add_argument(
 "--no-images-upload",
 action="store_true",
-help=_(u"do *NOT* upload images (default: do upload images)"),
+help=_("do *NOT* upload images (default: do upload images)"),
 )
 self.parser.add_argument(
 "--upload-ignore-host",
-help=_(u"do not upload images from this host (default: upload all images)"),
+help=_("do not upload images from this host (default: upload all images)"),
 )
 self.parser.add_argument(
 "--ignore-tls-errors",
 action="store_true",
 help=_("ignore invalide TLS certificate for uploads"),
 "-o",
 "--option",
 action="append",
 nargs=2,
 default=[],
-metavar=(u"NAME", u"VALUE"),
+metavar=("NAME", "VALUE"),
-help=_(u"importer specific options (see importer description)"),
+help=_("importer specific options (see importer description)"),
 )
 self.parser.add_argument(
 "location",
-type=base.unicode_decoder,
 nargs="?",
 help=_(
-u"importer data location (see importer description), nothing to show "
+"importer data location (see importer description), nothing to show "
-u"importer description"
+"importer description"
 ),
 )
 def onProgressStarted(self, metadata):
-self.disp(_(u"Blog upload started"), 2)
+self.disp(_("Blog upload started"), 2)
 def onProgressFinished(self, metadata):
-self.disp(_(u"Blog uploaded successfully"), 2)
+self.disp(_("Blog uploaded successfully"), 2)
 redirections = {
 k[len(URL_REDIRECT_PREFIX) :]: v
-for k, v in metadata.iteritems()
+for k, v in metadata.items()
 if k.startswith(URL_REDIRECT_PREFIX)
 }
 if redirections:
-conf = u"\n".join(
+conf = "\n".join(
 [
-u"url_redirections_dict = {}".format(
+"url_redirections_dict = {}".format(
 # we need to add ' ' before each new line
 # and to double each '%' for ConfigParser
-u"\n ".join(
+"\n ".join(
 json.dumps(redirections, indent=1, separators=(",", ": "))
-.replace(u"%", u"%%")
+.replace("%", "%%")
-.split(u"\n")
+.split("\n")
 )
 ),
 ]
 )
 self.disp(
 _(
-u"\nTo redirect old URLs to new ones, put the following lines in your"
+"\nTo redirect old URLs to new ones, put the following lines in your"
-u" sat.conf file, in [libervia] section:\n\n{conf}".format(conf=conf)
+" sat.conf file, in [libervia] section:\n\n{conf}".format(conf=conf)
 )
 )
 def onProgressError(self, error_msg):
-self.disp(_(u"Error while uploading blog: {}").format(error_msg), error=True)
+self.disp(_("Error while uploading blog: {}").format(error_msg), error=True)
 def error(self, failure):
 self.disp(
 _("Error while trying to upload a blog: {reason}").format(reason=failure),
 error=True,
 if self.args.location is None:
 for name in ("option", "service", "no_images_upload"):
 if getattr(self.args, name):
 self.parser.error(
 _(
-u"{name} argument can't be used without location argument"
+"{name} argument can't be used without location argument"
 ).format(name=name)
 )
 if self.args.importer is None:
 self.disp(
-u"\n".join(
+"\n".join(
 [
-u"{}: {}".format(name, desc)
+"{}: {}".format(name, desc)
 for name, desc in self.host.bridge.blogImportList()
 ]
 )
 )
 else:
 try:
 short_desc, long_desc = self.host.bridge.blogImportDesc(
 self.args.importer
 )
 except Exception as e:
-msg = [l for l in unicode(e).split("\n") if l][
+msg = [l for l in str(e).split("\n") if l][
 -1
 ]  # we only keep the last line
 self.disp(msg)
 self.host.quit(1)
 else:
 self.disp(
-u"{name}: {short_desc}\n\n{long_desc}".format(
+"{name}: {short_desc}\n\n{long_desc}".format(
 name=self.args.importer,
 short_desc=short_desc,
 long_desc=long_desc,
 )
 )
 options["ignore_tls_errors"] = C.BOOL_TRUE
 if self.args.no_images_upload:
 options["upload_images"] = C.BOOL_FALSE
 if self.args.upload_ignore_host:
 self.parser.error(
-u"upload-ignore-host option can't be used when no-images-upload "
+"upload-ignore-host option can't be used when no-images-upload "
-u"is set"
+"is set"
 )
 elif self.args.upload_ignore_host:
 options["upload_ignore_host"] = self.args.upload_ignore_host
 def gotId(id_):

Mercurial > libervia-backend

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