plover 5.0.0.dev2__py3-none-any.whl → 5.0.0.dev3__py3-none-any.whl

plover/machine/stentura.py

@@ -6,8 +6,7 @@
 # is a connection error.
 # TODO: Address any generic exceptions still left.
 
-"""Thread-based monitoring of a stenotype machine using the stentura protocol.
-"""
+"""Thread-based monitoring of a stenotype machine using the stentura protocol."""
 
 """
 The stentura protocol uses packets to communicate with the machine. A
@@ -157,8 +156,8 @@ def buffer(object, offset=None, size=None):
     if offset is None:
         offset = 0
     if size is None:
-        size = len(object)-offset
-    return memoryview(object)[offset:offset+size]
+        size = len(object) - offset
+    return memoryview(object)[offset : offset + size]
 
 
 def _allocate_buffer():
@@ -167,24 +166,29 @@ def _allocate_buffer():
 
 class _ProtocolViolationException(Exception):
     """Something has happened that is doesn't follow the protocol."""
+
     pass
 
 
 class _StopException(Exception):
     """The thread was asked to stop."""
+
     pass
 
 
 class _TimeoutException(Exception):
     """An operation has timed out."""
+
     pass
 
 
 class _ConnectionLostException(Exception):
     """Cannot communicate with the machine."""
+
     pass
 
 
+# fmt: off
 _CRC_TABLE = [
     0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241,
     0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440,
@@ -219,6 +223,7 @@ _CRC_TABLE = [
     0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641,
     0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081, 0x4040
 ]
+# fmt: on
 
 
 def _crc(data, offset=None, size=None):
@@ -250,8 +255,7 @@ def _crc(data, offset=None, size=None):
     checksum = 0
     for n in range(offset, offset + size):
         b = data[n]
-        checksum = (_CRC_TABLE[(checksum ^ b) & 0xff] ^
-                    ((checksum >> 8) & 0xff))
+        checksum = _CRC_TABLE[(checksum ^ b) & 0xFF] ^ ((checksum >> 8) & 0xFF)
     return checksum
 
 
@@ -265,14 +269,17 @@ def _write_to_buffer(buf, offset, data):
     - offset. The offset at which to start writing.
     - data: An iterable containing the data to write.
     """
-    buf[offset:offset+len(data)] = data
+    buf[offset : offset + len(data)] = data
+
 
 # Helper table for parsing strokes of the form:
 # 11^#STKP 11WHRAO* 11EUFRPB 11LGTSDZ
-_STENO_KEY_CHART = ('^', '#', 'S-', 'T-', 'K-', 'P-',    # Byte #1
-                    'W-', 'H-', 'R-', 'A-', 'O-', '*',   # Byte #2
-                    '-E', '-U', '-F', '-R', '-P', '-B',  # Byte #3
-                    '-L', '-G', '-T', '-S', '-D', '-Z')  # Byte #4
+# fmt: off
+_STENO_KEY_CHART = ("^", "#", "S-", "T-", "K-", "P-",    # Byte #1
+                    "W-", "H-", "R-", "A-", "O-", "*",   # Byte #2
+                    "-E", "-U", "-F", "-R", "-P", "-B",  # Byte #3
+                    "-L", "-G", "-T", "-S", "-D", "-Z")  # Byte #4
+# fmt: on
 
 
 def _parse_stroke(a, b, c, d):
@@ -288,10 +295,8 @@ def _parse_stroke(a, b, c, d):
              e.g. ['S-', 'A-', '-T']
 
     """
-    fullstroke = (((a & 0x3f) << 18) | ((b & 0x3f) << 12) |
-                  ((c & 0x3f) << 6) | d & 0x3f)
-    return [_STENO_KEY_CHART[i] for i in range(24)
-            if (fullstroke & (1 << (23 - i)))]
+    fullstroke = ((a & 0x3F) << 18) | ((b & 0x3F) << 12) | ((c & 0x3F) << 6) | d & 0x3F
+    return [_STENO_KEY_CHART[i] for i in range(24) if (fullstroke & (1 << (23 - i)))]
 
 
 def _parse_strokes(data):
@@ -309,7 +314,8 @@ def _parse_strokes(data):
     strokes = []
     if (len(data) % 4) != 0:
         raise _ProtocolViolationException(
-            "Data size is not divisible by 4: %d" % (len(data)))
+            "Data size is not divisible by 4: %d" % (len(data))
+        )
     for b in data:
         if (b & 0b11000000) != 0b11000000:
             raise _ProtocolViolationException("Data is not stroke: 0x%X" % (b))
