From 206679996a5cea67553870412af174c3dda071f4 Mon Sep 17 00:00:00 2001 From: oliverpool Date: Sun, 4 Jun 2017 11:20:21 +0200 Subject: [PATCH 1/3] new pylint --- Makefile | 6 +- pylintrc | 557 ++++++++++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 559 insertions(+), 4 deletions(-) diff --git a/Makefile b/Makefile index 9dccd129..34e73dd5 100644 --- a/Makefile +++ b/Makefile @@ -5,4 +5,8 @@ test: install: pip3 install -r Requirements.txt - python3 setup.py develop \ No newline at end of file + python3 setup.py develop + +lint: + # autopep8 -ir . + pylint patacrep test --rcfile=pylintrc diff --git a/pylintrc b/pylintrc index 0208af8f..85f14cbf 100644 --- a/pylintrc +++ b/pylintrc @@ -1,5 +1,556 @@ -[VARIABLES] -dummy-variables-rgx=_|dummy +#[MESSAGES CONTROL] +#disable= logging-format-interpolation, I + + + +# Based on Apache 2.0 licensed code from https://github.com/ClusterHQ/flocker + +[MASTER] + +# Specify a configuration file. +#rcfile= + +# Python code to execute, usually for sys.path manipulation such as +# pygtk.require(). +#init-hook="import quarkc" + +# Add files or directories to the blacklist. They should be base names, not +# paths. +ignore= + +# Pickle collected data for later comparisons. +persistent=no + +# List of plugins (as comma separated values of python modules names) to load, +# usually to register additional checkers. +load-plugins= + +# Use multiple processes to speed up Pylint. +# DO NOT CHANGE THIS VALUES >1 HIDE RESULTS!!!!! +jobs=1 + +# Allow loading of arbitrary C extensions. Extensions are imported into the +# active Python interpreter and may run arbitrary code. +unsafe-load-any-extension=no + +# A comma-separated list of package or module names from where C extensions may +# be loaded. Extensions are loading into the active Python interpreter and may +# run arbitrary code +extension-pkg-whitelist= + +# Allow optimization of some AST trees. This will activate a peephole AST +# optimizer, which will apply various small optimizations. For instance, it can +# be used to obtain the result of joining multiple strings with the addition +# operator. Joining a lot of strings can lead to a maximum recursion error in +# Pylint and this flag can prevent that. It has one side effect, the resulting +# AST will be different than the one from reality. +optimize-ast=no + [MESSAGES CONTROL] -disable= logging-format-interpolation, I + +# Only show warnings with the listed confidence levels. Leave empty to show +# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED +confidence= + +# Enable the message, report, category or checker with the given id(s). You can +# either give multiple identifier separated by comma (,) or put this option +# multiple time. See also the "--disable" option for examples. +disable=all + +enable=import-error, + import-self, + reimported, + wildcard-import, + misplaced-future, + deprecated-module, + unpacking-non-sequence, + invalid-all-object, + undefined-all-variable, + used-before-assignment, + cell-var-from-loop, + global-variable-undefined, + redefine-in-handler, + unused-import, + unused-wildcard-import, + global-variable-not-assigned, + undefined-loop-variable, + global-statement, + global-at-module-level, + bad-open-mode, + redundant-unittest-assert, + boolean-datetime + deprecated-method, + anomalous-unicode-escape-in-string, + anomalous-backslash-in-string, + not-in-loop, + continue-in-finally, + abstract-class-instantiated, + star-needs-assignment-target, + duplicate-argument-name, + return-in-init, + too-many-star-expressions, + nonlocal-and-global, + return-outside-function, + return-arg-in-generator, + invalid-star-assignment-target, + bad-reversed-sequence, + nonexistent-operator, + yield-outside-function, + init-is-generator, + nonlocal-without-binding, + lost-exception, + assert-on-tuple, + dangerous-default-value, + duplicate-key, + useless-else-on-loop + expression-not-assigned, + confusing-with-statement, + unnecessary-lambda, + pointless-statement, + pointless-string-statement, + unnecessary-pass, + unreachable, + eval-used, + exec-used, + using-constant-test, + bad-super-call, + missing-super-argument, + slots-on-old-class, + super-on-old-class, + property-on-old-class, + not-an-iterable, + not-a-mapping, + format-needs-mapping, + truncated-format-string, + missing-format-string-key, + mixed-format-string, + too-few-format-args, + bad-str-strip-call, + too-many-format-args, + bad-format-character, + format-combined-specification, + bad-format-string-key, + bad-format-string, + missing-format-attribute, + missing-format-argument-key, + unused-format-string-argument + unused-format-string-key, + invalid-format-index, + bad-indentation, + mixed-indentation, + unnecessary-semicolon, + lowercase-l-suffix, + invalid-encoded-data, + unpacking-in-except, + import-star-module-level, + long-suffix, + old-octal-literal, + old-ne-operator, + backtick, + old-raise-syntax, + metaclass-assignment, + next-method-called, + dict-iter-method, + dict-view-method, + indexing-exception, + raising-string, + using-cmp-argument, + cmp-method, + coerce-method, + delslice-method, + getslice-method, + hex-method, + nonzero-method, + t-method, + setslice-method, + old-division, + logging-format-truncated, + logging-too-few-args, + logging-too-many-args, + logging-unsupported-format, + logging-format-interpolation, + invalid-unary-operand-type, + unsupported-binary-operation, + not-callable, + redundant-keyword-arg, + assignment-from-no-return, + assignment-from-none, + not-context-manager, + repeated-keyword, + missing-kwoa, + no-value-for-parameter, + invalid-sequence-index, + invalid-slice-index, + unexpected-keyword-arg, + unsupported-membership-test, + unsubscriptable-object, + access-member-before-definition, + method-hidden, + assigning-non-slot, + duplicate-bases, + inconsistent-mro, + inherit-non-class, + invalid-slots, + invalid-slots-object, + no-method-argument, + no-self-argument, + unexpected-special-method-signature, + non-iterator-returned, + arguments-differ, + signature-differs, + bad-staticmethod-argument, + non-parent-init-called, + bad-except-order, + catching-non-exception, + bad-exception-context, + notimplemented-raised, + raising-bad-type, + raising-non-exception, + misplaced-bare-raise, + duplicate-except, + broad-except, + nonstandard-exception, + binary-op-exception, + bare-except, + not-async-context-manager, + yield-inside-async-function + +# Needs investigation: +# abstract-method (might be indicating a bug? probably not though) +# protected-access (requires some refactoring) +# attribute-defined-outside-init (requires some refactoring) +# super-init-not-called (requires some cleanup) + +# Things we'd like to enable someday: +# redefined-builtin (requires a bunch of work to clean up our code first) +# redefined-outer-name (requires a bunch of work to clean up our code first) +# undefined-variable (re-enable when pylint fixes https://github.com/PyCQA/pylint/issues/760) +# no-name-in-module (giving us spurious warnings https://github.com/PyCQA/pylint/issues/73) +# unused-argument (need to clean up or code a lot, e.g. prefix unused_?) +# function-redefined (@overload causes lots of spurious warnings) +# too-many-function-args (@overload causes spurious warnings... I think) +# parameter-unpacking (needed for eventual Python 3 compat) +# print-statement (needed for eventual Python 3 compat) +# filter-builtin-not-iterating (Python 3) +# map-builtin-not-iterating (Python 3) +# range-builtin-not-iterating (Python 3) +# zip-builtin-not-iterating (Python 3) +# many others relevant to Python 3 +# unused-variable (a little work to cleanup, is all) + +# ... +[REPORTS] + +# Set the output format. Available formats are text, parseable, colorized, msvs +# (visual studio) and html. You can also give a reporter class, eg +# mypackage.mymodule.MyReporterClass. +output-format=parseable + +# Put messages in a separate file for each module / package specified on the +# command line instead of printing them on stdout. Reports (if any) will be +# written in a file name "pylint_global.[txt|html]". +files-output=no + +# Tells whether to display a full report or only the messages +reports=no + +# Python expression which should return a note less than 10 (10 is the highest +# note). You have access to the variables errors warning, statement which +# respectively contain the number of errors / warnings messages and the total +# number of statements analyzed. This is used by the global evaluation report +# (RP0004). +evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10) + +# Template used to display messages. This is a python new-style format string +# used to format the message information. See doc for all details +#msg-template= + + +[LOGGING] + +# Logging modules to check that the string format arguments are in logging +# function parameter format +logging-modules=logging + + +[FORMAT] + +# Maximum number of characters on a single line. +max-line-length=100 + +# Regexp for a line that is allowed to be longer than the limit. +ignore-long-lines=^\s*(# )??$ + +# Allow the body of an if to be on the same line as the test if there is no +# else. +single-line-if-stmt=no + +# List of optional constructs for which whitespace checking is disabled. `dict- +# separator` is used to allow tabulation in dicts, etc.: {1 : 1,\n222: 2}. +# `trailing-comma` allows a space between comma and closing bracket: (a, ). +# `empty-line` allows space-only lines. +no-space-check=trailing-comma,dict-separator + +# Maximum number of lines in a module +max-module-lines=1000 + +# String used as indentation unit. This is usually " " (4 spaces) or "\t" (1 +# tab). +indent-string=' ' + +# Number of spaces of indent required inside a hanging or continued line. +indent-after-paren=4 + +# Expected format of line ending, e.g. empty (any line ending), LF or CRLF. +expected-line-ending-format= + + +[TYPECHECK] + +# Tells whether missing members accessed in mixin class should be ignored. A +# mixin class is detected if its name ends with "mixin" (case insensitive). +ignore-mixin-members=yes + +# List of module names for which member attributes should not be checked +# (useful for modules/projects where namespaces are manipulated during runtime +# and thus existing member attributes cannot be deduced by static analysis. It +# supports qualified module names, as well as Unix pattern matching. +ignored-modules= + +# List of classes names for which member attributes should not be checked +# (useful for classes with attributes dynamically set). This supports can work +# with qualified names. +ignored-classes= + +# List of members which are set dynamically and missed by pylint inference +# system, and so shouldn't trigger E1101 when accessed. Python regular +# expressions are accepted. +generated-members= + + +[VARIABLES] + +# Tells whether we should check for unused import in __init__ files. +init-import=no + +# A regular expression matching the name of dummy variables (i.e. expectedly +# not used). +dummy-variables-rgx=_$|dummy + +# List of additional names supposed to be defined in builtins. Remember that +# you should avoid to define new builtins when possible. +additional-builtins= + +# List of strings which can identify a callback function by name. A callback +# name must start or end with one of those strings. +callbacks=cb_,_cb + + +[SIMILARITIES] + +# Minimum lines number of a similarity. +min-similarity-lines=4 + +# Ignore comments when computing similarities. +ignore-comments=yes + +# Ignore docstrings when computing similarities. +ignore-docstrings=yes + +# Ignore imports when computing similarities. +ignore-imports=no + + +[SPELLING] + +# Spelling dictionary name. Available dictionaries: none. To make it working +# install python-enchant package. +spelling-dict= + +# List of comma separated words that should not be checked. +spelling-ignore-words= + +# A path to a file that contains private dictionary; one word per line. +spelling-private-dict-file= + +# Tells whether to store unknown words to indicated private dictionary in +# --spelling-private-dict-file option instead of raising a message. +spelling-store-unknown-words=no + + +[MISCELLANEOUS] + +# List of note tags to take in consideration, separated by a comma. +notes=FIXME,XXX,TODO + + +[BASIC] + +# List of builtins function names that should not be used, separated by a comma +bad-functions=map,filter,input + +# Good variable names which should always be accepted, separated by a comma +good-names=i,j,k,ex,Run,_ + +# Bad variable names which should always be refused, separated by a comma +bad-names=foo,bar,baz,toto,tutu,tata + +# Colon-delimited sets of names that determine each other's naming style when +# the name regexes allow several styles. +name-group= + +# Include a hint for the correct naming format with invalid-name +include-naming-hint=no + +# Regular expression matching correct function names +function-rgx=[a-z_][a-z0-9_]{2,30}$ + +# Naming hint for function names +function-name-hint=[a-z_][a-z0-9_]{2,30}$ + +# Regular expression matching correct variable names +variable-rgx=[a-z_][a-z0-9_]{2,30}$ + +# Naming hint for variable names +variable-name-hint=[a-z_][a-z0-9_]{2,30}$ + +# Regular expression matching correct constant names +const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$ + +# Naming hint for constant names +const-name-hint=(([A-Z_][A-Z0-9_]*)|(__.*__))$ + +# Regular expression matching correct attribute names +attr-rgx=[a-z_][a-z0-9_]{2,30}$ + +# Naming hint for attribute names +attr-name-hint=[a-z_][a-z0-9_]{2,30}$ + +# Regular expression matching correct argument names +argument-rgx=[a-z_][a-z0-9_]{2,30}$ + +# Naming hint for argument names +argument-name-hint=[a-z_][a-z0-9_]{2,30}$ + +# Regular expression matching correct class attribute names +class-attribute-rgx=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$ + +# Naming hint for class attribute names +class-attribute-name-hint=([A-Za-z_][A-Za-z0-9_]{2,30}|(__.*__))$ + +# Regular expression matching correct inline iteration names +inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$ + +# Naming hint for inline iteration names +inlinevar-name-hint=[A-Za-z_][A-Za-z0-9_]*$ + +# Regular expression matching correct class names +class-rgx=[A-Z_][a-zA-Z0-9]+$ + +# Naming hint for class names +class-name-hint=[A-Z_][a-zA-Z0-9]+$ + +# Regular expression matching correct module names +module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$ + +# Naming hint for module names +module-name-hint=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$ + +# Regular expression matching correct method names +method-rgx=[a-z_][a-z0-9_]{2,30}$ + +# Naming hint for method names +method-name-hint=[a-z_][a-z0-9_]{2,30}$ + +# Regular expression which should only match function or class names that do +# not require a docstring. +no-docstring-rgx=^_ + +# Minimum line length for functions/classes that require docstrings, shorter +# ones are exempt. +docstring-min-length=-1 + + +[ELIF] + +# Maximum number of nested blocks for function / method body +max-nested-blocks=5 + + +[IMPORTS] + +# Deprecated modules which should not be used, separated by a comma +deprecated-modules=regsub,TERMIOS,Bastion,rexec + +# Create a graph of every (i.e. internal and external) dependencies in the +# given file (report RP0402 must not be disabled) +import-graph= + +# Create a graph of external dependencies in the given file (report RP0402 must +# not be disabled) +ext-import-graph= + +# Create a graph of internal dependencies in the given file (report RP0402 must +# not be disabled) +int-import-graph= + + +[DESIGN] + +# Maximum number of arguments for function / method +max-args=5 + +# Argument names that match this expression will be ignored. Default to name +# with leading underscore +ignored-argument-names=_.* + +# Maximum number of locals for function / method body +max-locals=15 + +# Maximum number of return / yield for function / method body +max-returns=6 + +# Maximum number of branch for function / method body +max-branches=12 + +# Maximum number of statements in function / method body +max-statements=50 + +# Maximum number of parents for a class (see R0901). +max-parents=7 + +# Maximum number of attributes for a class (see R0902). +max-attributes=7 + +# Minimum number of public methods for a class (see R0903). +min-public-methods=2 + +# Maximum number of public methods for a class (see R0904). +max-public-methods=20 + +# Maximum number of boolean expressions in a if statement +max-bool-expr=5 + + +[CLASSES] + +# List of method names used to declare (i.e. assign) instance attributes. +defining-attr-methods=__init__,__new__,setUp + +# List of valid names for the first argument in a class method. +valid-classmethod-first-arg=cls + +# List of valid names for the first argument in a metaclass class method. +valid-metaclass-classmethod-first-arg=mcs + +# List of member names, which should be excluded from the protected access +# warning. +exclude-protected=_asdict,_fields,_replace,_source,_make + + +[EXCEPTIONS] + +# Exceptions that will emit a warning when being caught. Defaults to +# "Exception" +overgeneral-exceptions=Exception \ No newline at end of file From 6ec5b1064b274cb49faaf6d16cc2e3e74fd21777 Mon Sep 17 00:00:00 2001 From: oliverpool Date: Sun, 4 Jun 2017 11:37:54 +0200 Subject: [PATCH 2/3] fix pylint --- patacrep/content/__init__.py | 8 ++++---- patacrep/content/section.py | 2 +- patacrep/content/setcounter.py | 2 +- patacrep/content/song.py | 4 ++-- patacrep/content/songsection.py | 2 +- patacrep/files.py | 2 +- patacrep/songbook/__main__.py | 4 ++-- patacrep/songs/chordpro/lexer.py | 4 ++-- patacrep/songs/latex/__init__.py | 2 +- pylintrc | 2 +- setup.py | 2 +- test/dynamic.py | 2 +- test/test_doctest.py | 2 +- 13 files changed, 19 insertions(+), 19 deletions(-) diff --git a/patacrep/content/__init__.py b/patacrep/content/__init__.py index 12e9bed9..27c26691 100755 --- a/patacrep/content/__init__.py +++ b/patacrep/content/__init__.py @@ -82,7 +82,7 @@ class ContentItem: here. """ - def render(self, __context): + def render(self, context): """Render this content item. Returns a string, to be placed verbatim in the generated .tex file. @@ -91,7 +91,7 @@ class ContentItem: # Block management - def begin_new_block(self, __previous, __context): + def begin_new_block(self, previous, context): """Return a boolean stating if a new block is to be created. # Arguments @@ -108,11 +108,11 @@ class ContentItem: """ return True - def begin_block(self, __context): + def begin_block(self, context): """Return the string to begin a block.""" return "" - def end_block(self, __context): + def end_block(self, context): """Return the string to end a block.""" return "" diff --git a/patacrep/content/section.py b/patacrep/content/section.py index 78776d5c..c045d8c5 100755 --- a/patacrep/content/section.py +++ b/patacrep/content/section.py @@ -22,7 +22,7 @@ class Section(ContentItem): self.name = name self.short = short - def render(self, __context): + def render(self, context): if self.short is None or self.keyword not in KEYWORDS: return r'\{}{{{}}}'.format(self.keyword, self.name) else: diff --git a/patacrep/content/setcounter.py b/patacrep/content/setcounter.py index 400ce26b..ca0d9bc7 100755 --- a/patacrep/content/setcounter.py +++ b/patacrep/content/setcounter.py @@ -10,7 +10,7 @@ class CounterSetter(ContentItem): self.name = name self.value = value - def render(self, __context): + def render(self, context): """Set the value of the counter.""" return r'\setcounter{{{}}}{{{}}}'.format(self.name, self.value) diff --git a/patacrep/content/song.py b/patacrep/content/song.py index dc35b5ae..9708556e 100755 --- a/patacrep/content/song.py +++ b/patacrep/content/song.py @@ -30,7 +30,7 @@ class SongRenderer(ContentItem): return True return False - def begin_new_block(self, previous, __context): + def begin_new_block(self, previous, context): """Return a boolean stating if a new block is to be created.""" return not isinstance(previous, SongRenderer) @@ -41,7 +41,7 @@ class SongRenderer(ContentItem): indexes = "" return r'\begin{songs}{%s}' % indexes - def end_block(self, __context): + def end_block(self, context): """Return the string to end a block.""" return r'\end{songs}' diff --git a/patacrep/content/songsection.py b/patacrep/content/songsection.py index 132c0666..f9d17593 100755 --- a/patacrep/content/songsection.py +++ b/patacrep/content/songsection.py @@ -15,7 +15,7 @@ class SongSection(ContentItem): self.keyword = keyword self.name = name - def render(self, __context): + def render(self, context): """Render this section or chapter.""" return r'\{}{{{}}}'.format(self.keyword, self.name) diff --git a/patacrep/files.py b/patacrep/files.py index 114513d4..22d9cb44 100644 --- a/patacrep/files.py +++ b/patacrep/files.py @@ -34,7 +34,7 @@ def recursive_find(root_directory, extensions=None): pattern = re.compile(r'.*\.({})$'.format('|'.join(extensions))) with chdir(root_directory): - for root, __ignored, filenames in os.walk(os.curdir): + for root, _, filenames in os.walk(os.curdir): for filename in filenames: if pattern.match(filename): matches.append(os.path.join(root, filename)) diff --git a/patacrep/songbook/__main__.py b/patacrep/songbook/__main__.py index 6793b6f1..94b0b2d3 100644 --- a/patacrep/songbook/__main__.py +++ b/patacrep/songbook/__main__.py @@ -19,7 +19,7 @@ LOGGER = logging.getLogger() # pylint: disable=too-few-public-methods class ParseStepsAction(argparse.Action): """Argparse action to split a string into a list.""" - def __call__(self, __parser, namespace, values, __option_string=None): + def __call__(self, parser, namespace, values, option_string=None): if not getattr(namespace, self.dest): setattr(namespace, self.dest, []) setattr( @@ -33,7 +33,7 @@ class ParseStepsAction(argparse.Action): class VerboseAction(argparse.Action): """Set verbosity level with option --verbose.""" - def __call__(self, *_args, **_kwargs): + def __call__(self, parser, namespace, values, option_string=None): LOGGER.setLevel(logging.DEBUG) def yesno_type(string): diff --git a/patacrep/songs/chordpro/lexer.py b/patacrep/songs/chordpro/lexer.py index c63049aa..535fe889 100644 --- a/patacrep/songs/chordpro/lexer.py +++ b/patacrep/songs/chordpro/lexer.py @@ -121,11 +121,11 @@ class ChordProLexer: r'[^{}\\\r\n\]\[\t ]+' return token - def t_LBRACKET(self, __token): + def t_LBRACKET(self, token): r'\[' self.lexer.push_state('chord') - def t_chord_RBRACKET(self, __token): + def t_chord_RBRACKET(self, token): r'\]' self.lexer.pop_state() diff --git a/patacrep/songs/latex/__init__.py b/patacrep/songs/latex/__init__.py index 27100eba..ddae6a28 100644 --- a/patacrep/songs/latex/__init__.py +++ b/patacrep/songs/latex/__init__.py @@ -29,7 +29,7 @@ class Latex2LatexSong(Song): else: self.authors = [] - def render(self): + def render(self, *args, **kwargs): """Return the code rendering the song.""" # pylint: disable=signature-differs filename = os.path.basename(self.fullpath) diff --git a/pylintrc b/pylintrc index 85f14cbf..87d023b0 100644 --- a/pylintrc +++ b/pylintrc @@ -169,7 +169,7 @@ enable=import-error, logging-too-few-args, logging-too-many-args, logging-unsupported-format, - logging-format-interpolation, + # logging-format-interpolation, invalid-unary-operand-type, unsupported-binary-operation, not-callable, diff --git a/setup.py b/setup.py index aedd2009..4e9230d2 100755 --- a/setup.py +++ b/setup.py @@ -30,7 +30,7 @@ if sys.platform[0:3] == 'win': olddir = os.getcwd() os.chdir(root_directory) - for root, __ignored, filenames in os.walk(os.curdir): + for root, _, filenames in os.walk(os.curdir): for filename in filenames: yield os.path.join(root, filename) os.chdir(olddir) diff --git a/test/dynamic.py b/test/dynamic.py index 494dfc8f..4313f23a 100644 --- a/test/dynamic.py +++ b/test/dynamic.py @@ -13,7 +13,7 @@ class DynamicTest(type): def __init__(cls, name, bases, nmspc): super().__init__(name, bases, nmspc) - for methodname, testmethod in cls._iter_testmethods(): + for methodname, testmethod in cls._iter_testmethods(): #pylint: disable=no-value-for-parameter setattr(cls, methodname, testmethod) def _iter_testmethods(cls): diff --git a/test/test_doctest.py b/test/test_doctest.py index 98175716..f101bbc1 100644 --- a/test/test_doctest.py +++ b/test/test_doctest.py @@ -22,7 +22,7 @@ import doctest import patacrep from patacrep import files -def load_tests(__loader, tests, __pattern): +def load_tests(loader, tests, pattern): """Load tests (doctests). """ # Loading doctests From cede0444fc84f0fe7409782a0ded1926e8a076ad Mon Sep 17 00:00:00 2001 From: oliverpool Date: Sun, 4 Jun 2017 11:43:03 +0200 Subject: [PATCH 3/3] fix DeprecationWarning: invalid escape sequence \e --- patacrep/authors.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/patacrep/authors.py b/patacrep/authors.py index 03221ebc..e904910b 100644 --- a/patacrep/authors.py +++ b/patacrep/authors.py @@ -33,7 +33,7 @@ def split_author_names(string): >>> split_author_names("Edgar Allan Poe") ('Poe', 'Edgar Allan') - >>> split_author_names("Edgar Allan \emph {Poe}") + >>> split_author_names("Edgar Allan \\emph {Poe}") ('{Poe}', 'Edgar Allan \\emph') >>> split_author_names(r"The Rolling\ Stones") ('Rolling~Stones', 'The')