libervia-backend: sat_frontends/jp/common.py comparison

comparison sat_frontends/jp/common.py @ 3568:04283582966f

core, frontends: fix invalid translatable strings. Some f-strings where used in translatable text, this has been fixed by using explicit `format()` call (using a script based on `tokenize`). As tokenize messes with spaces, a reformating tool (`black`) has been applied to some files afterwards.

author	Goffi <goffi@goffi.org>
date	Mon, 14 Jun 2021 18:35:12 +0200
parents	be6d91572633
children	82e616b70a2a

comparison

equal deleted inserted replaced

-:a240748ed686
+:04283582966f
 path = Path(path).resolve()
 if not path.is_file:
 raise OSError("path must link to a regular file")
 if path.parent != getTmpDir(self.sat_conf, self.cat_dir):
 self.disp(
-f"File {path} is not in SàT temporary hierarchy, we do not remove "
+f"File {path} is not in SàT temporary hierarchy, we do not remove " f"it",
-f"it",
 2,
 )
 return
 # we have 2 files per draft with use_metadata, so we double max
 unlink_max = SECURE_UNLINK_MAX * 2 if self.use_metadata else SECURE_UNLINK_MAX
 backup_dir = getTmpDir(self.sat_conf, self.cat_dir, SECURE_UNLINK_DIR)
 if not os.path.exists(backup_dir):
 os.makedirs(backup_dir)
 filename = os.path.basename(path)
 backup_path = os.path.join(backup_dir, filename)
 # we move file to backup dir
 self.host.disp(
-"Backuping file {src} to {dst}".format(
+"Backuping file {src} to {dst}".format(src=path, dst=backup_path),
-src=path, dst=backup_path
-),
 1,
 )
 os.rename(path, backup_path)
 # and if we exceeded the limit, we remove older file
 backup_files = [os.path.join(backup_dir, f) for f in os.listdir(backup_dir)]
 backup_files.sort(key=lambda path: os.stat(path).st_mtime)
 for path in backup_files[: len(backup_files) - unlink_max]:
 self.host.disp("Purging backup file {}".format(path), 2)
 os.unlink(path)
-async def runEditor(self, editor_args_opt, content_file_path, content_file_obj,
+async def runEditor(
-meta_file_path=None, meta_ori=None):
+self,
+editor_args_opt,
+content_file_path,
+content_file_obj,
+meta_file_path=None,
+meta_ori=None,
+):
 """Run editor to edit content and metadata
 @param editor_args_opt(unicode): option in [jp] section in configuration for
 specific args
 @param content_file_path(str): path to the content file
 """
 if not self.use_metadata:
 assert meta_file_path is None
 assert meta_ori is None
 # we calculate hashes to check for modifications
 import hashlib
 content_file_obj.seek(0)
 tmp_ori_hash = hashlib.sha1(content_file_obj.read()).digest()
 content_file_obj.close()
 parse_kwargs["metadata_file"] = meta_file_path
 args = parse_args(self.host, editor_args, **parse_kwargs)
 if not args:
 args = [content_file_path]
 # actual editing
 editor_process = await asyncio.create_subprocess_exec(
-editor, *[str(a) for a in args])
+editor, *[str(a) for a in args]
+)
 editor_exit = await editor_process.wait()
 # edition will now be checked, and data will be sent if it was a success
 if editor_exit != 0:
 self.disp(
 f"Cancelling edition",
 error=True,
 )
 self.host.quit(C.EXIT_NOT_FOUND)
 # metadata
 if self.use_metadata:
 try:
 with meta_file_path.open("rb") as f:
 metadata = json.load(f)
 except (OSError, IOError):
 self.host.quit(C.EXIT_DATA_ERROR)
 if self.use_metadata and not metadata.get("publish", True):
 self.disp(
 f'Publication blocked by "publish" key in metadata, cancelling '
-f'edition.\n\ntemporary file path:\t{content_file_path}\nmetadata '
+f"edition.\n\ntemporary file path:\t{content_file_path}\nmetadata "
-f'file path:\t{meta_file_path}',
+f"file path:\t{meta_file_path}",
 error=True,
 )
 self.host.quit()
 if len(content) == 0:
 if self.use_metadata:
 self.disp(f"Deletion of {meta_file_path}".format(meta_file_path), 2)
 os.unlink(meta_file_path)
 self.host.quit()
 # time to re-check the hash
 elif tmp_ori_hash == hashlib.sha1(content).digest() and (
 not self.use_metadata or meta_ori == metadata
 ):
 self.disp("The content has not been modified, cancelling the edition")
 self.host.quit()
 dir=tmp_dir,
 text=True,
 )
 return os.fdopen(fd, "w+b"), Path(path)
 except OSError as e:
-self.disp(
+self.disp(f"Can't create temporary file: {e}", error=True)
-f"Can't create temporary file: {e}", error=True
-)
 self.host.quit(1)
 def getCurrentFile(self, profile):
 """Get most recently edited file
 # the most recent file corresponding to temp file pattern
 # in tmp_dir, excluding metadata files
 tmp_dir = getTmpDir(self.sat_conf, self.cat_dir, profile)
 available = [
 p
-for p in tmp_dir.glob(f'{self.cat_dir}_*')
+for p in tmp_dir.glob(f"{self.cat_dir}_*")
 if not p.match(f"*{METADATA_SUFF}")
 ]
 if not available:
 self.disp(
 f"Could not find any content draft in {tmp_dir}",
 if last_item:
 self.disp(_("no item found at all, we create a new one"), 2)
 else:
 self.disp(
 _(
-f'item "{item}" not found, we create a new item with'
+'item "{item}" not found, we create a new item with'
-f'this id'
+"this id"
-),
+).format(item=item),
 2,
 )
 content_file_obj.seek(0)
 else:
 self.disp(f"Error while retrieving item: {e}")
 # we already have a draft,
 # we copy item content after it and add an indicator
 content_file_obj.write("\n*****\n")
 content_file_obj.write(content.encode("utf-8"))
 content_file_obj.seek(0)
-self.disp(
+self.disp(_('item "{item}" found, we edit it').format(item=item), 2)
-_(f'item "{item}" found, we edit it'), 2
-)
 else:
 self.disp("Editing a new item", 2)
 if self.use_metadata:
 metadata = None
 self.rows = []
 size = None
 if headers:
 # we use a namedtuple to make the value easily accessible from filters
-headers_safe = [re.sub(r'[^a-zA-Z_]', '_', h) for h in headers]
+headers_safe = [re.sub(r"[^a-zA-Z_]", "_", h) for h in headers]
 row_cls = namedtuple("RowData", headers_safe)
 else:
 row_cls = tuple
 for row_data in data:
 else:
 try:
 col_value = filter_(value, row_cls(*row_data_list))
 except TypeError:
 col_value = filter_(value)
 # we count size without ANSI code as they will change length of the
 # string when it's mostly style/color changes.
 col_size = len(regex.ansiRemove(col_value))
 else:
 col_value = str(value)
 col_size = len(col_value)
 new_row.append(col_value)
 else:
 raise e
 @classmethod
 def fromListDict(
-cls, host, data, keys=None, headers=None, filters=None, defaults=None):
+cls, host, data, keys=None, headers=None, filters=None, defaults=None
+):
 """Create a table from a list of dictionaries
 each dictionary is a row of the table, keys being columns names.
 the whole data will be read and kept into memory, to be printed
 @param data(list[dict[unicode, unicode]]): data to create the table from
 bottom = top
 if bottom_sep is None:
 bottom_sep = col_sep_size * bottom
 if not show_borders:
 left = right = head_line_left = head_line_right = ""
 # top border
 if show_borders:
 self._disp(
 top_left + top_sep.join([top * size for size in sizes]) + top_right
 )
 # headers
 if show_header and self.headers is not None:
 self._disp(
 left
 + self._headers(head_sep, headers, sizes, head_alignment, head_style)
 + right
 head_line_left
 + head_line_sep.join([head_line * size for size in sizes])
 + head_line_right
 )
 # content
 if columns_alignment == "left":
 alignment = lambda idx, s: ansi_ljust(s, sizes[idx])
 elif columns_alignment == "center":
 alignment = lambda idx, s: ansi_center(s, sizes[idx])
 elif columns_alignment == "right":
 self._disp(
 bottom_left
 + bottom_sep.join([bottom * size for size in sizes])
 + bottom_right
 )
 #  we return self so string can be used after display (table.display().string)
 return self
 def display_blank(self, **kwargs):
 """Display table without visible borders"""
 kwargs_ = {"col_sep": " ", "head_line_sep": " ", "show_borders": False}
 try:
 uri_data = uris_data[key]
 except KeyError:
 host.disp(
-_(f"No {key} URI specified for this project, please specify service and "
+_(
-f"node"),
+"No {key} URI specified for this project, please specify service and "
+"node"
+).format(key=key),
 error=True,
 )
 host.quit(C.EXIT_NOT_FOUND)
 uri = uri_data["uri"]
 # set extra metadata if they are specified
-for data_key in ['labels']:
+for data_key in ["labels"]:
 new_values_json = uri_data.get(data_key)
 if uri_data is not None:
 if meta_map is None:
 dest = data_key
 else:
 continue
 try:
 values = getattr(args, data_key)
 except AttributeError:
-raise exceptions.InternalError(f'there is no {data_key!r} arguments')
+raise exceptions.InternalError(f"there is no {data_key!r} arguments")
 else:
 if values is None:
 values = []
 values.extend(json.loads(new_values_json))
 setattr(args, dest, values)
 parsed_uri = xmpp_uri.parseXMPPUri(uri)
 try:
 args.service = parsed_uri["path"]
 args.node = parsed_uri["node"]
 except KeyError:
-host.disp(_(f"Invalid URI found: {uri}"), error=True)
+host.disp(_("Invalid URI found: {uri}").format(uri=uri), error=True)
 host.quit(C.EXIT_DATA_ERROR)

Mercurial > libervia-backend

comparison sat_frontends/jp/common.py @ 3568:04283582966f