Merge pull request #3 from erickcan/v2.0

V2.0

Author: erickcan

README.md

@@ -2,132 +2,130 @@
 A command-line sound change applier written in Python.
 
 ## Setup
-To begin using this sound change applier, you just need to download the executable (`.exe`) file in the [releases](https://github.com/erickcan/sound-change-applier/releases) tab.
-
-You can also clone this repo and use the `sca.bat` file:
+To begin using this sound change applier, you just need to download the executable (`.exe`) file in the [Releases page](https://github.com/erickcan/sound-change-applier/releases) and use it through the command-line prompt:
+```
+$ sca sca-options
 ```
+You can also clone this repo and use the `sca.bat` or `sca.sh` file:
+```sh
 $ git clone https://github.com/erickcan/sound-change-applier.git
+$ sca sca-options       # if Windows
+$ ./sca.sh sca-options  # if Linux
 ```
 
 ## Command line
-There are two ways of applying sound changes using the command line: `--file-based-sound-change` and `--named-sound-change`.
-
-- `--file-based-sound-change` (or `-f`) applies a set of rules to a set of words, each defined in their own files, and creates a text file with the changed words.
-- `--named-sound-change` (or `-n`) applies a named sound change to words passed on the command line, and then prints the words after the change.
-
-### Usage
-For `--file-based-sound-change`:<sup name="a1">[[1]](#f1)</sup>
 ```
-$ sca sound-classes-file -f rules-file words-file [--csv-output]
+sca (-f rules-file words-file | -n named-rules-json named-rule words)
+    [--csv-output] [-s sound-classes-json | --no-sound-classes]
 ```
-where:
-- `sca` is the sound change applier;
-- `sound-classes-file` is a JSON file where sound classes are defined;
-- `rules-file` is a text file where the rules to apply are;
-- `words-file` is a text file where the words to which the rules will be applied;
-- `--csv-output` is an optional argument that, if selected, creates a CSV file with the before and after of the words instead of a text file.
-
----
-
-For `--named-sound-change`:<sup name="a2">[[2]](#f2)</sup>
-```
-$ sca sound-classes-file -n named-rules-file named-rule words [--csv-output]
-```
-where:
-- `sca` is the sound change applier;
-- `sound-classes-file` is a JSON file where sound classes are defined;
-- `named-rules-file` is a JSON file where sound changes and their names are defined;
-- `named-rule` is the name of the rule to apply (should be defined in the `named-rules-file` file);
-- `words` is a string with the words to change (if more than one word, should be inside quotes and separed by spaces);
-- `--csv-output` is an optional argument that, if selected, creates a CSV file with the before and after of the words instead of just printing the words.
+### Usage
+- `--file-based-sound-change` | `-f` to apply a set of rules to a set of words, each defined in a separate file, creating a text file with the changed words;
+  - `rules-file`: text file with the rules
+  - `words-file`: text file with the words
+- `--named-sound-change` | `-n` to apply a named sound change to words passed on the command line, and then prints the words after the change;
+  - `named-rules-json`: JSON file where sound classes are defined
+  - `named-rule`: name of the rule to apply (defined in `named-rules-json`)
+  - `words`: words to apply the sound change
+- `--csv-output` to create a before and after of the changed words;
+- `--sound-classes-file` | `-s` to specify the JSON file where the sound classes are defined (see also [Default sound classes](#default-sound-classes));
+- `--no-sound-classes` to not make use of sound classes.
 
 ### Examples
 Suppose the following files:
-
-> sound_classes.json
-```json
-{
-  "V": "aeiou",
-  "C": "bcdfghjklmnpqrstvwxyz",
-  "P": "pbtdkg",
-  "F": "fvsz",
-  "N": "mn",
-  "S": "sz"
-}
-```
 > named_rules.json
 ```json
 {
-  "terminal-devoicing": "[bdgz] -> [ptks] / _#",
-  "h-dropping": "h -> _ / _",
-  "z-rhotacization": "z -> r / V_V",
-  "/æ/-raising": "æ -> eə / _N"
+  "terminal-devoicing": "[bdgz] > [ptks] /  _#",
+  "h-dropping":          "h    -> _      /  _",
+  "z-rhotacization":     "z    -> r      / V_V",
+  "l-vocalization":      "l    => w      /  _!V",
+  "/æ/-raising":         "æ    => eə     /  _N",
+  "th-fronting":         "[θð] -> [fv]   /  _"
 }
 ```
-
 > rules.txt
 ```
-d -> ð / V_V
-[ae] -> [ãẽ] / _N
-[aou] -> [äöü] / _e
-l -> w / _#
-s -> z / [bdg]_
+d    => ð   /    V_V
+[gk] -> _   /    #_n
+a    -> ə   /     _#
+l    -> w   /     _!V
+[aou]e>[æøy]/     _
+sw    > s   /     _[ou]
+[ao]N > [ãõ]/     _
+s    => z   /[bdg]_
+e    -> _   /   CC_#
 ```
-
 > words.txt
 ```
-ada
+aeon
 beds
 clue
 daemon
+knowledge
+laterals
+media
 sand
-vowel
+swords
 ```
 
-If this were passed to the command line:
+If this were passed to the command line,
 ```
-$ sca sound_classes.json -f rules.txt words.txt --csv-output
+$ sca -f rules.txt words.txt --csv-output
 ```
-The following file would be created:
-
+the following file would be created:
 > sound-change-YYYY-MM-DD-HH-MM-SS.csv
 ```csv
-ada,aða
+aeon,æõ
 beds,bedz
-clue,clüe
-daemon,daẽmon
-sand,sãnd
-vowel,vowew
+clue,cly
+daemon,dæmõ
+knowledge,nowledg
+laterals,lateraws
+media,meðiə
+sand,sãd
+swords,sordz
 ```
 
-And if the following were passed into the command line:
+And if the following were passed into the command line,
 ```
-$ sca sound_classes.json -n named_rules.json h-dropping "here he had hallucinated"
+$ sca -n named_rules.json h-dropping "here he had hallucinated"
 ```
-It would print:
+it would print:
 ```
-ere
-e
-ad
-allucinated
+ere e ad allucinated
 ```
 
 ## Rule notation
-The rules should be written in the form `x -> y / a_b`, where `x` becomes `y` when `x` is between `a` and `b`.
+The rules can be written in any of the following forms:
+```
+x  > y / a_b
+x -> y / a_b
+x => y / a_b
+```
+where `x` becomes `y` when `x` is between `a` and `b`. (Spaces between `>`, `->`, `=>` and `/` are insignificant.)
 
 ### Symbols
-| symbol  | meaning       | example                                   |
-| ------- | ------------- | ----------------------------------------- |
-| `#`     | word boundary | `_#` : end of word                        |
-| `A..Z`  | sound class   | `Gt` : class `G` followed by `t`          |
-| `[xyz]` | ad-hoc class  | `u[rl]` : `u` followed by `r` or `l`      |
-| `_`     | everywhere    | `ð -> d / _` : `ð` becomes `d` everywhere |
-| `_`     | sound-eraser  | `h -> _` : deletes `h`                    |
-
-
-## Dependencies
-This project has no dependencies. It only uses modules of the Python Standard Library.
-
-## Footnotes
-1. <b name="f1"></b> `$ sca -f rules-file words-file [--csv-output] sound-classes-file` and `$ sca [--csv-output] -f rules-file words-file sound-classes-file` are also valid. [↩](#a1)
-2. <b name="f2"></b> `$ sca -n named-rules-file named-rule words [--csv-output] sound-classes-file` and `$ sca [--csv-output] -n named-rules-file named-rule words` are also valid. [↩](#a2)
+| symbol  | meaning          | example                                     |
+| ------- | ---------------- | ------------------------------------------- |
+| `#`     | word boundary    | `_#`: end of word, `#_`: start of word      |
+| `A..Z`  | sound class      | `Gt`: class `G` followed by `t`             |
+| `[xyz]` | ad-hoc class     | `u[rl]`: `u` followed by `r` or `l`         |
+| `> _`   | sound-eraser     | `h -> _`: deletes `h`                       |
+| `_`     | everywhere, when | `_x`: when followed by `x`, `_`: everywhere |
+| `!_`    | not proceeded by | `u!_`: when not proceeded by `u`            |
+| `_!`    | not followed by  | `_!n`: when not followed by `n`             |
+
+## Appendix
+
+### Default sound classes
+If neither `--sound-classes-file` nor `--no-sound-classes` are used, the following sound classes are used:
+```json
+{
+  "V": "aeiou",
+  "C": "bcdfghjklmnpqrstvwxyz",
+  "P": "pbtdkg",
+  "F": "fvsz",
+  "N": "mn",
+  "S": "sz"
+}
+```

main.py

@@ -1,69 +1,41 @@
-import os
 from sys import argv
-from csv import writer
 
-from src import *
+from src import io
+from src import sound_changer as sc
 
 
-def before_after_csv(before: list[str], after: list[str], filename: str):
-    """Create a CSV file with two columns in the cwd and print that the file was created."""
-    filename = f"{os.path.join(os.getcwd(), filename)}.csv"
-    with open(filename, newline="", encoding="utf-8", mode="w") as f:
-        for w in zip(before, after):
-            writer(f).writerow(u.strip() for u in w)
+def main(args: list[str]):
+    sca_args = io.ScaArgs(args)
 
-    created_file(filename)
+    if sca_args.ndsc is not None:
+        named_rules = io.json_to_dict(sca_args.ndsc[0])
+        chosen_rule = named_rules[sca_args.ndsc[1]]
+        words = sca_args.ndsc[2].split()
 
+        phon_rule = sc.PhonRule(chosen_rule, sca_args.sound_classes)
+        changed_words = list(map(phon_rule.apply, words))
 
-def try_changes_words(rules: list[str], words: list[str], sound_classes: HashableDict) -> list[str]:
-    """Try to change words, raise NotPhonRule if any rule is not valid."""
-    try:
-        changed_words = changes_words(rules, words, sound_classes)
-    except NotPhonRule as e:
-        exit(e)
-
-    return changed_words
-
-
-def main(args):
-    args_dict = parse_cmd_args(args)
-
-    sound_classes = try_open_json(args_dict['sound-classes-file'], "sound-classes-file")
-
-    if (nsc := args_dict['named_sound_change']) is not None:
-
-        named_rules = try_open_json(nsc[0], "named-rules-file")
-        chosen_rule = named_rules[nsc[1]]
-        words = nsc[2].split()
+        if not sca_args.csv_output:
+            print(" ".join(changed_words))
 
-        changed_words = try_changes_words([chosen_rule], words, sound_classes)
+    else:
+        rules = io.read_file(sca_args.fbsc[0])
+        words = io.read_file(sca_args.fbsc[1])
 
-        if args_dict['csv_output'] == True:
-            filename = make_filename()
-            before_after_csv(words, changed_words, filename)
+        phon_rules = sc.PhonRules(rules, sca_args.sound_classes)
+        changed_words = list(map(phon_rules.apply, words))
 
-        else:
-            for w in changed_words:
-                print(w)
+        if not sca_args.csv_output:
+            filename = f"sound-change-{io.today_str()}"
+            io.write_txt(filename, changed_words)
 
-    if (fbsc := args_dict['file_based_sound_change']) is not None:
+    if sca_args.csv_output:
+        filename = f"sound-change-{io.today_str()}"
+        io.before_after_csv(words, changed_words, filename)
 
-        rules = try_open_txt(fbsc[0], "rules-file")
-        words = try_open_txt(fbsc[1], "words-file")
 
-        changed_words = try_changes_words(rules, words, sound_classes)
-
-        filename = make_filename()
-
-        if args_dict['csv_output'] == True:
-            before_after_csv(words, changed_words, filename)
-
-        else:
-            filename = f"{os.path.join(os.getcwd(), filename)}.txt"
-            with open(filename, encoding="utf-8", mode="w") as f:
-                f.writelines(word + '\n' for word in changed_words)
-            created_file(filename)
-
-
-if __name__ == '__main__':
-    main(argv[1:])
+if __name__ == "__main__":
+    try:
+        main(argv[1:])
+    except Exception as e:
+        exit(f"{type(e).__name__}: {e}")

sca.bat

@@ -1,3 +1 @@
-@echo off
-python main.py %*
-pause
+@python main.py %*

sca.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+python3 main.py "$@"

src/__init__.py

@@ -1,5 +0,0 @@
-from src.sound_changer import changes_words
-from src.cmd_args import parse_cmd_args
-from src.small_functions import created_file, make_filename
-from src.errs import try_open_json, try_open_txt, NotPhonRule
-from src.hash_dict import HashableDict