Lexitron 2.0.4__tar.gz → 2.1.2__tar.gz

{Lexitron-2.0.4 → lexitron-2.1.2/Lexitron.egg-info}/PKG-INFO

@@ -1,15 +1,17 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: Lexitron
-Version: 2.0.4
+Version: 2.1.2
 Summary: A command-line regex search engine for the English language
-Home-page: http://github.com/rothos/lexitron
 Author: Rothos
 License: GNU GPL Version 2
+Project-URL: Homepage, http://github.com/rothos/lexitron
 Keywords: english,dictionary,crossword,spelling,words,lexicon,search
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: importlib-metadata; python_version < "3.8"
+Requires-Dist: importlib-resources; python_version < "3.8"
 
 Lexitron
 ==============================================================================
@@ -57,11 +59,12 @@ where `expression` is a regular expression and `[options]` are as follows.
 
  option | function
 --------|-------------------------------------------------
-  `-d`  | Append start and end delimiters `^...$` to search query
+  `-h`  | Print help and exit
+  `-i`  | Print info header along with search results
   `-n`  | Print only the number of matches
-  `-u`  | Search only for lowercase/common/uncapitalized words
-  `-U`  | Search only for uppercase/proper/capitalized words
-  `-v`  | Show version and exit
+  `-u`  | Include uppercase/proper words (like "France") in addition to lowercase/common words
+  `-U`  | Search only for uppercase/proper words
+  `-v`  | Print version and exit
   `-x`  | Print unformatted output, one word per line
 
 Type `$ lx -h` for full help text.
@@ -87,37 +90,30 @@ Examples
 ------------------------------------------------------------------------------
 
 ### Example 1
-A list of English words ending with "icide".
+A list of lowercase English words ending with "icide".
 ```
 $ lx icide$
----------------------------------------------------------------------------
-53 results for /.*icide/
-0 proper ~ 53 common
----------------------------------------------------------------------------
-
-aborticide      foeticide       matricide       pesticide       stillicide
-acaricide       fratricide      medicide        prolicide       suicide
-agricide        fungicide       menticide       pulicide        tyrannicide
-algicide        germicide       miticide        raticide        uxoricide
-aphicide        giganticide     molluscicide    regicide        vaticide
-aphidicide      herbicide       nematicide      rodenticide     verbicide
-bacillicide     homicide        ovicide         scabicide       vermicide
-bactericide     infanticide     parasiticide    silicide        viricide
-deicide         insecticide     parasuicide     sororicide      vulpicide
-feticide        larvicide       parricide       spermicide
-filicide        liberticide     patricide       sporicide
+aborticide      germicide       ovicide         spermicide
+acaricide       giganticide     parasiticide    sporicide
+agricide        herbicide       parasuicide     stillicide
+algicide        homicide        parricide       suicide
+aphicide        infanticide     patricide       tyrannicide
+aphidicide      insecticide     pesticide       uxoricide
+bacillicide     larvicide       prolicide       vaticide
+bactericide     liberticide     pulicide        verbicide
+deicide         matricide       raticide        vermicide
+feticide        medicide        regicide        viricide
+filicide        menticide       rodenticide     vulpicide
+foeticide       miticide        scabicide
+fratricide      molluscicide    silicide
+fungicide       nematicide      sororicide
 ```
 
 ### Example 2
-A list of English words that contain the substring "rdb".
+A list of lowercase English words that contain the substring "rdb", printed with info header.
 ```
-$ lx rdb
----------------------------------------------------------------------------
-21 results for /rdb/
-1 proper ~ 20 common
----------------------------------------------------------------------------
-
-Standardbred
+$ lx -i rdb
+20 matches for /rdb/
 
 birdbath          herdbook
 birdbrain         herdboy
@@ -134,7 +130,7 @@ hardbound         yardbird
 ### Example 3
 The number of lowercase English words that end in "tion".
 ```
-$ lx -nxu ".*tion"
+$ lx -n ".*tion"
 3837
 ```
 (This number should be taken with a grain of salt, since no dictionary
@@ -145,13 +141,10 @@ and which technical or niche jargons are included; etc etc.)
 ### Example 4
 A list of English words with the same double letter appearing twice, except
 for those whose double letter is a vowel or the letter `s` (to ignore
-words of the form `*lessness`).
+words of the form `*lessness`), printed with info header.
 ```
-$ lx "([^aeious])\1.*\1\1"
----------------------------------------------------------------------------
-45 results for /([^aeious])\1.*\1\1/
-9 proper ~ 36 common
----------------------------------------------------------------------------
+$ lx -iu "([^aeious])\1.*\1\1"
+45 matches for /([^aeious])\1.*\1\1/ (9 proper, 36 common)
 
 Allhallowmas
 Allhallows
@@ -163,26 +156,29 @@ Gallirallus
 Hunnemannia
 Llullaillaco
 
