We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
Latin Syllabifier Fails on Macrons
The Latin syllabifier seems to fail on words with macrons. For example, `audītū` becomes `['aud', 'ītū']` rather than `['au', 'dī', tū']`.  

It looks like we can fix this by just adding the macronized vowels to the  [vowels property](https://github.com/cltk/cltk/blob/master/cltk/stem/latin/syllabifier.py#L27).

@kylepjohnson I can submit a PR for this if it sounds reasonable.

--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `cltk/stem/latin/syllabifier.py`
Content:
```
1 """Split Latin words into a list of syllables, based on a set of Latin
2 language syllable specifications and the original work of Father Matthew
3 Spencer in C# and Javascript. Original documentation from Fr. Spencer
4 is preserved where applicable.
5 """
6 
7 __author__ = ['Luke Hollis <lukehollis@gmail.com>']
8 __license__ = 'MIT License. See LICENSE.'
9 
10 import re
11 
12 
13 # nota bene: ui is only a diphthong in the exceptional 
14 # cases below (according to Wheelock's Latin)
15 LATIN = {'diphthongs': ["ae", "au", "ei", "eu", "oe"],
16 
17          'exceptions': {
18              'huius': ["hui", "us"],
19              'cuius': ["cui", "us"],
20              'huic': ["huic"],
21              'cui': ["cui"],
22              'hui': ["hui"]
23          },
24 
25          # y is treated as a vowel; not native to Latin but useful 
26          # for words borrowed from Greek
27          'vowels': [
28              "a", "e", "i", "o", "u",
29              "á", "é", "í", "ó", "ú",
30              "æ", "œ",
31              "ǽ",  # no accented œ in unicode?
32              "y"
33              ],
34 
35          'mute_consonants_and_f': ["b", "c", "d", "g", "p", "t", "f"],
36 
37          'liquid_consonants': ["l", "r"],
38 
39          'prefixes': [
40              "a", "ab", "abs",
41              "ad", "ac",
42              "amb", "ambi",
43              "ante",
44              "circum",
45              "co", "con", "com",
46              "contra", "counter",
47              "de",
48              "dis", "di", "dif",
49              "e", "ex", "ef",
50              "extra", "extro",
51              "in", "en",
52              "infra",
53              "inter",
54              "intro",
55              "juxta",
56              "ne",
57              "non",
58              "ob",
59              "per",
60              "post",
61              "prae", "pre",
62              "preter",
63              "pro",
64              "quasi",
65              "re", "red",
66              "retro",
67              "se", "sed",
68              "sin", "sine",
69              "sub",
70              "subter",
71              "super", "sur",
72              "supra",
73              "trans", "tra", "tran",
74              "ultra", "outr"
75              ],
76 
77          'single_syllable_prefixes': [
78              "in",
79              "ex",
80              "ob"
81          ]}
82 
83 
84 class Syllabifier(object):
85     """Split Latin words into syllables"""
86 
87     def __init__(self, language=LATIN):
88         """Initializer for syllabifier, import language syllable data"""
89 
90         self.language = language
91 
92         return
93 
94     def _is_consonant(self, char):
95         """Checks if char is in the list of vowels in the language"""
96         return not char in self.language['vowels']
97 
98     def _is_vowel(self, char):
99         """Checks if char is in the list of vowels in the language"""
100         return char in self.language['vowels']
101 
102     def _is_diphthong(self, char_1, char_2):
103         """Checks if two sequential characters compose a diphthong"""
104         return char_1 + char_2 in self.language['diphthongs']
105 
106     def _is_mute_consonant_or_f(self, char):
107         """Checks if char is in the mute_consonants_and_f list"""
108         return char in self.language['mute_consonants_and_f']
109 
110     def _is_liquid_consonant(self, char):
111         """Checks if char is in the mute_consonants_and_f list"""
112         return char in self.language['liquid_consonants']
113 
114     def syllabify(self, word):
115         """Splits input Latin word into a list of syllables, based on 
116         the language syllables loaded for the Syllabifier instance"""
117 
118         prefixes = self.language['single_syllable_prefixes']
119         prefixes.sort(key=len, reverse=True)
120 
121         # Check if word is in exception dictionary
122         if word in self.language['exceptions']:
123             syllables = self.language['exceptions'][word]
124 
125         # Else, breakdown syllables for word
126         else:
127             syllables = []
128 
129             # Remove prefixes
130             for prefix in prefixes:
131                 if word.startswith(prefix):
132                     syllables.append(prefix)
133                     word = re.sub('^%s' % prefix, '', word)
134                     break
135 
136             # Initialize syllable to build by iterating through over characters
137             syllable = ''
138 
139             # Get word length for determining character position in word
140             word_len = len(word)
141 
142             # Iterate over characters to build syllables
143             for i, char in enumerate(word):
144 
145                 # Build syllable
146                 syllable = syllable + char
147                 syllable_complete = False
148 
149                 # Checks to process syllable logic
150                 char_is_vowel = self._is_vowel(char)
151                 has_next_char = i < word_len - 1
152                 has_prev_char = i > 0
153 
154                 # If it's the end of the word, the syllable is complete
155                 if not has_next_char:
156                     syllable_complete = True
157 
158                 else:
159                     next_char = word[i + 1]
160                     if has_prev_char:
161                         prev_char = word[i - 1]
162 
163                     # 'i' is a special case for a vowel. when i is at the 
164                     # beginning of the word (Iesu) or i is between 
165                     # vowels (alleluia), then the i is treated as a 
166                     # consonant (y) Note: what about compounds like 'adiungere'
167                     if char == 'i' and has_next_char and self._is_vowel(next_char): 
168                         if i == 0:
169                             char_is_vowel = False
170                         elif self._is_vowel(prev_char):
171                             char_is_vowel = False
172 
173                     # Determine if the syllable is complete
174                     if char_is_vowel:
175 
176                         if (
177                                     (  # If the next character's a vowel
178                                        self._is_vowel(
179                                                next_char)  # And it doesn't compose a dipthong with the current character
180                                        and not self._is_diphthong(char,
181                                                                   next_char)  # And the current character isn't preceded by a q, unless followed by a u
182                                        and not (
183                                                            has_prev_char
184                                                        and prev_char == "q"
185                                                    and char == "u"
186                                                and next_char != "u"
187                                        )
188 
189                                        )
190                                 or (
191                                         # If the next character's a consonant but not a double consonant, unless it's a mute consonant followed by a liquid consonant
192                                         i < word_len - 2
193                                         and (
194                                                         (
195                                                                     (
196                                                                                         has_prev_char
197                                                                                     and prev_char != "q"
198                                                                                 and char == "u"
199                                                                             and self._is_vowel(word[i + 2])
200                                                                     )
201                                                                 or (
202                                                                                 not has_prev_char
203                                                                             and char == "u"
204                                                                         and self._is_vowel(word[i + 2])
205                                                                 )
206                                                         )
207                                                     or (
208                                                                         char != "u"
209                                                                 and self._is_vowel(word[i + 2])
210                                                             and not self._is_diphthong(char, next_char)
211                                                     )
212                                                 or (
213                                                             self._is_mute_consonant_or_f(next_char)
214                                                         and self._is_liquid_consonant(word[i + 2])
215                                                 )
216                                         )
217 
218                                 )
219                         ):
220                             syllable_complete = True
221 
222                     # Otherwise, it's a consonant
223                     else:
224 
225                         if (  # If the next character's also a consonant (but it's not the last in the word)
226                               (
227 
228                                           not self._is_vowel(next_char)
229                                       and i < word_len - 2
230                               )  # If the char's not a mute consonant followed by a liquid consonant
231                               and not (
232                                           self._is_mute_consonant_or_f(char)
233                                       and self._is_liquid_consonant(next_char)
234                               )  # If the char's not a c, p, or t followed by an h
235                               and not (
236                                           (
237                                                               has_prev_char
238                                                           and not self._is_vowel(prev_char)
239                                                       and char in ['c', 'p', 't'] and next_char == 'h'
240                                           )
241                                       or (
242                                                       not has_prev_char
243                                                   and char in ['c', 'p', 't'] and next_char == 'h'
244                                       )
245                               )  # And it's not the only letter in the syllable
246                               and not len(syllable) == 1
247 
248                               ):
249                             syllable_complete = True
250 
251                 # If it's a complete syllable, append it to syllables list and reset syllable
252                 if syllable_complete:
253                     syllables.append(syllable)
254                     syllable = ''
255 
256         return syllables
257 
258
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/cltk/stem/latin/syllabifier.py b/cltk/stem/latin/syllabifier.py
--- a/cltk/stem/latin/syllabifier.py
+++ b/cltk/stem/latin/syllabifier.py
@@ -27,6 +27,7 @@
          'vowels': [
              "a", "e", "i", "o", "u",
              "á", "é", "í", "ó", "ú",
+             "ā", "ē", "ī", "ō", "ū",
              "æ", "œ",
              "ǽ",  # no accented œ in unicode?
              "y"

{"golden_diff": "diff --git a/cltk/stem/latin/syllabifier.py b/cltk/stem/latin/syllabifier.py\n--- a/cltk/stem/latin/syllabifier.py\n+++ b/cltk/stem/latin/syllabifier.py\n@@ -27,6 +27,7 @@\n          'vowels': [\n              \"a\", \"e\", \"i\", \"o\", \"u\",\n              \"\u00e1\", \"\u00e9\", \"\u00ed\", \"\u00f3\", \"\u00fa\",\n+             \"\u0101\", \"\u0113\", \"\u012b\", \"\u014d\", \"\u016b\",\n              \"\u00e6\", \"\u0153\",\n              \"\u01fd\",  # no accented \u0153 in unicode?\n              \"y\"\n", "issue": "Latin Syllabifier Fails on Macrons\nThe Latin syllabifier seems to fail on words with macrons. For example, `aud\u012bt\u016b` becomes `['aud', '\u012bt\u016b']` rather than `['au', 'd\u012b', t\u016b']`.  \r\n\r\nIt looks like we can fix this by just adding the macronized vowels to the  [vowels property](https://github.com/cltk/cltk/blob/master/cltk/stem/latin/syllabifier.py#L27).\r\n\r\n@kylepjohnson I can submit a PR for this if it sounds reasonable.\n", "before_files": [{"content": "\"\"\"Split Latin words into a list of syllables, based on a set of Latin\nlanguage syllable specifications and the original work of Father Matthew\nSpencer in C# and Javascript. Original documentation from Fr. Spencer\nis preserved where applicable.\n\"\"\"\n\n__author__ = ['Luke Hollis <lukehollis@gmail.com>']\n__license__ = 'MIT License. See LICENSE.'\n\nimport re\n\n\n# nota bene: ui is only a diphthong in the exceptional \n# cases below (according to Wheelock's Latin)\nLATIN = {'diphthongs': [\"ae\", \"au\", \"ei\", \"eu\", \"oe\"],\n\n         'exceptions': {\n             'huius': [\"hui\", \"us\"],\n             'cuius': [\"cui\", \"us\"],\n             'huic': [\"huic\"],\n             'cui': [\"cui\"],\n             'hui': [\"hui\"]\n         },\n\n         # y is treated as a vowel; not native to Latin but useful \n         # for words borrowed from Greek\n         'vowels': [\n             \"a\", \"e\", \"i\", \"o\", \"u\",\n             \"\u00e1\", \"\u00e9\", \"\u00ed\", \"\u00f3\", \"\u00fa\",\n             \"\u00e6\", \"\u0153\",\n             \"\u01fd\",  # no accented \u0153 in unicode?\n             \"y\"\n             ],\n\n         'mute_consonants_and_f': [\"b\", \"c\", \"d\", \"g\", \"p\", \"t\", \"f\"],\n\n         'liquid_consonants': [\"l\", \"r\"],\n\n         'prefixes': [\n             \"a\", \"ab\", \"abs\",\n             \"ad\", \"ac\",\n             \"amb\", \"ambi\",\n             \"ante\",\n             \"circum\",\n             \"co\", \"con\", \"com\",\n             \"contra\", \"counter\",\n             \"de\",\n             \"dis\", \"di\", \"dif\",\n             \"e\", \"ex\", \"ef\",\n             \"extra\", \"extro\",\n             \"in\", \"en\",\n             \"infra\",\n             \"inter\",\n             \"intro\",\n             \"juxta\",\n             \"ne\",\n             \"non\",\n             \"ob\",\n             \"per\",\n             \"post\",\n             \"prae\", \"pre\",\n             \"preter\",\n             \"pro\",\n             \"quasi\",\n             \"re\", \"red\",\n             \"retro\",\n             \"se\", \"sed\",\n             \"sin\", \"sine\",\n             \"sub\",\n             \"subter\",\n             \"super\", \"sur\",\n             \"supra\",\n             \"trans\", \"tra\", \"tran\",\n             \"ultra\", \"outr\"\n             ],\n\n         'single_syllable_prefixes': [\n             \"in\",\n             \"ex\",\n             \"ob\"\n         ]}\n\n\nclass Syllabifier(object):\n    \"\"\"Split Latin words into syllables\"\"\"\n\n    def __init__(self, language=LATIN):\n        \"\"\"Initializer for syllabifier, import language syllable data\"\"\"\n\n        self.language = language\n\n        return\n\n    def _is_consonant(self, char):\n        \"\"\"Checks if char is in the list of vowels in the language\"\"\"\n        return not char in self.language['vowels']\n\n    def _is_vowel(self, char):\n        \"\"\"Checks if char is in the list of vowels in the language\"\"\"\n        return char in self.language['vowels']\n\n    def _is_diphthong(self, char_1, char_2):\n        \"\"\"Checks if two sequential characters compose a diphthong\"\"\"\n        return char_1 + char_2 in self.language['diphthongs']\n\n    def _is_mute_consonant_or_f(self, char):\n        \"\"\"Checks if char is in the mute_consonants_and_f list\"\"\"\n        return char in self.language['mute_consonants_and_f']\n\n    def _is_liquid_consonant(self, char):\n        \"\"\"Checks if char is in the mute_consonants_and_f list\"\"\"\n        return char in self.language['liquid_consonants']\n\n    def syllabify(self, word):\n        \"\"\"Splits input Latin word into a list of syllables, based on \n        the language syllables loaded for the Syllabifier instance\"\"\"\n\n        prefixes = self.language['single_syllable_prefixes']\n        prefixes.sort(key=len, reverse=True)\n\n        # Check if word is in exception dictionary\n        if word in self.language['exceptions']:\n            syllables = self.language['exceptions'][word]\n\n        # Else, breakdown syllables for word\n        else:\n            syllables = []\n\n            # Remove prefixes\n            for prefix in prefixes:\n                if word.startswith(prefix):\n                    syllables.append(prefix)\n                    word = re.sub('^%s' % prefix, '', word)\n                    break\n\n            # Initialize syllable to build by iterating through over characters\n            syllable = ''\n\n            # Get word length for determining character position in word\n            word_len = len(word)\n\n            # Iterate over characters to build syllables\n            for i, char in enumerate(word):\n\n                # Build syllable\n                syllable = syllable + char\n                syllable_complete = False\n\n                # Checks to process syllable logic\n                char_is_vowel = self._is_vowel(char)\n                has_next_char = i < word_len - 1\n                has_prev_char = i > 0\n\n                # If it's the end of the word, the syllable is complete\n                if not has_next_char:\n                    syllable_complete = True\n\n                else:\n                    next_char = word[i + 1]\n                    if has_prev_char:\n                        prev_char = word[i - 1]\n\n                    # 'i' is a special case for a vowel. when i is at the \n                    # beginning of the word (Iesu) or i is between \n                    # vowels (alleluia), then the i is treated as a \n                    # consonant (y) Note: what about compounds like 'adiungere'\n                    if char == 'i' and has_next_char and self._is_vowel(next_char): \n                        if i == 0:\n                            char_is_vowel = False\n                        elif self._is_vowel(prev_char):\n                            char_is_vowel = False\n\n                    # Determine if the syllable is complete\n                    if char_is_vowel:\n\n                        if (\n                                    (  # If the next character's a vowel\n                                       self._is_vowel(\n                                               next_char)  # And it doesn't compose a dipthong with the current character\n                                       and not self._is_diphthong(char,\n                                                                  next_char)  # And the current character isn't preceded by a q, unless followed by a u\n                                       and not (\n                                                           has_prev_char\n                                                       and prev_char == \"q\"\n                                                   and char == \"u\"\n                                               and next_char != \"u\"\n                                       )\n\n                                       )\n                                or (\n                                        # If the next character's a consonant but not a double consonant, unless it's a mute consonant followed by a liquid consonant\n                                        i < word_len - 2\n                                        and (\n                                                        (\n                                                                    (\n                                                                                        has_prev_char\n                                                                                    and prev_char != \"q\"\n                                                                                and char == \"u\"\n                                                                            and self._is_vowel(word[i + 2])\n                                                                    )\n                                                                or (\n                                                                                not has_prev_char\n                                                                            and char == \"u\"\n                                                                        and self._is_vowel(word[i + 2])\n                                                                )\n                                                        )\n                                                    or (\n                                                                        char != \"u\"\n                                                                and self._is_vowel(word[i + 2])\n                                                            and not self._is_diphthong(char, next_char)\n                                                    )\n                                                or (\n                                                            self._is_mute_consonant_or_f(next_char)\n                                                        and self._is_liquid_consonant(word[i + 2])\n                                                )\n                                        )\n\n                                )\n                        ):\n                            syllable_complete = True\n\n                    # Otherwise, it's a consonant\n                    else:\n\n                        if (  # If the next character's also a consonant (but it's not the last in the word)\n                              (\n\n                                          not self._is_vowel(next_char)\n                                      and i < word_len - 2\n                              )  # If the char's not a mute consonant followed by a liquid consonant\n                              and not (\n                                          self._is_mute_consonant_or_f(char)\n                                      and self._is_liquid_consonant(next_char)\n                              )  # If the char's not a c, p, or t followed by an h\n                              and not (\n                                          (\n                                                              has_prev_char\n                                                          and not self._is_vowel(prev_char)\n                                                      and char in ['c', 'p', 't'] and next_char == 'h'\n                                          )\n                                      or (\n                                                      not has_prev_char\n                                                  and char in ['c', 'p', 't'] and next_char == 'h'\n                                      )\n                              )  # And it's not the only letter in the syllable\n                              and not len(syllable) == 1\n\n                              ):\n                            syllable_complete = True\n\n                # If it's a complete syllable, append it to syllables list and reset syllable\n                if syllable_complete:\n                    syllables.append(syllable)\n                    syllable = ''\n\n        return syllables\n\n", "path": "cltk/stem/latin/syllabifier.py"}], "after_files": [{"content": "\"\"\"Split Latin words into a list of syllables, based on a set of Latin\nlanguage syllable specifications and the original work of Father Matthew\nSpencer in C# and Javascript. Original documentation from Fr. Spencer\nis preserved where applicable.\n\"\"\"\n\n__author__ = ['Luke Hollis <lukehollis@gmail.com>']\n__license__ = 'MIT License. See LICENSE.'\n\nimport re\n\n\n# nota bene: ui is only a diphthong in the exceptional \n# cases below (according to Wheelock's Latin)\nLATIN = {'diphthongs': [\"ae\", \"au\", \"ei\", \"eu\", \"oe\"],\n\n         'exceptions': {\n             'huius': [\"hui\", \"us\"],\n             'cuius': [\"cui\", \"us\"],\n             'huic': [\"huic\"],\n             'cui': [\"cui\"],\n             'hui': [\"hui\"]\n         },\n\n         # y is treated as a vowel; not native to Latin but useful \n         # for words borrowed from Greek\n         'vowels': [\n             \"a\", \"e\", \"i\", \"o\", \"u\",\n             \"\u00e1\", \"\u00e9\", \"\u00ed\", \"\u00f3\", \"\u00fa\",\n             \"\u0101\", \"\u0113\", \"\u012b\", \"\u014d\", \"\u016b\",\n             \"\u00e6\", \"\u0153\",\n             \"\u01fd\",  # no accented \u0153 in unicode?\n             \"y\"\n             ],\n\n         'mute_consonants_and_f': [\"b\", \"c\", \"d\", \"g\", \"p\", \"t\", \"f\"],\n\n         'liquid_consonants': [\"l\", \"r\"],\n\n         'prefixes': [\n             \"a\", \"ab\", \"abs\",\n             \"ad\", \"ac\",\n             \"amb\", \"ambi\",\n             \"ante\",\n             \"circum\",\n             \"co\", \"con\", \"com\",\n             \"contra\", \"counter\",\n             \"de\",\n             \"dis\", \"di\", \"dif\",\n             \"e\", \"ex\", \"ef\",\n             \"extra\", \"extro\",\n             \"in\", \"en\",\n             \"infra\",\n             \"inter\",\n             \"intro\",\n             \"juxta\",\n             \"ne\",\n             \"non\",\n             \"ob\",\n             \"per\",\n             \"post\",\n             \"prae\", \"pre\",\n             \"preter\",\n             \"pro\",\n             \"quasi\",\n             \"re\", \"red\",\n             \"retro\",\n             \"se\", \"sed\",\n             \"sin\", \"sine\",\n             \"sub\",\n             \"subter\",\n             \"super\", \"sur\",\n             \"supra\",\n             \"trans\", \"tra\", \"tran\",\n             \"ultra\", \"outr\"\n             ],\n\n         'single_syllable_prefixes': [\n             \"in\",\n             \"ex\",\n             \"ob\"\n         ]}\n\n\nclass Syllabifier(object):\n    \"\"\"Split Latin words into syllables\"\"\"\n\n    def __init__(self, language=LATIN):\n        \"\"\"Initializer for syllabifier, import language syllable data\"\"\"\n\n        self.language = language\n\n        return\n\n    def _is_consonant(self, char):\n        \"\"\"Checks if char is in the list of vowels in the language\"\"\"\n        return not char in self.language['vowels']\n\n    def _is_vowel(self, char):\n        \"\"\"Checks if char is in the list of vowels in the language\"\"\"\n        return char in self.language['vowels']\n\n    def _is_diphthong(self, char_1, char_2):\n        \"\"\"Checks if two sequential characters compose a diphthong\"\"\"\n        return char_1 + char_2 in self.language['diphthongs']\n\n    def _is_mute_consonant_or_f(self, char):\n        \"\"\"Checks if char is in the mute_consonants_and_f list\"\"\"\n        return char in self.language['mute_consonants_and_f']\n\n    def _is_liquid_consonant(self, char):\n        \"\"\"Checks if char is in the mute_consonants_and_f list\"\"\"\n        return char in self.language['liquid_consonants']\n\n    def syllabify(self, word):\n        \"\"\"Splits input Latin word into a list of syllables, based on \n        the language syllables loaded for the Syllabifier instance\"\"\"\n\n        prefixes = self.language['single_syllable_prefixes']\n        prefixes.sort(key=len, reverse=True)\n\n        # Check if word is in exception dictionary\n        if word in self.language['exceptions']:\n            syllables = self.language['exceptions'][word]\n\n        # Else, breakdown syllables for word\n        else:\n            syllables = []\n\n            # Remove prefixes\n            for prefix in prefixes:\n                if word.startswith(prefix):\n                    syllables.append(prefix)\n                    word = re.sub('^%s' % prefix, '', word)\n                    break\n\n            # Initialize syllable to build by iterating through over characters\n            syllable = ''\n\n            # Get word length for determining character position in word\n            word_len = len(word)\n\n            # Iterate over characters to build syllables\n            for i, char in enumerate(word):\n\n                # Build syllable\n                syllable = syllable + char\n                syllable_complete = False\n\n                # Checks to process syllable logic\n                char_is_vowel = self._is_vowel(char)\n                has_next_char = i < word_len - 1\n                has_prev_char = i > 0\n\n                # If it's the end of the word, the syllable is complete\n                if not has_next_char:\n                    syllable_complete = True\n\n                else:\n                    next_char = word[i + 1]\n                    if has_prev_char:\n                        prev_char = word[i - 1]\n\n                    # 'i' is a special case for a vowel. when i is at the \n                    # beginning of the word (Iesu) or i is between \n                    # vowels (alleluia), then the i is treated as a \n                    # consonant (y) Note: what about compounds like 'adiungere'\n                    if char == 'i' and has_next_char and self._is_vowel(next_char): \n                        if i == 0:\n                            char_is_vowel = False\n                        elif self._is_vowel(prev_char):\n                            char_is_vowel = False\n\n                    # Determine if the syllable is complete\n                    if char_is_vowel:\n\n                        if (\n                                    (  # If the next character's a vowel\n                                       self._is_vowel(\n                                               next_char)  # And it doesn't compose a dipthong with the current character\n                                       and not self._is_diphthong(char,\n                                                                  next_char)  # And the current character isn't preceded by a q, unless followed by a u\n                                       and not (\n                                                           has_prev_char\n                                                       and prev_char == \"q\"\n                                                   and char == \"u\"\n                                               and next_char != \"u\"\n                                       )\n\n                                       )\n                                or (\n                                        # If the next character's a consonant but not a double consonant, unless it's a mute consonant followed by a liquid consonant\n                                        i < word_len - 2\n                                        and (\n                                                        (\n                                                                    (\n                                                                                        has_prev_char\n                                                                                    and prev_char != \"q\"\n                                                                                and char == \"u\"\n                                                                            and self._is_vowel(word[i + 2])\n                                                                    )\n                                                                or (\n                                                                                not has_prev_char\n                                                                            and char == \"u\"\n                                                                        and self._is_vowel(word[i + 2])\n                                                                )\n                                                        )\n                                                    or (\n                                                                        char != \"u\"\n                                                                and self._is_vowel(word[i + 2])\n                                                            and not self._is_diphthong(char, next_char)\n                                                    )\n                                                or (\n                                                            self._is_mute_consonant_or_f(next_char)\n                                                        and self._is_liquid_consonant(word[i + 2])\n                                                )\n                                        )\n\n                                )\n                        ):\n                            syllable_complete = True\n\n                    # Otherwise, it's a consonant\n                    else:\n\n                        if (  # If the next character's also a consonant (but it's not the last in the word)\n                              (\n\n                                          not self._is_vowel(next_char)\n                                      and i < word_len - 2\n                              )  # If the char's not a mute consonant followed by a liquid consonant\n                              and not (\n                                          self._is_mute_consonant_or_f(char)\n                                      and self._is_liquid_consonant(next_char)\n                              )  # If the char's not a c, p, or t followed by an h\n                              and not (\n                                          (\n                                                              has_prev_char\n                                                          and not self._is_vowel(prev_char)\n                                                      and char in ['c', 'p', 't'] and next_char == 'h'\n                                          )\n                                      or (\n                                                      not has_prev_char\n                                                  and char in ['c', 'p', 't'] and next_char == 'h'\n                                      )\n                              )  # And it's not the only letter in the syllable\n                              and not len(syllable) == 1\n\n                              ):\n                            syllable_complete = True\n\n                # If it's a complete syllable, append it to syllables list and reset syllable\n                if syllable_complete:\n                    syllables.append(syllable)\n                    syllable = ''\n\n        return syllables\n\n", "path": "cltk/stem/latin/syllabifier.py"}]}