@@ -317,6 +323,7 @@ def _parse_strokes(data):
         strokes.append(_parse_stroke(a, b, c, d))
     return strokes
 
+
 # Actions
 _CLOSE = 0x2
 _DELETE = 0x3
@@ -329,8 +336,8 @@ _RESET = 0x14
 _TERM = 0x15
 
 # Compiled struct for writing request headers.
-_REQUEST_STRUCT = struct.Struct('<2B7H')
-_SHORT_STRUCT = struct.Struct('<H')
+_REQUEST_STRUCT = struct.Struct("<2B7H")
+_SHORT_STRUCT = struct.Struct("<H")
 
 
 def _make_request(buf, action, seq, p1=0, p2=0, p3=0, p4=0, p5=0, data=None):
@@ -351,8 +358,7 @@ def _make_request(buf, action, seq, p1=0, p2=0, p3=0, p4=0, p5=0, data=None):
     length = 18
     if data:
         length += len(data) + 2  # +2 for the data CRC.
-    _REQUEST_STRUCT.pack_into(buf, 0, 1, seq, length, action,
-                              p1, p2, p3, p4, p5)
+    _REQUEST_STRUCT.pack_into(buf, 0, 1, seq, length, action, p1, p2, p3, p4, p5)
     crc = _crc(buf, 1, 15)
     _SHORT_STRUCT.pack_into(buf, 16, crc)
     if data:
@@ -460,7 +466,10 @@ def _read_data(port, stop, buf, offset, num_bytes):
     _write_to_buffer(buf, offset, read_bytes)
     return len(read_bytes)
 
+
 MINIMUM_PACKET_LENGTH = 14
+
+
 def _read_packet(port, stop, buf):
     """Read a full packet from the port.
 
@@ -487,8 +496,7 @@ def _read_packet(port, stop, buf):
     # Packet length should always be at least 14 bytes long
     if packet_length < MINIMUM_PACKET_LENGTH:
         raise _ProtocolViolationException()
-    bytes_read += _read_data(port, stop, buf, bytes_read,
-                             packet_length - bytes_read)
+    bytes_read += _read_data(port, stop, buf, bytes_read, packet_length - bytes_read)
     packet = buffer(buf, 0, bytes_read)
     if not _validate_response(packet):
         raise _ProtocolViolationException()
@@ -548,6 +556,7 @@ def _send_receive(port, stop, packet, buf, max_tries=3):
 
 class _SequenceCounter:
     """A mod 256 counter."""
+
     def __init__(self, seq=0):
         """Init a new counter starting at seq."""
         self.seq = seq
@@ -582,8 +591,10 @@ def _read(port, stop, seq, request_buf, response_buf, stroke_buf, block, byte):
         packet = _make_read(request_buf, seq(), block, byte, length=512)
         response = _send_receive(port, stop, packet, response_buf)
         p1 = _SHORT_STRUCT.unpack(response[8:10])[0]
-        if not ((p1 == 0 and len(response) == 14) or  # No data.
-                (p1 == len(response) - 16)):          # Data.
+        if not (
+            (p1 == 0 and len(response) == 14)  # No data.
+            or (p1 == len(response) - 16)
+        ):  # Data.
             raise _ProtocolViolationException()
         if p1 == 0:
             return block, byte, buffer(stroke_buf, 0, bytes_read)
@@ -595,6 +606,7 @@ def _read(port, stop, seq, request_buf, response_buf, stroke_buf, block, byte):
             block += 1
             byte -= 512
 
+
 def _loop(port, stop, callback, ready_callback, timeout=1):
     """Enter into a loop talking to the machine and returning strokes.
 
@@ -628,15 +640,19 @@ def _loop(port, stop, callback, ready_callback, timeout=1):
     request_buf, response_buf = _allocate_buffer(), _allocate_buffer()
     stroke_buf = _allocate_buffer()
     seq = _SequenceCounter()