-acciaccatura       hillbilly          pellmell           shillyshally
-bellpull           huggermugger       pizzazz            skillfully
-chiffchaff         hullaballoo        pralltriller       snippersnapper
-dillydallier       jellyroll          razzamatazz        villanelle
-dillydally         kinnikinnic        razzmatazz         volleyball
-dullsville         kinnikinnick       riffraff           volleyballer
-flibbertigibbet    millefeuille       rollcollar         whippersnapper
-granddaddy         niffnaff           rollerball         willfully
-hallalling         parallelling       scuttlebutt        yellowbelly
+acciaccatura       jellyroll          rollcollar
+bellpull           kinnikinnic        rollerball
+chiffchaff         kinnikinnick       scuttlebutt
+dillydallier       millefeuille       shillyshally
+dillydally         niffnaff           skillfully
+dullsville         parallelling       snippersnapper
+flibbertigibbet    pellmell           villanelle
+granddaddy         pizzazz            volleyball
+hallalling         pralltriller       volleyballer
+hillbilly          razzamatazz        whippersnapper
+huggermugger       razzmatazz         willfully
+hullaballoo        riffraff           yellowbelly
 ```
 
 ### Example 5
-Compare the number of lowercase/uncapitalized words that end in "woman"
+Compare the number of lowercase English words that end in "woman"
 with the number that end in "man".
 ```
-$ lx -nxu ".*woman"
+$ lx -n ".*woman"
 107
 ```
 ```
-$ lx -nxu ".*(?<\!wo)man"
+$ lx -n ".*(?<\!wo)man"
 1145
 ```
 
@@ -202,4 +198,4 @@ Lexitron is licensed under GNU GPL Version 2.
 Contact
 ------------------------------------------------------------------------------
 Questions, bug reports, and feature requests can be filed on the [Github
-issues tracker](//github.com/hrothgar/lexitron/issues).
+issues tracker](//github.com/rothos/lexitron/issues).

{Lexitron-2.0.4 → lexitron-2.1.2}/Lexitron.egg-info/SOURCES.txt

@@ -1,7 +1,6 @@
 LICENSE
 README.md
 pyproject.toml
-setup.cfg
 ./lexitron/__init__.py
 ./lexitron/agid-common.txt
 ./lexitron/agid-proper.txt
@@ -12,4 +11,8 @@ Lexitron.egg-info/dependency_links.txt
 Lexitron.egg-info/entry_points.txt
 Lexitron.egg-info/not-zip-safe
 Lexitron.egg-info/requires.txt
-Lexitron.egg-info/top_level.txt
+Lexitron.egg-info/top_level.txt
+lexitron/__init__.py
+lexitron/agid-common.txt
+lexitron/agid-proper.txt
+lexitron/lexitron.py

{Lexitron-2.0.4 → lexitron-2.1.2}/Lexitron.egg-info/top_level.txt

@@ -1 +1,2 @@
+dist
 lexitron

{Lexitron-2.0.4/Lexitron.egg-info → lexitron-2.1.2}/PKG-INFO

@@ -1,15 +1,17 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: Lexitron
-Version: 2.0.4
+Version: 2.1.2
 Summary: A command-line regex search engine for the English language
-Home-page: http://github.com/rothos/lexitron
 Author: Rothos
 License: GNU GPL Version 2
+Project-URL: Homepage, http://github.com/rothos/lexitron
 Keywords: english,dictionary,crossword,spelling,words,lexicon,search
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: importlib-metadata; python_version < "3.8"
+Requires-Dist: importlib-resources; python_version < "3.8"
 
 Lexitron
 ==============================================================================
@@ -57,11 +59,12 @@ where `expression` is a regular expression and `[options]` are as follows.
 
  option | function
 --------|-------------------------------------------------
-  `-d`  | Append start and end delimiters `^...$` to search query
+  `-h`  | Print help and exit
+  `-i`  | Print info header along with search results
   `-n`  | Print only the number of matches
-  `-u`  | Search only for lowercase/common/uncapitalized words
-  `-U`  | Search only for uppercase/proper/capitalized words
-  `-v`  | Show version and exit
+  `-u`  | Include uppercase/proper words (like "France") in addition to lowercase/common words
+  `-U`  | Search only for uppercase/proper words
+  `-v`  | Print version and exit
   `-x`  | Print unformatted output, one word per line
 
 Type `$ lx -h` for full help text.
@@ -87,37 +90,30 @@ Examples
 ------------------------------------------------------------------------------
 
 ### Example 1
-A list of English words ending with "icide".
+A list of lowercase English words ending with "icide".
 ```
 $ lx icide$
