pynagram3 3.1.0__py3-none-any.whl

pynagram/__init__.py

@@ -0,0 +1,3 @@
+"""Pynagram - Unjumble the letters and get addicted!"""
+
+__version__ = "3.1.0"

pynagram/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from pynagram.main import main
+
+sys.exit(main())

pynagram/backend/anagram.py

@@ -0,0 +1,118 @@
+#
+#     anagram.py
+#
+#     Copyright (c) 2009, 2010, 2011 Umang Varma <umang.me@gmail.com>.
+#
+#     This file is part of Pynagram
+#
+#     Pynagram is free software: you can redistribute it and/or modify
+#     it under the terms of the GNU General Public License as published by
+#     the Free Software Foundation, either version 3 of the License, or
+#     (at your option) any later version.
+#
+#     Pynagram is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#     GNU General Public License for more details.
+#
+#     You should have received a copy of the GNU General Public License
+#     along with Pynagram. If not, see <http://www.gnu.org/licenses/>.
+#
+
+import random
+from collections import Counter
+
+
+class AnagramException(Exception): pass
+class LengthException(AnagramException): pass
+class WordException(AnagramException): pass
+
+
+class Anagram:
+    """The backend of pynagram that manages the current game.
+
+    This class performs all the back-end tasks such as generating anagrams,
+    checking if the input word exists, etc."""
+
+    LENGTH = 7
+    MIN_LENGTH = 3
+
+    def __init__(self):
+        self.letters = []
+        self.score = 0
+        self.words = {}
+        self.wordlist = []
+        self.scoring = {3: 3, 4: 5, 5: 8, 6: 14, 7: 20}
+        self.solved_all = False
+        self.qualified = False
+
+    def read_from_file(self, wordlist):
+        """Reads a word list file (one word per line).
+
+        Raises OSError if the file cannot be read and WordException if it does
+        not contain any word long enough to build a game from."""
+        with open(wordlist, encoding="utf-8", errors="replace") as fsock:
+            words = self.filter_wordlist(fsock)
+        if not any(len(w) == self.LENGTH for w in words):
+            raise WordException(
+                "The word list %s does not contain any %d letter words."
+                % (wordlist, self.LENGTH))
+        self.wordlist = words
+
+    def filter_wordlist(self, lines):
+        """Normalises raw lines into a sorted list of unique, playable words."""
+        words = {line.strip().lower() for line in lines}
+        return sorted(w for w in words
+                      if w.isalpha() and self.MIN_LENGTH <= len(w) <= self.LENGTH)
+
+    def find_letters(self, length=LENGTH):
+        """Picks the letters of a random word of the given length."""
+        candidates = [w for w in self.wordlist if len(w) == length]
+        if not candidates:
+            raise WordException("There are no %d letter words in the word list"
+                                % length)
+        return list(random.choice(candidates))
+
+    def start_new(self, letters=None, length=LENGTH):
+        """Starts a new game of Pynagram!"""
+        self.qualified = False
+        self.solved_all = False
+        if letters is not None and len(letters) == length:
+            letters = [x.lower() for x in letters]
+        elif letters is not None:
+            raise LengthException("Bad number of letters given.")
+        else:
+            letters = self.find_letters(length)
+        available = Counter(letters)
+        words = [w for w in self.wordlist if not Counter(w) - available]
+        if not any(len(w) == length for w in words):
+            raise WordException("There are no %d letter words that match "
+                                "this anagram" % length)
+        self.letters = letters
+        self.words = {w: False for w in words}
+
+    def guess(self, word):
+        """Attempts to solve (guess) a word.
+
+        Returns a tuple (valid, already_guessed)."""
+        word = word.lower()
+        if word not in self.words:
+            return (False, False)
+        typed = self.words[word]
+        self.words[word] = True
+        if not typed:
+            self.score += self.scoring[len(word)]
+            if not self.qualified and len(word) == self.LENGTH:
+                self.score += 30
+                self.qualified = True
+            if all(self.words.values()) and not self.solved_all:
+                self.solved_all = True
+                self.score += 30
+        return (True, typed)
+
+    def clear_all(self):
+        """Clears all data being used for a new game."""
+        self.score = 0
+        self.letters = []
+        self.words = {}
+        self.qualified = False