-    request = _make_open(request_buf, seq(), b'A', b'REALTIME.000')
+    request = _make_open(request_buf, seq(), b"A", b"REALTIME.000")
     # Any checking needed on the response packet?
     _send_receive(port, stop, request, response_buf)
     # Do a full read to get to the current position in the realtime file.
     block, byte = 0, 0
-    block, byte, _ = _read(port, stop, seq, request_buf, response_buf, stroke_buf, block, byte)
+    block, byte, _ = _read(
+        port, stop, seq, request_buf, response_buf, stroke_buf, block, byte
+    )
     ready_callback()
     while True:
-        block, byte, data = _read(port, stop, seq, request_buf, response_buf, stroke_buf, block, byte)
+        block, byte, data = _read(
+            port, stop, seq, request_buf, response_buf, stroke_buf, block, byte
+        )
         strokes = _parse_strokes(data)
         for stroke in strokes:
             callback(stroke)
@@ -650,13 +666,13 @@ class Stentura(plover.machine.base.SerialStenotypeBase):
     add_callback.
     """
 
-    KEYS_LAYOUT = '''
+    KEYS_LAYOUT = """
         #  #  #  #  #  #  #  #  #  #
         S- T- P- H- * -F -P -L -T -D
         S- K- W- R- * -R -B -G -S -Z
               A- O-   -E -U
         ^
-    '''
+    """
 
     def run(self):
         """Overrides base class run method. Do not call directly."""

plover/machine/txbolt.py

@@ -24,10 +24,12 @@ import plover.machine.base
 # seen. Additionally, if there is no activity then the machine will
 # send a zero byte every few seconds.
 
+# fmt: off
 STENO_KEY_CHART = ("S-", "T-", "K-", "P-", "W-", "H-",  # 00
                    "R-", "A-", "O-", "*", "-E", "-U",   # 01
                    "-F", "-R", "-P", "-B", "-L", "-G",  # 10
                    "-T", "-S", "-D", "-Z", "#")         # 11
+# fmt: on
 
 
 class TxBolt(plover.machine.base.SerialStenotypeBase):
@@ -39,12 +41,12 @@ class TxBolt(plover.machine.base.SerialStenotypeBase):
 
     """
 
-    KEYS_LAYOUT = '''
+    KEYS_LAYOUT = """
         #  #  #  #  #  #  #  #  #  #
         S- T- P- H- * -F -P -L -T -D
         S- K- W- R- * -R -B -G -S -Z
               A- O-   -E -U
-    '''
+    """
 
     def __init__(self, params):
         super().__init__(params)
@@ -63,7 +65,7 @@ class TxBolt(plover.machine.base.SerialStenotypeBase):
     def run(self):
         """Overrides base class run method. Do not call directly."""
         settings = self.serial_port.getSettingsDict()
-        settings['timeout'] = 0.1 # seconds
+        settings["timeout"] = 0.1  # seconds
         self.serial_port.applySettingsDict(settings)
         self._ready()
         while not self.finished.is_set():

plover/macro/repeat.py

@@ -1,4 +1,3 @@
-
 from plover.steno import Stroke
 
 

plover/macro/retro.py

@@ -1,4 +1,3 @@
-
 from plover.translation import Translation
 from plover.steno import Stroke
 from plover import system
@@ -13,12 +12,13 @@ def toggle_asterisk(translator, stroke, cmdline):
     t = translations[-1]
     translator.untranslate_translation(t)
     keys = set(t.strokes[-1].steno_keys)
-    if '*' in keys:
-        keys.remove('*')
+    if "*" in keys:
+        keys.remove("*")
     else:
-        keys.add('*')
+        keys.add("*")
     translator.translate_stroke(Stroke(keys))
 
+
 def delete_space(translator, stroke, cmdline):
     assert not cmdline
     # Retrospective delete space
@@ -33,13 +33,14 @@ def delete_space(translator, stroke, cmdline):
         if t.english is not None:
             english.append(t.english)
         elif len(t.rtfcre) == 1 and t.rtfcre[0].isdigit():
-            english.append('{&%s}' % t.rtfcre[0])
+            english.append("{&%s}" % t.rtfcre[0])
     if len(english) > 1:
-        t = Translation([stroke], '{^~|^}'.join(english))
+        t = Translation([stroke], "{^~|^}".join(english))
         t.replaced = replaced
         t.is_retrospective_command = True
         translator.translate_translation(t)
 
