Hi,
ich bin vor ein paar Wochen auf das Python-Suchen-und-Ersetzen-Skript subst.py gestoßen und begeistert davon, da ich schon lange genau so ein Skript gesucht habe. (Der BBCode scheint nicht interpretiert zu werden, obwohl er eingeschaltet ist.)
Es gab einige Bugs, die ich dem Entwickler gemeldet habe. Ein Problem ist noch offen: Wildcards in Pfaden funktionieren unter Windows noch nicht. Der Entwickler nutzt das glob-Modul zur Interpretation/Auflösung der Wildcards. Leider kann der Entwickler das Skript nur unter einem virtuellen Windows testen.
Falls jemand hier das Skript ebenfalls nützlich findet, idealerweise über mehr Python-Erfahrung verfügt als ich und Lust hat, sich mit dem Bug auseinanderzusetzen, würde ich mich freuen, wenn er/sie sich in die Diskussion in dem entsprechenden Github-Thread einschaltet. Und der Entwickler würde sich wahrscheinlich auch freuen. Jedenfalls hat er sich über mein Interesse an dem Skript und meine Beiträge gefreut. Im Moment ist das Skript abwärtskompatibel zu Python 2.7. Und das sollte es auch bleiben.
Außerdem: Mit der Anzahl der User steigt tendentiell die Wahrscheinlichkeit, dass Bugs entdeckt und gefixt werden, schätze ich.
Wildcard-Problem unter Windows
Mir ist eben aufgefallen, dass auf Github derzeit gar keine Version des Skripts verfügbar ist, die unter Windows funktioniert, weil der Wildcard-Bug dazu führt, dass auch Pfade ohne Wildcards unter Windows ignoriert werden. Ich habe hier noch eine der letzten Versionen des Scripts, in der der Entwickler die Verarbeitung von Wildcards nicht mit dem glob-, sondern mit dem fnmatch-Modul umzusetzen versucht hat. Das funktioniert auch, aber nur bei Wildcards in Dateinamen oder Dateitypen. "*.*" funktioniert also, "Ordner\*\datei.txt" aber nicht.
Ich hätte diese Version gerne diesem Beitrag als Anhang beigefügt, aber dazu scheinen mir die Rechte zu fehlen. Deswegen trotz der Länge des Skripts in einer Codebox.
Lizenz: https://github.com/msztolcman/subst#license
Ich hätte diese Version gerne diesem Beitrag als Anhang beigefügt, aber dazu scheinen mir die Rechte zu fehlen. Deswegen trotz der Länge des Skripts in einer Codebox.
Lizenz: https://github.com/msztolcman/subst#license
Code: Alles auswählen
#!/usr/bin/env python
# -*- coding: utf-8 -*-
""" subst - Replace PATTERN with REPLACE in many files.
http://msztolcman.github.io/subst
Author: Marcin Sztolcman (marcin@urzenia.net)
Get help with: subst --help
Information about version: subst --version
"""
from __future__ import print_function, unicode_literals, division
import argparse
import codecs
import fnmatch
import os
import os.path
import re
import shutil
import sys
import tempfile
import textwrap
import unicodedata
__version__ = '0.4.0'
IS_PY2 = sys.version_info[0] < 3
FILESYSTEM_ENCODING = sys.getfilesystemencoding()
FILE_ENCODING = sys.getdefaultencoding()
INPUT_ENCODING = sys.getdefaultencoding()
DEFAULT_BACKUP_EXTENSION = 'bak'
class SubstException(Exception):
""" Exception raised when there is some error.
"""
class ParserException(SubstException):
""" Exception raised when pattern given by user has errors.
"""
def u(string, encoding='utf-8'):
""" Wrapper to decode string into unicode.
Converts only when `string` is type of `str`, and in python2.
Thanks to this there is possible single codebase between PY2 and PY3.
"""
if not IS_PY2:
if isinstance(string, bytes):
return str(string, encoding=encoding)
else:
if isinstance(string, str):
return string.decode(encoding)
elif not isinstance(string, unicode):
return unicode(string)
return string
def err(*args, **kwargs):
"""
Display error message.
It's a wrapper for disp, with additions:
* file - if not specified, use sys.stderr
* exit_code - if specified, calls sys.exit with given code. If None, do not exit.
:param args:
:param kwargs:
:return:
"""
args = list(args)
args.insert(0, 'ERROR:')
if not kwargs.get('file'):
kwargs['file'] = sys.stderr
disp(*args, **kwargs)
if kwargs.get('exit_code', None) is not None:
sys.exit(kwargs['exit_code'])
def disp(*args, **kwargs):
""" Print data in safe way.
First, try to encode whole data to utf-8. If printing fails, try to encode to
sys.stdout.encoding or sys.getdefaultencoding(). In last step, encode to 'ascii'
with replacing unconvertable characters.
"""
indent = (' ' * kwargs.get('indent', 0) * 4)
if indent:
args = list(args)
args.insert(0, indent[:-1])
try:
if IS_PY2:
args = [part.encode('utf-8') for part in args]
print(*args, sep=kwargs.get('sep'), end=kwargs.get('end'), file=kwargs.get('file'))
except UnicodeEncodeError:
try:
encoding = sys.stdout.encoding or sys.getdefaultencoding()
args = [part.encode(encoding) for part in args]
print(*args, sep=kwargs.get('sep'), end=kwargs.get('end'), file=kwargs.get('file'))
except UnicodeEncodeError:
args = [part.encode('ascii', 'replace') for part in args]
print(*args, sep=kwargs.get('sep'), end=kwargs.get('end'), file=kwargs.get('file'))
def debug(message, **kwargs):
""" Display debug message.
Prints always to stderr.
"""
kwargs['file'] = sys.stderr
disp(message, **kwargs)
def _plural_s(cnt, word):
if cnt == 1:
return word
return '%ss' % word
def _parse_args__get_backup_file_ext(args):
""" Find extension for backup files.
Extension in args is supposed to not have leading dot.
"""
if args.no_backup:
return ''
if not args.ext:
return '.' + DEFAULT_BACKUP_EXTENSION
return '.' + args.ext
def _parse_args__eval_replacement(repl):
""" Compile replace argument as valid Python code and return
function which can be passed to re.sub or re.subn functions.
"""
# pylint: disable=missing-docstring
def _(match):
# pylint: disable=eval-used
return eval(repl, {'__builtins__': __builtins__}, {'m': match})
return _
def _parse_args__parse_pattern(pat):
"""
Split pattern into search, replacement and flags.
:param pat:
:return:
"""
def _parse_args__split_bracketed_pattern(delim, pattern):
"""
Helper for parsing arguments: search user-given pattern for delim
and extract flags, replacement and specific pattern from it
:param delim:
:param pattern:
:return:
"""
pattern, replace = pattern[1:].split(delim[::-1], 1)
if replace.endswith(delim[1]):
flags = ''
else:
replace, flags = replace.rsplit(delim[1], 1)
return pattern, replace, flags
if pat.startswith('('):
pattern, replace, flags = _parse_args__split_bracketed_pattern('()', pat)
elif pat.startswith('{'):
pattern, replace, flags = _parse_args__split_bracketed_pattern('{}', pat)
elif pat.startswith('['):
pattern, replace, flags = _parse_args__split_bracketed_pattern('[]', pat)
elif pat.startswith('<'):
pattern, replace, flags = _parse_args__split_bracketed_pattern('<>', pat)
else:
delim, pat = pat[0], pat[1:]
pattern, replace, flags = pat.split(delim, 2)
return pattern, replace, flags
# pylint: disable=too-many-branches
def _parse_args__pattern(args):
""" Read arguments from argparse.ArgumentParser instance, and
parse it to find correct values for arguments:
* pattern
* replace
* count
If is provided --pattern-and-replace argument, then parse
it and return data from it.
In other case just return data from argparse.ArgumentParser
instance.
Reads also string argument, and apply it to pattern.
Returned pattern is compiled (see: re.compile).
"""
re_flags = re.UNICODE
if args.pattern is not None and args.replace is not None:
if args.string:
pattern = re.escape(args.pattern)
else:
pattern = args.pattern
return re.compile(pattern, re_flags), args.replace, args.count or 0
elif args.pattern_and_replace is not None:
pat = args.pattern_and_replace
try:
# pattern must begin with 's'
if not pat.startswith('s'):
raise ParserException('Bad pattern specified: %s' % args.pattern_and_replace)
pat = pat[1:]
pattern, replace, flags = _parse_args__parse_pattern(pat)
if 'g' in flags:
count = 0
elif args.count is not None:
count = args.count
else:
count = 1
if 'i' in flags:
re_flags |= re.IGNORECASE
if 'x' in flags:
re_flags |= re.VERBOSE
if 's' in flags:
re_flags |= re.DOTALL
if 'm' in flags:
re_flags |= re.MULTILINE
except ValueError:
raise ParserException('Bad pattern specified: %s' % args.pattern_and_replace)
if args.ignore_case:
re_flags |= re.IGNORECASE
if args.pattern_dot_all:
re_flags |= re.DOTALL
if args.pattern_verbose:
re_flags |= re.VERBOSE
if args.pattern_multiline:
re_flags |= re.MULTILINE
return re.compile(pattern, re_flags), replace, count
else:
raise ParserException('Bad pattern specified: %s' % args.pattern_and_replace)
def _parse_args__expand_wildcards(paths):
"""
Expand wildcards in given paths
:param paths:
:return:
"""
_paths = []
for path in paths:
_paths.extend(glob(path))
return _paths
def wrap_text(txt):
""" Make custom wrapper for passed text.
Splits given text for lines, and for every line apply custom
textwrap.TextWrapper settings, then return reformatted string.
"""
_wrap = textwrap.TextWrapper(
width=72,
expand_tabs=True,
replace_whitespace=False,
drop_whitespace=True,
subsequent_indent=' ',
)
txt = [_wrap.fill(line) for line in txt.splitlines()]
return os.linesep.join(txt)
def glob(pattern):
root, pattern = os.path.split(pattern)
if not pattern:
return root
if not root:
root = '.'
try:
items = [item.name for item in os.scandir(root)]
except AttributeError:
items = os.listdir(root)
items = map(lambda item: unicodedata.normalize('NFKC', item), items)
items = fnmatch.filter(items, pattern)
return [os.path.join(root, item) for item in items]
def _parse_args__prepare_path(path):
path = os.path.abspath(path)
path = u(path, FILESYSTEM_ENCODING)
path = unicodedata.normalize('NFKC', path)
return path
# pylint: disable=too-many-branches,too-many-statements
def parse_args(args):
""" Parse arguments passed to script, validate it, compile if needed and return.
"""
# pylint: disable=global-statement
global INPUT_ENCODING, FILE_ENCODING, FILESYSTEM_ENCODING
args_description = 'Replace PATTERN with REPLACE in many files.'
# pylint: disable=invalid-name
p = argparse.ArgumentParser(
description=args_description,
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog=wrap_text(textwrap.dedent("""\
Miscellaneous notes:
* regular expressions engine used here is PCRE, dialect from Python
* is required to pass either --pattern and -replace, or --pattern-and-replace argument
* if pattern passed to --pattern-and-replace has /g modifier, it overwrites --count value
* if neither /g modifier nor --count argument is passed, assume that --count is equal 1
* if only --count is given, this value is used
* if --eval-replace is given, --replace must be valid Python code, where can be used m variable. m holds MatchObject instance (see: https://docs.python.org/3/library/re.html#match-objects, for example:
--eval-replace --replace 'm.group(1).lower()'
* regular expressions with non linear search read whole file to yours computer memory - if file size is bigger then you have memory in your computer, it fails
* parsing expression passed to --pattern-and-replace argument is very simple - if you use / as delimiter, then in your expression can't be used this character anymore. If you need to use same character as delimiter and in expression, then better use --pattern and --replace arguments
* you can test exit code to verify there was made any changes (exit code = 0) or not (exit code = 1)
Security notes:
* be careful with --eval-replace argument. When it's given, value passed to --replace is eval-ed, so any unsafe code will be executed!
Author:
Marcin Sztolcman <marcin@urzenia.net> // http://urzenia.net
HomePage:
http://msztolcman.github.io/subst/"""
))
)
p.add_argument('-p', '--pattern', type=str,
help='pattern to replace for. Supersede --pattern-and-replace. Required if --replace is specified.')
p.add_argument('-r', '--replace', type=str,
help='replacement. Supersede --pattern-and-replace. Required if --pattern is specified.')
p.add_argument('--eval-replace', dest='eval', action='store_true',
help='if specified, make eval data from --replace(should be valid Python code). Ignored with '
'--pattern-and-replace argument.')
p.add_argument('-t', '--string', action='store_true',
help='if specified, treats --pattern as string, not as regular expression. Ignored with '
'--pattern-and-replace argument.')
p.add_argument('-s', '--pattern-and-replace', '--pattern-and-replace', metavar='"s/PAT/REP/gixsm"', type=str,
help='pattern and replacement in one: s/pattern/replace/g(pattern is always regular expression, /g '
'is optional and stands for --count=0, /i == --ignore-case, /s == --pattern-dot-all, /m == --pattern-multiline).')
p.add_argument('-c', '--count', type=int,
help='make COUNT replacements for every file (0 makes unlimited changes, default).')
p.add_argument('-l', '--linear', action='store_true',
help='apply pattern for every line separately. Without this flag whole file is read into memory.')
p.add_argument('-i', '--ignore-case', dest='ignore_case', action='store_true',
help='ignore case of characters when matching')
p.add_argument('--pattern-dot-all', dest='pattern_dot_all', action='store_true',
help='with this flag, dot(.) character in pattern match also new line character (see: '
'https://docs.python.org/3/library/re.html#re.DOTALL).')
p.add_argument('--pattern-verbose', dest='pattern_verbose', action='store_true',
help='with this flag pattern can be passed as verbose(see: https://docs.python.org/3/library/re.html#re.VERBOSE).')
p.add_argument('--pattern-multiline', dest='pattern_multiline', action='store_true',
help='with this flag pattern can be passed as multiline(see: https://docs.python.org/3/library/re.html#re.MULTILINE).')
p.add_argument('-u', '--utf8', action='store_true',
help='Use UTF-8 in --encoding-input, --encoding-file and --encoding-filesystem')
p.add_argument('--encoding-input', type=str, default=INPUT_ENCODING,
help='set encoding for parameters like --pattern etc (default for your system: %s)' % INPUT_ENCODING)
p.add_argument('--encoding-file', type=str, default=FILE_ENCODING,
help='set encoding for content of processed files (default for your system: %s)' % FILE_ENCODING)
p.add_argument('--encoding-filesystem', type=str, default=FILESYSTEM_ENCODING,
help='set encoding for paths and filenames (default for your system: %s)' % FILESYSTEM_ENCODING)
p.add_argument('-b', '--no-backup', dest='no_backup', action='store_true',
help='don\'t create backup of modified files.')
p.add_argument('-e', '--backup-extension', dest='ext', default=DEFAULT_BACKUP_EXTENSION, type=str,
help='extension for backup files(ignore if no backup is created), without leading dot. Defaults to: "bak".')
p.add_argument('-W', '--expand-wildcards', action='store_true',
help='expand wildcards (see: https://docs.python.org/3/library/glob.html) in paths')
p.add_argument('--stdin', action='store_true',
help='read data from STDIN(implies --stdout)')
p.add_argument('--stdout', action='store_true',
help='output data to STDOUT instead of change files in-place(implies --no-backup)')
p.add_argument('-V', '--verbose', action='store_true',
help='show files and how many replacements was done and short summary')
p.add_argument('--debug', action='store_true',
help='show more informations')
p.add_argument('-v', '--version', action='version',
version="%s %s\n%s" % (os.path.basename(sys.argv[0]), __version__, args_description))
p.add_argument('files', nargs='*', type=str,
help='files to parse')
args = p.parse_args(args)
if args.utf8:
INPUT_ENCODING = FILE_ENCODING = FILESYSTEM_ENCODING = 'utf8'
args.encoding_input = args.encoding_file = args.encoding_filesystem = 'utf8'
else:
INPUT_ENCODING = args.encoding_input
FILE_ENCODING = args.encoding_file
FILESYSTEM_ENCODING = args.encoding_filesystem
try:
codecs.lookup(INPUT_ENCODING)
codecs.lookup(FILE_ENCODING)
codecs.lookup(FILESYSTEM_ENCODING)
except LookupError as exc:
p.error(exc)
if not args.files or args.files[0] == str('-'):
args.stdin = True
args.files = None
else:
args.files = list(map(_parse_args__prepare_path, args.files))
if args.expand_wildcards:
args.files = _parse_args__expand_wildcards(args.files)
if args.stdin:
args.stdout = True
if args.stdout:
args.no_backup = True
if \
(args.pattern is None and args.replace is None and args.pattern_and_replace is None) or \
(args.pattern is None and args.replace is not None) or \
(args.pattern is not None and args.replace is None):
p.error('must be provided --pattern and --replace options, or --pattern-and-replace.')
if args.pattern:
args.pattern = u(args.pattern, INPUT_ENCODING)
if args.replace:
args.replace = u(args.replace, INPUT_ENCODING)
if args.pattern_and_replace:
args.pattern_and_replace = u(args.pattern_and_replace, INPUT_ENCODING)
try:
args.ext = _parse_args__get_backup_file_ext(args)
args.pattern, args.replace, args.count = _parse_args__pattern(args)
if args.eval:
args.replace = _parse_args__eval_replacement(args.replace)
except ParserException as ex:
p.error(ex)
return args
def replace_linear(src, dst, pattern, replace, count):
""" Read data from 'src' line by line, replace some data from
regular expression in 'pattern' with data in 'replace',
write it to 'dst', and return quantity of replaces.
"""
ret = 0
for line in src:
if count == 0 or ret < count:
if IS_PY2 and not isinstance(line, unicode):
line = u(line, FILE_ENCODING)
line, rest_count = pattern.subn(replace, line, max(0, count - ret))
ret += rest_count
if IS_PY2 and isinstance(line, unicode):
line = line.encode(FILE_ENCODING)
dst.write(line)
return ret
def replace_global(src, dst, pattern, replace, count):
""" Read whole file from 'src', replace some data from
regular expression in 'pattern' with data in 'replace',
write it to 'dst', and return quantity of replaces.
"""
data = src.read()
if IS_PY2 and not isinstance(data, unicode):
data = u(data, FILE_ENCODING)
data, ret = pattern.subn(replace, data, count)
if IS_PY2 and isinstance(data, unicode):
data = data.encode(FILE_ENCODING)
dst.write(data)
return ret
def _process_file__make_backup(path, backup_ext):
""" Create backup of file: copy it with new extension.
Returns path to backup file.
"""
root = os.path.dirname(path)
backup_path = os.path.join(root, path + backup_ext)
if os.path.exists(backup_path):
raise SubstException('Backup path: "%s" for file "%s" already exists, file skipped' % (backup_path, path))
try:
shutil.copy2(path, backup_path)
except (shutil.Error, IOError) as ex:
raise SubstException('Cannot create backup for "%s": %s' % (path, ex))
return backup_path
def _process_file__handle(src_path, dst_fh, cfg, replace_func):
""" Read data from `src_path`, replace data with `replace_func` and
save it to `dst_fh`.
"""
with codecs.open(src_path, 'r', encoding=FILE_ENCODING) as fh_src:
cnt = replace_func(fh_src, dst_fh, cfg.pattern, cfg.replace, cfg.count)
if cfg.verbose or cfg.debug:
debug('%s %s' % (cnt, _plural_s(cnt, 'replacement')), indent=1)
return cnt
def _process_file__regular(src_path, cfg, replace_func):
""" Read data from `src_path`, replace data with `replace_func` and
save it.
It's safe operation - first save data to temporary file, and then try to rename
new file to old one.
"""
tmp_fh, tmp_path = tempfile.mkstemp()
tmp_fh = os.fdopen(tmp_fh, 'w')
cnt = _process_file__handle(src_path, tmp_fh, cfg, replace_func)
try:
tmp_fh.close()
# pylint: disable=bare-except
except:
pass
try:
shutil.move(tmp_path, src_path)
except OSError as ex:
raise SubstException('Error replacing "%s" with "%s": %s' % (src_path, tmp_path, ex))
else:
if cfg.debug:
debug('moved temporary file to original', indent=1)
return cnt
def process_file(path, replace_func, cfg):
""" Process single file: open, read, make backup and replace data.
"""
if cfg.verbose or cfg.debug:
debug(path)
if not os.path.exists(path):
raise SubstException('Path "%s" doesn\'t exists' % path)
if not os.path.isfile(path) or os.path.islink(path):
raise SubstException('Path "%s" is not a regular file' % path)
if not cfg.no_backup:
backup_path = _process_file__make_backup(path, cfg.ext)
if cfg.debug:
debug('created backup file: "%s"' % backup_path, indent=1)
cnt = 0
try:
if cfg.stdout:
cnt = _process_file__handle(path, sys.stdout, cfg, replace_func)
else:
cnt = _process_file__regular(path, cfg, replace_func)
except SubstException as ex:
err(u(ex))
return cnt
def main(args):
""" Run tool: parse input arguments, read data, replace and save or display.
"""
try:
args = parse_args(args)
except (UnicodeDecodeError, UnicodeEncodeError):
err("Cannot determine encoding of input arguments, please use --encoding-input option", exit_code=1)
if args.linear:
replace_func = replace_linear
else:
replace_func = replace_global
if args.stdin:
cnt_changes = replace_func(sys.stdin, sys.stdout, args.pattern, args.replace, args.count)
cnt_changed_files = 0
else:
cnt_changes = cnt_changed_files = 0
for path in args.files:
try:
cnt_changes_single = process_file(path, replace_func, args)
if cnt_changes_single > 0:
cnt_changes += cnt_changes_single
cnt_changed_files += 1
except SubstException as exc:
err(u(exc), indent=int(args.verbose or args.debug), exit_code=1)
if args.verbose:
debug('There was %d %s in %d %s.' % (
cnt_changes, _plural_s(cnt_changes, 'replacement'),
cnt_changed_files, _plural_s(cnt_changed_files, 'file'),
))
if cnt_changes > 0:
return 0
else:
return 1
if __name__ == '__main__':
sys.exit(main(sys.argv[1:]))
Ich hatte mir mal sowas ähnliches geschrieben:
Hilft dir das weiter?
Code: Alles auswählen
def get_filenames(path=os.curdir):
"""
Return an iterator of the filenames in `path`. If this function could not
retrieve any filename due to access errors then the iterator will be empty
(i.e. yielding no items).
Note that shell-like globbing is performed if `path` contains wildcard
symbols such as "*" or "?". The function will then return all names that
match the given pattern instead of their directory contents. If you need the
contents then you should put the platform's path separator at the end of
your pattern. In other words (on Windows):
r'Python27' => Content of "Python27"-folder
r'Py*' => Names starting with "Py" (e.g. "Python27", "Python34", ...)
r'Py*\\' => Contents of directories starting with "Py"
r'Py*\*.txt' => E.g. all text files in all Python folders
To make life easier, you are free to use alternative path separators if
they are supported by your platform (e.g. "/" instead of "\" on Windows).
Additionally, the "~"-symbol will be expanded to the user's home directory.
"""
path = os.path.expanduser(os.path.expandvars(path))
if os.altsep is not None:
# "C:/Folder/file.txt" -> "C:\Folder\file.txt"
path = path.replace(os.altsep, os.sep)
if not glob.has_magic(path) or path.endswith(os.sep):
# "C:\Folder\" -> "C:\Folder\*"
# (this makes `glob` picking the contents)
path = os.path.join(path, '*')
filenames = (fn.rstrip(os.sep) for fn in glob.iglob(path))
if not glob.has_magic(os.path.dirname(path)):
# "C:\Folder\" -> ['a.txt', 'b.txt', ...]
# "C:\F*\" -> ['C:\Folder\a.txt', 'C:\Foo\b.txt', ...]
filenames = (os.path.basename(fn) for fn in filenames)
return filenamesWobei ich gerade sehe, dass entgegen der Aussage im Docstring bei mehreren passenden Verzeichnissen (also das "Py*/"-Beispiel) leider nur der Inhalt vom ersten passenden Ordner angezeigt wird. Da muss ich nochmal genauer drüberschauen, warum das so ist...
EDIT:
Oh, das andere Verzeichnis, womit ich's getestet hatte, war einfach zufällig leer...
EDIT:
Oh, das andere Verzeichnis, womit ich's getestet hatte, war einfach zufällig leer...
Das weiß ich noch nicht. Auf jeden Fall: Danke! Ich konnte dem Entwickler zwar ein wenig zuarbeiten, auch in Bezug auf den Code selbst, aber ich kann kein Python. Und das Skript ist schon recht komplex, glaub ich. Der Entwickler ist Pole. Möglicherweise spricht er Deutsch. Vielleicht muss er das aber auch gar nicht, um mit Hilfe deines Skripts dem Problem auf die Spur zu kommen. Ich könnte ihm einen Link zu diesem Thread schicken.Hilft dir das weiter?
Übrigens glaube ich, eben noch einen Bug gefunden zu haben: https://github.com/msztolcman/subst/issues/8.
Schick ihm doch einfach direkt den Quelltext. Einfach Copy&Paste in den Issue oder gleich nen Pull-Request auf GitHub stellen (falls du dir das zutraust). Bei Fragen kann ich mich dann immer noch einschalten. 
glob() quasi nochmal nachzubauen, ist eigentlich nicht nötig. Das Sammeln der infrage kommenden Ergebnisse funktioniert ja bereits. Mein Code verlässt sich daher komplett auf die Grundfunktionalität von glob() und hübscht lediglich die Ausgabe etwas auf. Außerdem habe ich einen Fall vereinfacht, wo die meisten Anwender IMHO den Verzeichnisinhalt erwarten, glob() jedoch nur den Verzeichnisnamen liefern würde. Möglicherweise gibt es noch Randfälle, die ich übersehen habe, aber an sich dürfte das schon tun, was du erwartest.kyou hat geschrieben:Ich habe hier noch eine der letzten Versionen des Scripts, in der der Entwickler die Verarbeitung von Wildcards nicht mit dem glob-, sondern mit dem fnmatch-Modul umzusetzen versucht hat.
Habe den Code noch leicht verändert und nun hier hochgeladen:
https://pastebin.com/5tvZJr0e
Habe ich gerade gemacht (https://github.com/msztolcman/subst/iss ... -331425469).Schick ihm doch einfach direkt den Quelltext.
Nur nochmal zur Klärung für mich bezüglich des Hintergrunds: Es geht darum, dass Pfadangaben mit Wildcards durch die tatsächlichen Pfade ersetzt werden sollen, oder bin ich damit auf dem falschen Dampfer?
Genau. Wenn der Ordner MyDir die Ordner Sub1, Sub2 und Sub3 enthält, soll das Skript mit MyDir\*\*.* sämtliche Dateien verarbeiten, die sich in den Sub-Ordnern befinden, sofern sie eine Dateinamenserweiterung haben.Es geht darum, dass Pfadangaben mit Wildcards durch die tatsächlichen Pfade ersetzt werden sollen
Okay, das kann mein Code. Es gibt nur die Besonderheit, dass bei eindeutigen Pfadangaben (z.B. C:\Verzeichnis\) angenommen wird, dass man den Verzeichnisinhalt ohne explizite Pfadangabe haben möchte (also a.txt anstatt C:\Verzeichnis\a.txt). Das ist IMHO auch sinnvoll, weil der Anwender ja weiß, auf welches Verzeichnis sich die Ausgabe bezieht. Das ist aber in deinem Anwendungsfall möglicherweise nicht so gut, denn du willst bei o.g. Angabe vermutlich, dass gar nichts passiert. Aber wenn der Mensch von dem Ersetzungsmodul nicht auf den Kopf gefallen ist, dann wird er das sicher merken und entsprechend anpassen. Und im Grunde könnte man dann auch direkt glob() ausführen und eventuell os.path.expanduser() vorschalten. Ich verstehe nicht wirklich, warum dabei Wildcards speziell unter Windows ein Problem darstellen.
Den Eindruck macht er auf mich nicht.Aber wenn der Mensch von dem Ersetzungsmodul nicht auf den Kopf gefallen ist
Meinst du, dass man bei der Angabe "C:\Verzeichnis\" alle Dateien inklusive a.txt erreicht, die sich im Verzeichnis befinden?Es gibt nur die Besonderheit, dass bei eindeutigen Pfadangaben (z.B. C:\Verzeichnis\) angenommen wird, dass man den Verzeichnisinhalt ohne explizite Pfadangabe haben möchte (also a.txt anstatt C:\Verzeichnis\a.txt).
Das wäre zumindest das, was ich als Windows-User instinktiv erwarten würde.Das ist aber in deinem Anwendungsfall möglicherweise nicht so gut, denn du willst bei o.g. Angabe vermutlich, dass gar nichts passiert.
Ja, genau. Vielleicht weiche ich da auch einfach zu sehr von der Konvention ab. Ich meine aber, dass eine Linux-Shell hier den Inhalt ausgeben würde (hab gerade keine Linux-Shell zur Hand). Möglicherweise sollte sich die Ersetzung unter Windows anders verhalten als unter Linux, wobei ich das andererseits verwirrend fände.kyou hat geschrieben:Meinst du, dass man bei der Angabe "C:\Verzeichnis\" alle Dateien inklusive a.txt erreicht, die sich im Verzeichnis befinden?
Geht mir ähnlich. Wenn es sich um ein Windows-Only-Tool handelte, sähe die Sache anders aus. Ich selbst brauche das Skript, um mit TTX (Teil der FontTools [https://github.com/fonttools]) dekompilierte Font-Dateien zu kommentieren / zu manipulieren. Die FontTools sind in Python programmiert. Um sie nutzen zu können, benötigt der User also Python. Und da liegt es nahe, auf ein Suchen-und-Ersetzen-Skript zurückzugreifen, das ebenfalls in Python programmiert ist. Und ich steuere all diese Skripte mit Batch-Dateien. Würde ich für die Ersetzungen ein Windows-Only-Tool verwenden, wäre es schwieriger die Batch-Skripte in ihre Linux-/Mac-Pendants zu übersetzen. Falls ich die Batch-Skripte veröffentliche, hätten es Linux- und Mac-User schwerer, die Ersetzungen zu verstehen. Und wenn sich Subst.py dann unter Linux oder MacOs anders verhielte als unter Windows, könnte das ebenfalls verwirrend sein.Möglicherweise sollte sich die Ersetzung unter Windows anders verhalten als unter Linux, wobei ich das andererseits verwirrend fände.
Im Moment bin ich aber wegen des das Caret (Zeilenanfang/Stringanfang) betreffenden Bugs irritiert. Ich bin mir recht sicher, dass es ein Bug ist. Ich hoffe, ich finde nicht noch mehr Bugs. Sonst muss ich am Ende doch nach einem anderen Tool suchen. Und da gibt es gar nicht so viel, das in Bezug auf die Dateigröße klein ist, OpenSource ist, bugfrei ist und gepflegt wird.
Und der Fehler liegt wo genau? Gemäß deiner Beispiele matcht das ^-Zeichen doch korrekt am Textanfang. Bei Multiline werden halt alle Zeilen in einem Guss betrachtet und nicht die einzelnen Zeilen. So verstehe ich das zumindest. Hattest du erwartet, dass die Zeile nach dem Treffer wieder als neuer Textanfang gesehen wird? Enthalten deine Pfadangaben Newlines, oder in welchem Zusammenhang benötigst du dieses Verhalten?kyou hat geschrieben:Übrigens glaube ich, eben noch einen Bug gefunden zu haben: https://github.com/msztolcman/subst/issues/8.
Vielleicht sollte man die Funktionalität auch auslagern, falls der Autor den Zusammenhang nicht wirklich versteht. Möglicherweise kann das dann als eine Art Plugin integriert werden. Oder es läuft eben komplett als eigenes Projekt. Ich würde mich wohl bei Bedarf daran versuchen, falls es dir weiterhilft...
Für simple Ersetzungen reicht ja im Grunde das schon aus:
Der zu ersetzende Inhalt kann hier z.B. über eine Pipe in die Standardeingabe des kleinen Programms geleitet werden. Ausgegeben werden dann die entsprechenden Ersetzungen.
Code: Alles auswählen
from glob import iglob
from sys import stdin
def replace(lines):
for line in lines:
pattern = line.rstrip()
for path in iglob(pattern):
yield path
def main():
for path in replace(stdin):
print(path)
if __name__ == '__main__':
main()https://docs.python.org/2/library/re.html#re.MULTILINE:Und der Fehler liegt wo genau?
When specified, the pattern character '^' matches at the beginning of the string and at the beginning of each line (immediately following each newline); and the pattern character '$' matches at the end of the string and at the end of each line (immediately preceding each newline). By default, '^' matches only at the beginning of the string, and '$' only at the end of the string and immediately before the newline (if any) at the end of the string.
Ich finde die Erklärung verwirrend. Mir ist unklar, was String in diesem Kontext bedeuten soll. Wenn ich davon ausgehe, dass "Beta Gamma Delta" ein String ist, der zwischen den Strings "Alpha" und "Zeta" liegt, spielt es doch keine Rolle, ob das Pattern "^Beta" oder "Beta" ist. Oder anders: Woher soll mein Pattern wissen, in welchem der vielen möglichen Strings in meinem Text ich suche. Ich weiß schlichtweg nicht, welchen Sinn das Caret haben soll, wenn es nicht um den Anfang von Zeilen, sondern um den Anfang von Strings geht.
Und weil ich die Erklärung verwirrend finde, habe ich es auf regex.com getestet: http://regexr.com/3gqjc.
Die Flag "global" entspricht "--count 0". ("--count 0" ist die Default.)
Die Flag "multiline" entspricht "--pattern-multiline".
Aber bei einem gegebenen Text:
Code: Alles auswählen
Test Test
Test Test
Test Test
Test TestCode: Alles auswählen
subst --count 0 --pattern-multiline -p "^Test Test\nTest" -r "Match Match\nMatch" "Text.txt"Code: Alles auswählen
subst --count 0 --pattern-multiline -p "^Test Test\r\nTest" -r "Match Match\r\nMatch" "Text.txt"-l bedeutet, dass der Text Zeile für Zeile in den Speicher eingelesen wird. Ohne die Option -l wird der gesamte Text in den Speicher eingelesen. Mit -l kann also "^Test Test\nTest" nicht erfasst werden, weil der dritte String "Test" schon in der nächsten Zeile liegt, die subst.py noch nicht eingelesen hat. -l ist nicht das Gegenteil von --pattern-multiline, wie man erwarten könnte. Der Punkt ist einfach, dass es keine Kombination von Optionen gibt, mit der sich jedes Auftreten von "^Test Test\r\nTest" bzw "^Test Test\nTest" erfassen lässt.
In der Regex-Sprache ist das so, weil der Standard halt der komplette Text ist. Mit Multiline sagst du, dass du einzelne Zeilen betrachten willst. Bei dem von dir verwendeten Programm ist jedoch die zeilenweise Betrachtung der Standard und Multiline meint, dass alle Zeilen in einem Rutsch gesehen werden sollen (d.h. Caret meint das erste Zeichen vom kompletten Text, anstatt von der jeweiligen Zeile). Du musst hier halt genau umgekehrt denken.
Ich hab übrigens meinen Eigenbau noch etwas erweitert:
Bringt dir das was für dein Vorhaben? In dem Fall könnte ich natürlich noch die Behandlung von Carets mit aufnehmen...
Ich hab übrigens meinen Eigenbau noch etwas erweitert:
Code: Alles auswählen
#!/usr/bin/env python
from __future__ import print_function
from glob import has_magic, iglob
from sys import argv, stderr, stdin, stdout
from textwrap import dedent
def replace(lines):
"""
Replace lines containing wildcards with their real paths.
Input can be any iterable (list, file object, ...)
"""
for line in lines:
pattern = line.rstrip()
if not has_magic(pattern):
# No wildcard -> No change
yield pattern
else:
for path in iglob(pattern):
yield path
def print_replaced(lines, output_stream=stdout):
"""
Print replacements for given lines if they contain wildcards.
Otherwise, print the original line.
"""
for path in replace(lines):
print(path, file=output_stream)
def main():
"""
Print replacements for given lines using shell-like globbing.
An additional argument defines the input's filename.
If omitted, STDIN is used.
Invokation:
pathrepl [filename]
Examples:
pathrepl pathfile.txt
pathfile.txt > pathrepl
echo *.py | pathrepl
"""
if len(argv) == 1:
print_replaced(stdin)
elif len(argv) == 2:
try:
with open(argv[1]) as stream:
print_replaced(stream)
except IOError as err:
print('I/O Error:', err, file=stderr)
else:
print(dedent(main.__doc__), file=stderr)
if __name__ == '__main__':
main()Aber es gibt ja keine Kombination von Optionen (inkl. des Verzichts auf bestimmte Optionen), mit denen subst jedes Auftreten des Musters "^Test Test\nTest" im Text erfassen kann. Umgekehrt zu denken, nützt also nichts. Und das bedeutet nichts anders, als das subst derzeit Regex nicht abdeckt. Da reguläre Ausdrücke aber auch ohne solche Bugs sehr komplex sein können, ist es mit Bugs ausgesprochen schwer durch reine Überlegung herauszufinden, ob der User selbst oder aber das Programm einen Fehler gemacht hat. Der beste Weg ist dann ein Test mit einem anderen Ersetzungsprogramm, das in Bezug auf die Ersetzungen bugfrei ist. UltraEdit verhält sich übrigens genauso wie das Ersetzen-Programm, das auf regexr.com verwendet wird.Du musst hier halt genau umgekehrt denken.
Edited: Ein wesentlicher Unterschied zwischen Ultraedit bzw. dem auf regexr.com verwendeten Programm und subst ist, dass der User nur entscheiden kann, ob er jedes oder nur das erste Auftreten des Musters erfassen will. Subst kann hingegen mit "--count n" auch maximal n Ersetzungen durchführen.
Anscheinend bist du nicht daran interessiert, dass statt Anpassungen als Alternative einfach neuer Code geschrieben wird. Dann bin ich hier wohl raus. Ich finde den Code des gezeigten Projekts kompliziert und werde mich da sicher nicht ohne Not einarbeiten. Nichts für ungut.