----------------------------------------------------------------------------
-53 results for /.*icide/
-0 proper ~ 53 common
----------------------------------------------------------------------------
-
-aborticide      foeticide       matricide       pesticide       stillicide
-acaricide       fratricide      medicide        prolicide       suicide
-agricide        fungicide       menticide       pulicide        tyrannicide
-algicide        germicide       miticide        raticide        uxoricide
-aphicide        giganticide     molluscicide    regicide        vaticide
-aphidicide      herbicide       nematicide      rodenticide     verbicide
-bacillicide     homicide        ovicide         scabicide       vermicide
-bactericide     infanticide     parasiticide    silicide        viricide
-deicide         insecticide     parasuicide     sororicide      vulpicide
-feticide        larvicide       parricide       spermicide
-filicide        liberticide     patricide       sporicide
+aborticide      germicide       ovicide         spermicide
+acaricide       giganticide     parasiticide    sporicide
+agricide        herbicide       parasuicide     stillicide
+algicide        homicide        parricide       suicide
+aphicide        infanticide     patricide       tyrannicide
+aphidicide      insecticide     pesticide       uxoricide
+bacillicide     larvicide       prolicide       vaticide
+bactericide     liberticide     pulicide        verbicide
+deicide         matricide       raticide        vermicide
+feticide        medicide        regicide        viricide
+filicide        menticide       rodenticide     vulpicide
+foeticide       miticide        scabicide
+fratricide      molluscicide    silicide
+fungicide       nematicide      sororicide
 ```
 
 ### Example 2
-A list of English words that contain the substring "rdb".
+A list of lowercase English words that contain the substring "rdb", printed with info header.
 ```
-$ lx rdb
----------------------------------------------------------------------------
-21 results for /rdb/
-1 proper ~ 20 common
----------------------------------------------------------------------------
-
-Standardbred
+$ lx -i rdb
+20 matches for /rdb/
 
 birdbath          herdbook
 birdbrain         herdboy
@@ -134,7 +130,7 @@ hardbound         yardbird
 ### Example 3
 The number of lowercase English words that end in "tion".
 ```
-$ lx -nxu ".*tion"
+$ lx -n ".*tion"
 3837
 ```
 (This number should be taken with a grain of salt, since no dictionary
@@ -145,13 +141,10 @@ and which technical or niche jargons are included; etc etc.)
 ### Example 4
 A list of English words with the same double letter appearing twice, except
 for those whose double letter is a vowel or the letter `s` (to ignore
-words of the form `*lessness`).
+words of the form `*lessness`), printed with info header.
 ```
-$ lx "([^aeious])\1.*\1\1"
----------------------------------------------------------------------------
-45 results for /([^aeious])\1.*\1\1/
-9 proper ~ 36 common
----------------------------------------------------------------------------
+$ lx -iu "([^aeious])\1.*\1\1"
+45 matches for /([^aeious])\1.*\1\1/ (9 proper, 36 common)
 
 Allhallowmas
 Allhallows
@@ -163,26 +156,29 @@ Gallirallus
 Hunnemannia
 Llullaillaco
 
-acciaccatura       hillbilly          pellmell           shillyshally
-bellpull           huggermugger       pizzazz            skillfully
-chiffchaff         hullaballoo        pralltriller       snippersnapper
-dillydallier       jellyroll          razzamatazz        villanelle
-dillydally         kinnikinnic        razzmatazz         volleyball
-dullsville         kinnikinnick       riffraff           volleyballer
-flibbertigibbet    millefeuille       rollcollar         whippersnapper
-granddaddy         niffnaff           rollerball         willfully
-hallalling         parallelling       scuttlebutt        yellowbelly
+acciaccatura       jellyroll          rollcollar
+bellpull           kinnikinnic        rollerball
+chiffchaff         kinnikinnick       scuttlebutt
+dillydallier       millefeuille       shillyshally
+dillydally         niffnaff           skillfully
+dullsville         parallelling       snippersnapper
+flibbertigibbet    pellmell           villanelle
+granddaddy         pizzazz            volleyball
+hallalling         pralltriller       volleyballer
+hillbilly          razzamatazz        whippersnapper
+huggermugger       razzmatazz         willfully
+hullaballoo        riffraff           yellowbelly
 ```
 
 ### Example 5
-Compare the number of lowercase/uncapitalized words that end in "woman"
+Compare the number of lowercase English words that end in "woman"
 with the number that end in "man".
 ```
-$ lx -nxu ".*woman"
+$ lx -n ".*woman"
 107
 ```
 ```
-$ lx -nxu ".*(?<\!wo)man"
+$ lx -n ".*(?<\!wo)man"
 1145
 ```
 