+
 def insert_space(translator, stroke, cmdline):
     assert not cmdline
     # Retrospective insert space
@@ -50,14 +51,13 @@ def insert_space(translator, stroke, cmdline):
     if replaced.is_retrospective_command:
         return
     lookup_stroke = replaced.strokes[-1]
-    english = [t.english or '/'.join(t.rtfcre)
-               for t in replaced.replaced]
+    english = [t.english or "/".join(t.rtfcre) for t in replaced.replaced]
     if english:
         english.append(
             translator.lookup([lookup_stroke], system.SUFFIX_KEYS)
             or lookup_stroke.rtfcre
         )
-        t = Translation([stroke], ' '.join(english))
+        t = Translation([stroke], " ".join(english))
         t.replaced = [replaced]
         t.is_retrospective_command = True
         translator.translate_translation(t)

plover/macro/undo.py

@@ -2,10 +2,11 @@ from plover.translation import Translation
 from plover.oslayer.config import PLATFORM
 
 
-if PLATFORM == 'mac':
-    BACK_STRING = '{#Alt_L(BackSpace)}{^}'
+if PLATFORM == "mac":
+    BACK_STRING = "{#Alt_L(BackSpace)}{^}"
 else:
-    BACK_STRING = '{#Control_L(BackSpace)}{^}'
+    BACK_STRING = "{#Control_L(BackSpace)}{^}"
+
 
 def undo(translator, stroke, cmdline):
     assert not cmdline

plover/meta/attach.py

@@ -19,23 +19,24 @@ def meta_attach(ctx, meta):
         meta = META_ATTACH_FLAG + meta + META_ATTACH_FLAG
         begin = end = True
     if begin:
-        meta = meta[len(META_ATTACH_FLAG):]
+        meta = meta[len(META_ATTACH_FLAG) :]
         action.prev_attach = True
     if end:
-        meta = meta[:-len(META_ATTACH_FLAG)]
+        meta = meta[: -len(META_ATTACH_FLAG)]
         action.next_attach = True
         action.word_is_finished = False
-    last_word = ctx.last_action.word or ''
+    last_word = ctx.last_action.word or ""
     if not meta:
         # We use an empty connection to indicate a "break" in the
         # application of orthography rules. This allows the
         # stenographer to tell Plover not to auto-correct a word.
         action.orthography = False
     elif (
-        last_word and
-        not meta.isspace() and
-        ctx.last_action.orthography and
-        begin and (not end or has_word_boundary(meta))
+        last_word
+        and not meta.isspace()
+        and ctx.last_action.orthography
+        and begin
+        and (not end or has_word_boundary(meta))
     ):
         new_word = add_suffix(last_word, meta)
         common_len = len(commonprefix([last_word, new_word]))
@@ -49,6 +50,7 @@ def meta_attach(ctx, meta):
         action.word = rightmost_word(last_word + meta)
     return action
 
+
 def meta_carry_capitalize(ctx, meta):
     # Meta format: ^~|content^ (attach flags are optional)
     action = ctx.new_action()
@@ -56,12 +58,12 @@ def meta_carry_capitalize(ctx, meta):
         action.next_case = Case.CAP_FIRST_WORD
     begin = meta.startswith(META_ATTACH_FLAG)
     if begin:
-        meta = meta[len(META_ATTACH_FLAG):]
+        meta = meta[len(META_ATTACH_FLAG) :]
         action.prev_attach = True
-    meta = meta[len(META_CARRY_CAPITALIZATION):]
+    meta = meta[len(META_CARRY_CAPITALIZATION) :]
     end = meta.endswith(META_ATTACH_FLAG)
     if end:
-        meta = meta[:-len(META_ATTACH_FLAG)]
+        meta = meta[: -len(META_ATTACH_FLAG)]
         action.next_attach = True
         action.word_is_finished = False
     if meta or begin or end:

plover/meta/case.py

@@ -7,6 +7,7 @@ def meta_case(ctx, case):
     action.next_case = case
     return action
 
+
 def meta_retro_case(ctx, case):
     case = Case(case.lower())
     action = ctx.copy_last_action()
@@ -16,5 +17,5 @@ def meta_retro_case(ctx, case):
         action.prev_replace = last_words[0]
         action.text = apply_case(last_words[0], case)
     else:
-        action.text = ''
+        action.text = ""
     return action