pynagram/backend/config.py

@@ -0,0 +1,148 @@
+#
+#     config.py
+#
+#     Copyright (c) 2010 Umang Varma <umang.me@gmail.com>.
+#
+#     This file is part of Pynagram
+#
+#     Pynagram is free software: you can redistribute it and/or modify
+#     it under the terms of the GNU General Public License as published by
+#     the Free Software Foundation, either version 3 of the License, or
+#     (at your option) any later version.
+#
+#     Pynagram is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#     GNU General Public License for more details.
+#
+#     You should have received a copy of the GNU General Public License
+#     along with Pynagram. If not, see <http://www.gnu.org/licenses/>.
+#
+"""Configuration handling.
+
+The configuration is a small JSON file stored in
+``$XDG_CONFIG_HOME/pynagram/config.json`` (normally ``~/.config/pynagram``).
+It contains the list of word lists and the index of the selected one.
+
+The word list bundled with the package is stored as the special value
+``BUILTIN`` rather than as a file path, so that the configuration keeps working
+when the package is upgraded, reinstalled or moved to another virtualenv.
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+
+DATA_DIR = Path(__file__).resolve().parent.parent / "data"
+BUILTIN = "builtin:english"
+BUILTIN_PATH = DATA_DIR / "wordlist" / "wordlist.txt"
+BUILTIN_LABEL = "Built-in English word list"
+
+
+def config_dir():
+    """Returns the directory holding the configuration file."""
+    if sys.platform == "win32":
+        base = Path(os.environ.get("APPDATA", Path.home()))
+        return base / "Pynagram"
+    base = os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config"
+    return Path(base) / "pynagram"
+
+
+def legacy_config_file():
+    """Config file used by Pynagram <= 3.0 (~/.pynagram/config.txt)."""
+    return Path.home() / ".pynagram" / "config.txt"
+
+
+def resolve_wordlist(entry):
+    """Turns a config entry into a file path."""
+    return BUILTIN_PATH if entry == BUILTIN else Path(entry)
+
+
+def describe_wordlist(entry):
+    """Human readable name of a config entry."""
+    return BUILTIN_LABEL if entry == BUILTIN else entry
+
+
+def _is_old_bundled_list(path):
+    """True for paths where older versions installed the default word list."""
+    p = Path(path)
+    return p.name == "wordlist.txt" and p.parent.name in ("pynagram", "wordlist")
+
+
+class pynagram_config(dict):
+    """Handles all configuration actions: read, write, defaults, etc"""
+
+    def __init__(self):
+        dict.__init__(self)
+        self.changed = False
+
+    def pathtoconfig(self):
+        """Returns path to the configuration directory"""
+        return str(config_dir())
+
+    def pathtoconfigfile(self):
+        """Returns path to the configuration file"""
+        return str(config_dir() / "config.json")
+
+    def _load(self):
+        path = Path(self.pathtoconfigfile())
+        if path.exists():
+            with open(path, encoding="utf-8") as fsock:
+                return json.load(fsock)
+        legacy = legacy_config_file()
+        if legacy.exists():
+            with open(legacy, encoding="utf-8") as fsock:
+                data = json.load(fsock)
+            # Drop the old, absolute path to the bundled list; the built-in
+            # entry is re-added below.
+            data["wordlists"] = [w for w in data.get("wordlists", [])
+                                 if not _is_old_bundled_list(w)]
+            data["wordlist"] = 0
+            return data
+        return {}
+
+    def readconfig(self):
+        """Reads the configuration file, falling back to defaults."""
+        try:
+            data = self._load()
+            if not isinstance(data, dict):
+                raise ValueError("config is not a JSON object")
+        except (OSError, ValueError) as err:
+            print("pynagram: ignoring unreadable config (%s)" % err,
+                  file=sys.stderr)
+            data = {}
+        self.clear()
+        self.update(data)
+        wordlists = [str(w) for w in self.get("wordlists", [])]
+        if BUILTIN in wordlists:
+            wordlists.remove(BUILTIN)
+        self["wordlists"] = [BUILTIN] + wordlists
+        if not isinstance(self.get("wordlist"), int) or \
+                not 0 <= self["wordlist"] < len(self["wordlists"]):
+            self["wordlist"] = 0
+        if not Path(self.pathtoconfigfile()).exists():
+            self.writeconfig()
+
+    def writeconfig(self):
+        """Writes the configuration file."""
+        self.createdir()
+        self["wordlists"] = [w if w == BUILTIN else os.path.normpath(w)
+                             for w in self["wordlists"]]
+        with open(self.pathtoconfigfile(), "w", encoding="utf-8") as fsock:
+            json.dump(self, fsock, indent=4)
+
+    def writedefault(self):
+        """Writes default config file"""
+        self.clear()
+        self["wordlists"] = [BUILTIN]
+        self["wordlist"] = 0
+        self.writeconfig()
+
+    def createdir(self):
+        """Creates the config directory if it doesn't already exist"""
+        os.makedirs(self.pathtoconfig(), exist_ok=True)
+
+    def selected_wordlist(self):
+        """Config entry of the currently selected word list."""
+        return self["wordlists"][self["wordlist"]]