@@ -202,4 +198,4 @@ Lexitron is licensed under GNU GPL Version 2.
 Contact
 ------------------------------------------------------------------------------
 Questions, bug reports, and feature requests can be filed on the [Github
-issues tracker](//github.com/hrothgar/lexitron/issues).
+issues tracker](//github.com/rothos/lexitron/issues).

{Lexitron-2.0.4 → lexitron-2.1.2}/README.md

@@ -44,11 +44,12 @@ where `expression` is a regular expression and `[options]` are as follows.
 
  option | function
 --------|-------------------------------------------------
-  `-d`  | Append start and end delimiters `^...$` to search query
+  `-h`  | Print help and exit
+  `-i`  | Print info header along with search results
   `-n`  | Print only the number of matches
-  `-u`  | Search only for lowercase/common/uncapitalized words
-  `-U`  | Search only for uppercase/proper/capitalized words
-  `-v`  | Show version and exit
+  `-u`  | Include uppercase/proper words (like "France") in addition to lowercase/common words
+  `-U`  | Search only for uppercase/proper words
+  `-v`  | Print version and exit
   `-x`  | Print unformatted output, one word per line
 
 Type `$ lx -h` for full help text.
@@ -74,37 +75,30 @@ Examples
 ------------------------------------------------------------------------------
 
 ### Example 1
-A list of English words ending with "icide".
+A list of lowercase English words ending with "icide".
 ```
 $ lx icide$
----------------------------------------------------------------------------
-53 results for /.*icide/
-0 proper ~ 53 common
----------------------------------------------------------------------------
-
-aborticide      foeticide       matricide       pesticide       stillicide
-acaricide       fratricide      medicide        prolicide       suicide
-agricide        fungicide       menticide       pulicide        tyrannicide
-algicide        germicide       miticide        raticide        uxoricide
-aphicide        giganticide     molluscicide    regicide        vaticide
-aphidicide      herbicide       nematicide      rodenticide     verbicide
-bacillicide     homicide        ovicide         scabicide       vermicide
-bactericide     infanticide     parasiticide    silicide        viricide
-deicide         insecticide     parasuicide     sororicide      vulpicide
-feticide        larvicide       parricide       spermicide
-filicide        liberticide     patricide       sporicide
+aborticide      germicide       ovicide         spermicide
+acaricide       giganticide     parasiticide    sporicide
+agricide        herbicide       parasuicide     stillicide
+algicide        homicide        parricide       suicide
+aphicide        infanticide     patricide       tyrannicide
+aphidicide      insecticide     pesticide       uxoricide
+bacillicide     larvicide       prolicide       vaticide
+bactericide     liberticide     pulicide        verbicide
+deicide         matricide       raticide        vermicide
+feticide        medicide        regicide        viricide
+filicide        menticide       rodenticide     vulpicide
+foeticide       miticide        scabicide
+fratricide      molluscicide    silicide
+fungicide       nematicide      sororicide
 ```
 
 ### Example 2
-A list of English words that contain the substring "rdb".
+A list of lowercase English words that contain the substring "rdb", printed with info header.
 ```
-$ lx rdb
----------------------------------------------------------------------------
-21 results for /rdb/
-1 proper ~ 20 common
----------------------------------------------------------------------------
-
-Standardbred
+$ lx -i rdb
+20 matches for /rdb/
 
 birdbath          herdbook
 birdbrain         herdboy
@@ -121,7 +115,7 @@ hardbound         yardbird
 ### Example 3
 The number of lowercase English words that end in "tion".
 ```
-$ lx -nxu ".*tion"
+$ lx -n ".*tion"
 3837
 ```
 (This number should be taken with a grain of salt, since no dictionary
@@ -132,13 +126,10 @@ and which technical or niche jargons are included; etc etc.)
 ### Example 4
 A list of English words with the same double letter appearing twice, except
 for those whose double letter is a vowel or the letter `s` (to ignore
-words of the form `*lessness`).
+words of the form `*lessness`), printed with info header.
 ```
-$ lx "([^aeious])\1.*\1\1"
----------------------------------------------------------------------------
-45 results for /([^aeious])\1.*\1\1/
-9 proper ~ 36 common
----------------------------------------------------------------------------
+$ lx -iu "([^aeious])\1.*\1\1"
+45 matches for /([^aeious])\1.*\1\1/ (9 proper, 36 common)
 
 Allhallowmas
 Allhallows
@@ -150,26 +141,29 @@ Gallirallus
 Hunnemannia
 Llullaillaco
 
-acciaccatura       hillbilly          pellmell           shillyshally
-bellpull           huggermugger       pizzazz            skillfully
-chiffchaff         hullaballoo        pralltriller       snippersnapper
-dillydallier       jellyroll          razzamatazz        villanelle
-dillydally         kinnikinnic        razzmatazz         volleyball
-dullsville         kinnikinnick       riffraff           volleyballer
-flibbertigibbet    millefeuille       rollcollar         whippersnapper
-granddaddy         niffnaff           rollerball         willfully
-hallalling         parallelling       scuttlebutt        yellowbelly
+acciaccatura       jellyroll          rollcollar
+bellpull           kinnikinnic        rollerball
+chiffchaff         kinnikinnick       scuttlebutt
+dillydallier       millefeuille       shillyshally
+dillydally         niffnaff           skillfully
+dullsville         parallelling       snippersnapper
+flibbertigibbet    pellmell           villanelle
+granddaddy         pizzazz            volleyball
+hallalling         pralltriller       volleyballer
+hillbilly          razzamatazz        whippersnapper
+huggermugger       razzmatazz         willfully
+hullaballoo        riffraff           yellowbelly
 ```
 
 ### Example 5
-Compare the number of lowercase/uncapitalized words that end in "woman"
+Compare the number of lowercase English words that end in "woman"
 with the number that end in "man".
 ```
-$ lx -nxu ".*woman"
+$ lx -n ".*woman"
 107
 ```
 ```
-$ lx -nxu ".*(?<\!wo)man"
+$ lx -n ".*(?<\!wo)man"
 1145
 ```
 
@@ -189,4 +183,4 @@ Lexitron is licensed under GNU GPL Version 2.
 Contact
 ------------------------------------------------------------------------------
 Questions, bug reports, and feature requests can be filed on the [Github
-issues tracker](//github.com/hrothgar/lexitron/issues).
+issues tracker](//github.com/rothos/lexitron/issues).

lexitron-2.1.2/lexitron/lexitron.py

@@ -0,0 +1,282 @@
+import sys, os, re, argparse
+from importlib import resources, metadata
+from math import ceil, floor
+from typing import Dict, List, Tuple
+
+class Lexitron:
+    """Main class for the Lexitron command line tool."""
+    
+    # Configuration constants
+    DEFAULT_ENCODING = 'utf-8'
+    WORDLIST_PATHS = {
+        'common': 'agid-common.txt',
+        'proper': 'agid-proper.txt'
+    }
+    FORMATTING = {
+        'gutter_width': 4,
+        'terminal_margin': 1,
+        'show_rules': False
+    }
+
+    def __init__(self):
+        """Initialize Lexitron with wordlist files and argument parser configuration."""
+        # The wordlist files
+        self.wordlist_common_file = resources.files('lexitron').joinpath(self.WORDLIST_PATHS['common'])
+        self.wordlist_proper_file = resources.files('lexitron').joinpath(self.WORDLIST_PATHS['proper'])
+
+        # Here is the argument parser
+        description = "Lexitron, a regex search engine for the English " +\
+            "language. By default, Lexitron searches only for common " +\
+            "(lowercase) words."
+        epilog = "Currently, Lexitron only allows case-insensitive " +\
+            "searching.\n\nSee <https://github.com/rothos/lexitron> for " +\
+            "further documentation and examples."
+        self.parser = argparse.ArgumentParser(prog='lx',
+            description=description, epilog=epilog)
+
+        # Add the positional argument
+        self.parser.add_argument('expression', type=str,
+            help='the regular expression to search')
+
+        # Add the optional arguments
+        self.parser.add_argument('-n', '--number-only',
+            dest='number', action='store_true',
+            help='print only the total number of matches')
+        self.parser.add_argument('-i', '--info',
+            dest='show_info', action='store_true',
+            help='print info header along with search results')
+        self.parser.add_argument('-u', '--uppercase',
+            dest='include_proper', action='store_true',
+            help='include uppercase/proper words (like "France") in addition to lowercase/common words')
+        self.parser.add_argument('-U', '--only-uppercase',
+            dest='only_proper', action='store_true',
+            help='search only for uppercase/proper words')
+        self.parser.add_argument('-v', '--version',
+            action='version', version="Lexitron "+metadata.version('lexitron'),
+            help='print version and exit')
+        self.parser.add_argument('-x', '--plain',
+            dest='unformatted', action='store_true',
+            help='print unformatted output, one word per line')
+
+    def print_help(self):
+        """Display the help message for the command line interface."""
+        self.parser.print_help()
+
+    def parse_args(self, argv: List[str]) -> argparse.Namespace:
+        """Parse command line arguments.
+        
+        Args:
+            argv: List of command line arguments
+            
+        Returns:
+            Parsed argument namespace
+        """
+        # Parse the incoming arguments
+        args = self.parser.parse_args(argv)
+        return args
+
+    def search(self, args: argparse.Namespace) -> Dict[str, List[str]]:
+        """Search wordlists for matches to the given regular expression.
+        
+        Args:
+            args: Parsed command line arguments containing search parameters
+            
+        Returns:
+            Dictionary with 'common' and 'proper' lists of matching words
+        """
+        # Get the expression ready.
+        expr = self.sanitize(args.expression)
+
+        # Currently, lexitron search is case-insensitive.
+        expr = re.compile(expr, flags=re.IGNORECASE)
+        matches = {'common': [], 'proper': []}
+
+        # Now open each wordlist and start searching.
+        # Always search common words unless only_proper is specified
+        if not args.only_proper:
+            for word in self._iter_words(self.wordlist_common_file):
+                if expr.search(word):
+                    matches['common'].append(word)
+
+        # Only search proper words if include_proper or only_proper is specified
+        if args.include_proper or args.only_proper:
+            for word in self._iter_words(self.wordlist_proper_file):
+                if expr.search(word):
+                    matches['proper'].append(word)
+
+        matches['common'] = sorted(list(set(matches['common'])))
+        matches['proper'] = sorted(list(set(matches['proper'])))
+
+        return matches
+
+    def sanitize(self, expr: str) -> str:
+        """Remove wrapping quotation marks from the input expression.
+        
+        Args:
+            expr: Regular expression string
+            
+        Returns:
+            Sanitized expression string
+        """
+        # Remove any wrapping quotation marks from the input.
+        if expr[0]  in ('"',"'"): expr = expr[1:]
+        if expr[-1] in ('"',"'"): expr = expr[:-1]
+        return expr
+
+    def _iter_words(self, wordlist_file) -> str:
+        """Iterate through words in a wordlist file.
+        
+        Args:
+            wordlist_file: A Path object pointing to the wordlist file
+            
+        Yields:
+            str: Each word from the file, one at a time
+        """
+        with wordlist_file.open('rb') as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith(b'#'):  # Skip empty lines and comments
+                    try:
+                        yield self.parse_line(line)
+                    except LexitronParseError:
+                        continue  # Skip lines that can't be parsed
+
+    def parse_line(self, line: bytes) -> str:
+        """Parse a line from the wordlist file.
+        
+        Args:
+            line: A line from the wordlist file
+            
+        Returns:
+            The word from the line
+        """
+        # This only returns the word right now, but since the agid.txt list
+        # contains other information (part of speech, derivative words, etc),
+        # the search may become more robust in the future.
+        try:
+            return line.split()[0].decode()
+        except (IndexError, UnicodeDecodeError) as e:
+            raise LexitronParseError(f"Failed to parse line: {e}")
+
+    def print_results(self, matches: Dict[str, List[str]], args: argparse.Namespace):
+        """Print search results according to specified format.
+        
+        Args:
+            matches: Dictionary containing lists of matching common and proper words
+            args: Parsed arguments controlling output format
+        """
+        commons = matches['common']
+        propers = matches['proper']
+
+        if args.unformatted:
+            if args.number:
+                # Unformatted number only
+                print(str(len(propers + commons)))
+            else:
+                # Unformatted matches
+                print('\n'.join(propers + commons))
+        else:
+            width, height = os.get_terminal_size()
+            width = width - 1  # Wiggle room
+
+            if args.number:
+                # Print only the total number
+                print(len(propers + commons))
+            else:
+                # Print header if requested
+                if args.show_info:
+                    print(self.header(commons, propers, args, width))
+                    if propers or commons:
+                        print()
+                
+                # Print matches
+                if propers:
+                    print(self.formatted(propers, width, height))
+                if commons and propers:
+                    print()
+                if commons:
+                    print(self.formatted(commons, width, height))
+
+    def header(self, commons: List[str], propers: List[str], args: argparse.Namespace, width: int) -> str:
+        """Generate header string showing search results summary.
+        
+        Args:
+            commons: List of matching common words
+            propers: List of matching proper words
+            args: Parsed arguments containing search expression
+            width: Terminal width for formatting
+            
+        Returns:
+            Formatted header string
+        """
+        rule = '-' * width if self.FORMATTING['show_rules'] else ''
+        total = len(commons + propers)
+        expr = self.sanitize(args.expression)
+
+        breakdown = ''
+        if args.include_proper and not args.only_proper:
+            breakdown = ' (' + str(len(propers)) + ' proper, ' + str(len(commons)) + ' common)'
+
+        if self.FORMATTING['show_rules']:
+            txt = "{rule}\n{total} matches for /{expr}/{breakdown}\n{rule}"
+        else:
+            txt = "{total} matches for /{expr}/{breakdown}"
+            
+        return txt.format(rule=rule, total=total, expr=expr, breakdown=breakdown)
+
+    def formatted(self, words: List[str], termwidth: int, termheight: int) -> str:
+        """Format word list into columns that fit the terminal dimensions.
+        
+        Args:
+            words: List of words to format
+            termwidth: Width of terminal in characters
+            termheight: Height of terminal in characters
+            
+        Returns:
+            String of words formatted in columns
+        """
+        N = len(words)
+        GUTTER = self.FORMATTING['gutter_width']
+        COLWIDTH = max([len(word) for word in words])
+
+        # Adjust terminal width by margin
+        termwidth = termwidth - self.FORMATTING['terminal_margin']
+
+        # The maximum number of columns that will fit in the terminal
+        # (taking into account gutter width). The mathematics:
+        #    termwidth = n*colwidth + (n-1)*gutter,   solve for n.
+        max_num_cols = max(1, floor((GUTTER + termwidth)/float(GUTTER + COLWIDTH)))
+
+        # These are heuristics for determining the number of columns of output.
+        num_cols = max(1, min(max_num_cols, ceil(N/(termheight/2.))))
+        num_rows = ceil(N/float(num_cols))
+
+        # Convert to integers.
+        num_cols = int(num_cols)
+        num_rows = int(num_rows)
+
+        # Fill in the rest of the matrix with blanks.
+        # words = words + ['']*((numcols - (n-numcols*numrows)) % numcols)
+        words = words + ['']*(num_cols*num_rows - N)
+
+        rowlist = []
+        for k in range(num_rows):
+            rowlist += [''.join(word.ljust(COLWIDTH+GUTTER) \
+                        for word in words[k::num_rows]).rstrip()]
+
+        pretty_printed_results = '\n'.join(rowlist)
+        return pretty_printed_results
+
+
+# This is invoked when there's an error parsing the wordlist files
+class LexitronParseError(Exception):
+    pass
+
+
+# The function that will be called from the command line
+def main():
+    """Entry point for the Lexitron command line interface."""
+    lx      = Lexitron()
+    args    = lx.parse_args(sys.argv[1:])
+    matches = lx.search(args)
+    lx.print_results(matches, args)

lexitron-2.1.2/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "Lexitron"
+version = "2.1.2"
+authors = [
+    {name = "Rothos"}
+]
+description = "A command-line regex search engine for the English language"
+readme = "README.md"
+requires-python = ">=3.7"
+keywords = ["english", "dictionary", "crossword", "spelling", "words", "lexicon", "search"]
+license = {text = "GNU GPL Version 2"}
+classifiers = [
+    "Programming Language :: Python :: 3",
+]
+dependencies = [
+    "importlib-metadata;python_version<'3.8'",
+    "importlib-resources;python_version<'3.8'"
+]
+
+[project.urls]
+Homepage = "http://github.com/rothos/lexitron"
+
+[tool.setuptools]
+zip-safe = false
+include-package-data = true
+package-dir = {""= "."}
+
+[tool.setuptools.packages.find]
+where = ["."]
+
+[tool.setuptools.package-data]
+"*" = ["*.txt"]
+
+[project.scripts]
+lx = "lexitron.lexitron:main"

lexitron-2.1.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

Lexitron-2.0.4/lexitron/lexitron.py

@@ -1,190 +0,0 @@
-import sys, os, re, argparse
-from importlib import resources, metadata
-from math import ceil, floor
-
-class Lexitron:
-    def __init__(self):
-        # The wordlist files
-        self.wordlist_common_file = resources.files('lexitron').joinpath('agid-common.txt')
-        self.wordlist_proper_file = resources.files('lexitron').joinpath('agid-proper.txt')
-
-        with self.wordlist_common_file.open('rb') as f:
-            self.wordlist_common = f.read()
-        f.close()
-
-        with self.wordlist_proper_file.open('rb') as f:
-            self.wordlist_proper = f.read()
-        f.close()
-
-        # Here is the argument parser
-        description = "Lexitron, a regex search engine for the English " +\
-            "language."
-        epilog = "Currently, Lexitron only allows case-insensitive " +\
-            "searching.\n\nSee <http://github.com/rothos/lexitron> for " +\
-            "further documentation and examples."
-        self.parser = argparse.ArgumentParser(prog='lx',
-            description=description, epilog=epilog)
-
-        # Add the positional argument
-        self.parser.add_argument('expression', type=str,
-            help='The regular expression to search')
-
-        # Add the optional arguments
-        # self.parser.add_argument('-a',
-        #     dest='all', action='store_true',
-        #     help='Search all words, including plurals and conjugations')
-        self.parser.add_argument('-n', '--number-only',
-            dest='number', action='store_true',
-            help='Print only the number of matches')
-        self.parser.add_argument('-u', '--lowercase',
-            dest='only_common', action='store_true',
-            help='Search only for lowercase/common/uncapitalized words (like "boat")')
-        self.parser.add_argument('-U', '--uppercase',
-            dest='only_proper', action='store_true',
-            help='Search only for uppercase/proper/capitalized words (like "France")')
-        self.parser.add_argument('-v', '--version',
-            action='version', version="Lexitron "+metadata.version('lexitron'),
-            help='Show version and exit')
-        self.parser.add_argument('-x', '--plain',
-            dest='unformatted', action='store_true',
-            help='Print unformatted output, one word per line')
-
-    def print_help(self):
-        self.parser.print_help()
-
-    def parse_args(self, argv):
-        # Parse the incoming arguments
-        args = self.parser.parse_args(argv)
-        return args
-
-    def search(self, args):
-        # Figure out which files to search
-        if args.only_common and args.only_proper:
-            msg = 'Mutually exclusive options -u and -U may not ' \
-                + 'be used together.'
-            raise LexitronOptionsError(msg)
-
-        # Get the expression ready.
-        expr = self.sanitize(args.expression)
-
-        # Currently, lexitron search is case-insensitive.
-        expr = re.compile(expr, flags=re.IGNORECASE)
-        matches = {'common': [], 'proper': []}
-
-        # Now open each wordlist and start searching.
-        if not args.only_proper:
-            for line in self.wordlist_common.splitlines():
-                word = self.parse_line(line)
-                if expr.search(word):
-                    matches['common'] += [word]
-
-        if not args.only_common:
-            for line in self.wordlist_proper.splitlines():
-                word = self.parse_line(line)
-                if expr.search(word):
-                    matches['proper'] += [word]
-
-        matches['common'] = sorted(list(set(matches['common'])))
-        matches['proper'] = sorted(list(set(matches['proper'])))
-
-        return matches
-
-    def sanitize(self, expr):
-        # Remove any wrapping quotation marks from the input.
-        if expr[0]  in ('"',"'"): expr = expr[1:]
-        if expr[-1] in ('"',"'"): expr = expr[:-1]
-        return expr
-
-    def parse_line(self, line):
-        # This only returns the word right now, but since the agid.txt list
-        # contains other information (part of speech, derivative words, etc),
-        # the search may become more robust in the future.
-        return line.split()[0].decode()
-
-    def print_results(self, matches, args):
-        commons = matches['common']
-        propers = matches['proper']
-
-        if args.unformatted:
-            if args.number:
-                # Unformatted number
-                print(str(len(propers + commons)))
-            else:
-                # Unformatted matches
-                print('\n'.join(propers + commons))
-
-        else:
-            width, height = os.get_terminal_size()
-            width  = width - 1  # Wiggle room
-
-            if args.number:
-                # Formatted number
-                print(self.header(commons, propers, args, width))
-            else:
-                # Formatted matches
-                print(self.header(commons, propers, args, width))
-                if propers:
-                    print(self.formatted(propers, width, height))
-                if commons:
-                    print(self.formatted(commons, width, height))
-
-    def header(self, commons, propers, args, width):
-        rule  = '-' * width
-        total = len(commons + propers)
-        expr  = self.sanitize(args.expression)
-
-        breakdown = [str(len(propers)) + ' proper', str(len(commons)) + ' common']
-        if args.only_proper:
-            breakdown = ['(restricted search)']
-        elif args.only_common:
-            breakdown = ['(restricted search)']
-        breakdown = ' ~ '.join(breakdown)
-
-        txt = "{rule}\n{total} results for /{expr}/\n" \
-              "{breakdown}\n{rule}\n".format(rule=rule,
-                total=total, expr=expr, breakdown=breakdown)
-
-        return txt
-
-    def formatted(self, words, termwidth, termheight):
-        n        = len(words)
-        gutter   = 4
-        colwidth = max([len(word) for word in words])
-
-        # The maximum number of columns that will fit in the terminal
-        # (taking into account gutter width). The mathematics:
-        #    termwidth = n*colwidth + (n-1)*gutter,   solve for n.
-        maxnumcols = max(1, floor((gutter + termwidth)/float(gutter + colwidth)))
-
-        # These are heuristics for determining the number of columns of output.
-        numcols = max(1, min(maxnumcols, ceil(n/(termheight/2.))))
-        numrows = ceil(n/float(numcols))
-
-        # Convert to integers.
-        numcols = int(numcols)
-        numrows = int(numrows)
-
-        # Fill in the rest of the matrix with blanks.
-        # words = words + ['']*((numcols - (n-numcols*numrows)) % numcols)
-        words = words + ['']*(numcols*numrows - n)
-
-        rowlist = []
-        for k in range(numrows):
-            rowlist += [''.join(word.ljust(colwidth+gutter) \
-                        for word in words[k::numrows]).rstrip()]
-
-        pretty_printed_results = '\n'.join(rowlist) + '\n'
-        return pretty_printed_results
-
-
-# This is invoked when mutually exclusive options -a and -A are used together.
-class LexitronOptionsError(Exception):
-    pass
-
-
-# The function that will be called from the command line
-def main():
-    lx      = Lexitron()
-    args    = lx.parse_args(sys.argv[1:])
-    matches = lx.search(args)
-    lx.print_results(matches, args)

Lexitron-2.0.4/pyproject.toml

@@ -1,3 +0,0 @@
-[build-system]
-requires = ["setuptools"]
-build-backend = "setuptools.build_meta"

Lexitron-2.0.4/setup.cfg

@@ -1,38 +0,0 @@
-[metadata]
-name = Lexitron
-version = 2.0.4
-author = Rothos
-url = http://github.com/rothos/lexitron
-description = A command-line regex search engine for the English language
-long_description = file: README.md
-long_description_content_type = text/markdown
-keywords = english, dictionary, crossword, spelling, words, lexicon, search
-license = GNU GPL Version 2
-classifiers = 
-	Programming Language :: Python :: 3
-
-[options]
-zip_safe = False
-include_package_data = True
-packages = find:
-python_requires = >=3.7
-install_requires = 
-	importlib-metadata;python_version<'3.8'
-	importlib-resources;python_version<'3.8'
-package_dir = 
-	= .
-
-[options.packages.find]
-where = .
-
-[options.package_data]
-* = *.txt
-
-[options.entry_points]
-console_scripts = 
-	lx = lexitron.lexitron:main
-
-[egg_info]
-tag_build = 
-tag_date = 0
-