plover/meta/conditional.py

@@ -3,13 +3,13 @@ import re
 from plover.formatting import _LookAheadAction
 
 
-IF_NEXT_META_RX = re.compile(r'((?:[^\\/]|\\\\|\\/)*)/?')
-IF_NEXT_ESCAPE_RX = re.compile(r'\\([\\/])')
+IF_NEXT_META_RX = re.compile(r"((?:[^\\/]|\\\\|\\/)*)/?")
+IF_NEXT_ESCAPE_RX = re.compile(r"\\([\\/])")
 
 
 def meta_if_next_matches(ctx, meta):
     pattern, result1, result2 = [
-        IF_NEXT_ESCAPE_RX.sub(r'\1', s)
+        IF_NEXT_ESCAPE_RX.sub(r"\1", s)
         for s in filter(None, IF_NEXT_META_RX.split(meta, 2))
     ]
     action_list = []

plover/meta/currency.py

@@ -3,16 +3,16 @@ def meta_retro_currency(ctx, dict_format):
     last_words = ctx.last_words(count=1)
     if not last_words:
         return action
-    currency = last_words[0].replace(',', '')
+    currency = last_words[0].replace(",", "")
     for cast, fmt in (
-        (int,   '{:,}'   ),
-        (float, '{:,.2f}'),
+        (int, "{:,}"),
+        (float, "{:,.2f}"),
     ):
         try:
             cast_input = cast(currency)
         except ValueError:
             continue
-        currency_format = dict_format.replace('c', fmt)
+        currency_format = dict_format.replace("c", fmt)
         action.prev_attach = True
         action.prev_replace = last_words[0]
         action.text = currency_format.format(cast_input)

plover/meta/mode.py

@@ -15,34 +15,34 @@ def meta_mode(ctx, cmdline):
         set_space:xy: Set space to xy
         reset: Reset to normal case, space resets to ' '
     """
-    args = cmdline.split(':', 1)
+    args = cmdline.split(":", 1)
     mode = args.pop(0).lower()
     action = ctx.copy_last_action()
-    if mode == 'set_space':
-        action.space_char = args[0] if args else ''
+    if mode == "set_space":
+        action.space_char = args[0] if args else ""
         return action
     # No argument allowed for other mode directives.
     if args:
-        raise ValueError('%r is not a valid mode' % cmdline)
-    if mode == 'caps':
+        raise ValueError("%r is not a valid mode" % cmdline)
+    if mode == "caps":
         action.case = Case.UPPER
-    elif mode == 'title':
+    elif mode == "title":
         action.case = Case.TITLE
-    elif mode == 'lower':
+    elif mode == "lower":
         action.case = Case.LOWER
-    elif mode == 'snake':
-        action.space_char = '_'
-    elif mode == 'camel':
+    elif mode == "snake":
+        action.space_char = "_"
+    elif mode == "camel":
         action.case = Case.TITLE
-        action.space_char = ''
+        action.space_char = ""
         action.next_case = Case.LOWER_FIRST_CHAR
-    elif mode == 'reset':
+    elif mode == "reset":
         action.space_char = SPACE
         action.case = None
-    elif mode == 'reset_space':
+    elif mode == "reset_space":
         action.space_char = SPACE
-    elif mode == 'reset_case':
+    elif mode == "reset_case":
         action.case = None
     else:
-        raise ValueError('%r is not a valid mode' % cmdline)
+        raise ValueError("%r is not a valid mode" % cmdline)
     return action

plover/meta/punctuation.py

@@ -7,6 +7,7 @@ def meta_comma(ctx, text):
     action.prev_attach = True
     return action
 
+
 def meta_stop(ctx, text):
     action = ctx.new_action()
     action.prev_attach = True

plover/misc.py

@@ -10,30 +10,32 @@ from plover.resource import ASSET_SCHEME
 def popcount_8(v):
     """Population count for an 8 bit integer"""
     assert 0 <= v <= 255
-    v -= ((v >> 1) & 0x55555555)
+    v -= (v >> 1) & 0x55555555
     v = (v & 0x33333333) + ((v >> 2) & 0x33333333)
     return ((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24
 
+
 def expand_path(path):
-    ''' Expand path.
+    """Expand path.
 