pynagram/data/icons/pixmaps/pynagram.xpm

@@ -0,0 +1,37 @@
+/* XPM */
+static char * pynagram_xpm[] = {
+"32 32 2 1",
+" 	c None",
+".	c #000000",
+"                                ",
+"                                ",
+"                                ",
+"                                ",
+"       .....................    ",
+"     ......................     ",
+"     ......................     ",
+"    ...   ...       ...         ",
+"    ...  ....       ...         ",
+"         ....      ....         ",
+"         ....      ....         ",
+"         ....      ....         ",
+"         ...       ...          ",
+"         ...       ...          ",
+"        ....      ....          ",
+"        ....      ....          ",
+"        ...       ...           ",
+"        ...       ...           ",
+"       ....      ....           ",
+"       ....      ....           ",
+"       ....      ....           ",
+"       ....      ....           ",
+"       ...       .....  .       ",
+"      ....        .......       ",
+"      ....         .....        ",
+"                                ",
+"                                ",
+"                                ",
+"                                ",
+"                                ",
+"                                ",
+"                                "};

pynagram/data/pynagram.desktop

@@ -0,0 +1,10 @@
+[Desktop Entry]
+Type=Application
+Name=Pynagram
+GenericName=Anagram Game
+Comment=Unjumble the letters and get addicted!
+Exec=pynagram
+Icon=pynagram
+Terminal=false
+Categories=Game;LogicGame;
+Keywords=anagram;word;puzzle;letters;

pynagram/data/wordlist/README

@@ -0,0 +1,17 @@
+This word list has been compiled using the SCOWL word list. The word list
+contains words from the english-words category upto level 55. The following
+copyright notice applies to the word list, as mentioned in the original
+package's README file (a copy of which is provided in this folder as
+wordlist-README):
+
+  Copyright 2000-2004 by Kevin Atkinson
+
+  Permission to use, copy, modify, distribute and sell these word
+  lists, the associated scripts, the output created from the scripts,
+  and its documentation for any purpose is hereby granted without fee,
+  provided that the above copyright notice appears in all copies and
+  that both that copyright notice and this permission notice appear in
+  supporting documentation. Kevin Atkinson makes no representations
+  about the suitability of this array for any purpose. It is provided
+  "as is" without express or implied warranty.
+