-        - if starting with "~/", it is substituted with the user home directory
-        - if relative, it is resolved relative to CONFIG_DIR
-    '''
+    - if starting with "~/", it is substituted with the user home directory
+    - if relative, it is resolved relative to CONFIG_DIR
+    """
     if path.startswith(ASSET_SCHEME):
         return path
     path = os.path.expanduser(path)
     path = normalize_path(os.path.join(CONFIG_DIR, path))
     return path
 
+
 def shorten_path(path):
-    ''' Shorten path.
+    """Shorten path.
 
-        - if the path is below CONFIG_DIR, a relative path to it is returned
-        - if path is below the user home directory, "~/" is substituted to it
+    - if the path is below CONFIG_DIR, a relative path to it is returned
+    - if path is below the user home directory, "~/" is substituted to it
 
-        Note: relative path are automatically assumed to be relative to CONFIG_DIR.
-    '''
+    Note: relative path are automatically assumed to be relative to CONFIG_DIR.
+    """
     if path.startswith(ASSET_SCHEME):
         return path
     path = normalize_path(os.path.join(CONFIG_DIR, path))
@@ -41,31 +43,33 @@ def shorten_path(path):
     if not config_dir.endswith(os.sep):
         config_dir += os.sep
     if path.startswith(config_dir):
-        return path[len(config_dir):]
-    home_dir = normalize_path(os.path.expanduser('~'))
+        return path[len(config_dir) :]
+    home_dir = normalize_path(os.path.expanduser("~"))
     if not home_dir.endswith(os.sep):
         home_dir += os.sep
     if path.startswith(home_dir):
-        return os.path.join('~', path[len(home_dir):])
+        return os.path.join("~", path[len(home_dir) :])
     return path
 
+
 def normalize_path(path):
-    ''' Normalize path: return canonical path, normalizing case on Windows.
-    '''
+    """Normalize path: return canonical path, normalizing case on Windows."""
     if path.startswith(ASSET_SCHEME):
         return path
     return os.path.normcase(os.path.realpath(path))
 
+
 def boolean(value):
     if isinstance(value, str):
         v = value.lower()
-        if v in ('1', 'yes', 'true', 'on'):
+        if v in ("1", "yes", "true", "on"):
             return True
-        if v in ('0', 'no', 'false', 'off'):
+        if v in ("0", "no", "false", "off"):
             return False
         raise ValueError(value)
     return bool(value)
 
+
 def to_surrogate_pair(char):
     pairs = []
     for code in char:

plover/orthography.py

@@ -10,26 +10,27 @@ def make_candidates_from_rules(word, suffix, check=lambda x: True):
     candidates = []
     for r in system.ORTHOGRAPHY_RULES:
         m = r[0].match(word + " ^ " + suffix)
-        if m:   
+        if m:
             expanded = m.expand(r[1])
             if check(expanded):
                 candidates.append(expanded)
     return candidates
 
+
 def _add_suffix(word, suffix):
     in_dict_f = lambda x: x in system.ORTHOGRAPHY_WORDS
 
     candidates = []
-    
+
     alias = system.ORTHOGRAPHY_RULES_ALIASES.get(suffix, None)
     if alias is not None:
         candidates.extend(make_candidates_from_rules(word, alias, in_dict_f))
-    
+
     # Try a simple join if it is in the dictionary.
     simple = word + suffix
     if in_dict_f(simple):
         candidates.append(simple)
-    
+
     # Try rules with dict lookup.
     candidates.extend(make_candidates_from_rules(word, suffix, in_dict_f))
 
@@ -38,24 +39,25 @@ def _add_suffix(word, suffix):
     if candidates:
         candidates.sort(key=lambda x: system.ORTHOGRAPHY_WORDS[x])
         return candidates[0]
-    
+
     # Try rules without dict lookup.
     candidates = make_candidates_from_rules(word, suffix)
     if candidates:
         return candidates[0]
-    
+
     # If all else fails then just do a simple join.
     return simple
 
+
 def add_suffix(word, suffix):
     """Add a suffix to a word by applying the rules above
-    
+
     Arguments:
-        
+
     word -- A word
     suffix -- The suffix to add
-    
+
     """
-    suffix, sep, rest = suffix.partition(' ')
+    suffix, sep, rest = suffix.partition(" ")
     expanded = _add_suffix(word, suffix)
     return expanded + sep + rest