pgzero-plus 0.1.0__py3-none-any.whl

pgzero/spellcheck.py

@@ -0,0 +1,173 @@
+import re
+
+from operator import itemgetter
+
+from .game import PGZeroGame, positional_parameters
+
+
+def distance(a, b):
+    """Compute the distance between a and b.
+
+    This is based on Damerau-Levenshtein distance, but we modify the cost
+    of some edits, like insertion or removal of '_', or capitalisation changes.
+
+    """
+    d = {}
+    la = len(a)
+    lb = len(b)
+    for i in range(la + 1):
+        d[i, 0] = i
+    for j in range(1, lb + 1):
+        d[0, j] = j
+
+    for i, ca in enumerate(a, start=1):
+        for j, cb in enumerate(b, start=1):
+            cost = int(ca != cb)
+            if ca.lower() == cb.lower():
+                subst_cost = 0
+            else:
+                subst_cost = 1.25 * cost
+            insertion_cost = 0.7 if cb == "_" else 1.0
+            deletion_cost = 0.7 if ca == "_" else 1.0
+            d[i, j] = min(
+                d[i - 1, j] + deletion_cost,  # deletion
+                d[i, j - 1] + insertion_cost,  # insertion
+                d[i - 1, j - 1] + subst_cost,  # substitution
+            )
+            if i > 1 and j > 1 and ca == b[j - 2] and a[i - 2] == cb:
+                d[i, j] = min(d[i, j], d[i - 2, j - 2] + cost)  # transposition
+
+    return d[la, lb]
+
+
+def suggest(word, candidates):
+    """Suggest good candidates as corrections for the given word.
+
+    Suggestions will be ordered from best to worst.
+
+    """
+    candidates_with_score = [(c, distance(word, c)) for c in candidates]
+    good_candidates = [(c, d) for c, d in candidates_with_score if d < 2.6]
+    good_candidates.sort(key=itemgetter(1))
+    # print(word, good_candidates)
+    return [c for c, d in good_candidates]
+
+
+def compare(have, want):
+    """Compare a set of names we have (from user input) to those we want.
+
+    This is a greedy algorithm that will take the best answer for each word
+    in have in turn.
+
+    Returns (typos with suggestions, unrecognised functions)
+    """
+    want = set(want)
+    have = set(have)
+    matched = want & have
+    want -= matched
+    have -= matched
+    typos = []
+    for w in have:
+        suggestions = suggest(w, want)
+        if suggestions:
+            s = suggestions[0]
+            typos.append((w, s))
+            want.discard(s)
+    have -= set(w for w, s in typos)
+    return typos, have
+
+
+# The list of hooks we support
+
+EVENT_HOOKS = list(PGZeroGame.EVENT_HANDLERS.values())
+
+HOOKS = ["draw", "update", "start"]
+
+
+# The list of magic module-level constants
+CONSTS = ["TITLE", "WIDTH", "HEIGHT", "ICON"]
+
+# Available parameters for each hook
+# NB. update() takes one or zero positional parameter but we don't constrain
+# the name.
+#
+# FIXME: These are from the documentation; there could be some missing here
+VALID_PARAMS = {
+    "on_mouse_down": ["pos", "button"],
+    "on_mouse_up": ["pos", "button"],
+    "on_mouse_move": ["pos", "buttons", "rel"],
+    "on_key_up": ["key", "mod"],
+    "on_key_down": ["unicode", "key", "mod"],
+    "draw": [],
+    "on_music_end": [],
+}
+
+
+class InvalidParameter(Exception):
+    """A parameter to a hook was invalid."""
+
+
+class SpellCheckResult:
+    def warn(self, msg, found, suggestion):
+        print(msg.format(found=found, suggestion=suggestion))
+
+    def warn_event_handlers(self, typos, missing):
+        if not typos or missing:
+            return
+        print("Warning: Found some 'on' functions that are not " "valid event handlers.")
+        for found, suggestion in typos:
+            print("    {found} (did you mean {suggestion}?)".format(found=found, suggestion=suggestion))
+        for f in missing:
+            print("   ", f)
+
+    def error(self, msg, found, suggestion):
+        raise InvalidParameter(msg.format(found=found, suggestion=suggestion))
+
+
+def spellcheck(namespace, result=SpellCheckResult()):
+    """Spell check the names in the given module.
+
+    Where hooks are found, validate their positional parameters and offer
+    suggestions where mispelled.
+
+    """
+    funcs = {}
+    consts = []
+    for name, val in namespace.items():
+        if callable(val) and not isinstance(val, type):
+            funcs[name] = val
+        elif isinstance(val, (str, int)):
+            consts.append(name)
+
+    typos, _ = compare(funcs, HOOKS)
+    for found, suggestion in typos:
+        result.warn("Warning: found function named {found}: " "did you mean {suggestion}?", found, suggestion)
+
+    typos, missing = compare(funcs, EVENT_HOOKS)
+    maybe_hook = re.compile("on[A-Z_]")
+    missing_hooks = [f for f in missing if re.match(maybe_hook, f)]
+    result.warn_event_handlers(typos, missing_hooks)
+
+    typos, _ = compare(consts, CONSTS)
+    for found, suggestion in typos:
+        result.warn("Warning: found constant named {found}: " "did you mean {suggestion}?", found, suggestion)
+
+    for name, handler in funcs.items():
+        try:
+            valid = VALID_PARAMS[name]
+        except KeyError:
+            continue
+        else:
+            param_names = positional_parameters(handler)
+            for param in param_names:
+                if param in valid:
+                    continue
+                suggestions = suggest(param, valid)
+                if suggestions:
+                    result.error(
+                        "%s() hook accepts no parameter {found}; " "did you mean {suggestion}?" % name,
+                        param,
+                        suggestions[0],
+                    )
+                else:
+                    result.error("%s() hook accepts no parameter {found}" % name, param, None)

pgzero/sprites.py

@@ -0,0 +1,182 @@
+import pygame
+
+from . import loaders
+from .actor import Actor, POS_TOPLEFT, ANCHOR_CENTER
+
+
+class SpriteSheet:
+    def __init__(self, name):
+        self.name = name
+        self.sheet = loaders.sprites.load(name)
+
+    def image_at(self, rectangle, color_key=None):
+        rect = pygame.Rect(rectangle)
+        image = pygame.Surface(rect.size, pygame.SRCALPHA).convert_alpha()
+        image.blit(self.sheet, (0, 0), rect)
+
+        if color_key is not None:
+            if color_key == -1:
+                color_key = image.get_at((0, 0))
+            image.set_colorkey(color_key, pygame.RLEACCEL)
+
+        return image
+
+    def images_at(self, rects, color_key=None):
+        return [self.image_at(rect, color_key) for rect in rects]
+
+    def load_strip(self, rect, image_count, color_key=None):
+        rects = [(rect[0] + rect[2] * i, rect[1], rect[2], rect[3]) for i in range(image_count)]
+        return self.images_at(rects, color_key)
+
+
+class Sprite:
+    def __init__(
+        self,
+        image_name,
+        frame_width,
+        frame_height,
+        row_number,
+        frame_count,
+        fps=10,
+        transparent_color=None,
+        loop=True,
+    ):
+        self.image_name = image_name
+        self.frame_width = frame_width
+        self.frame_height = frame_height
+        self.row_number = row_number
+        self.frame_count = frame_count
+        self.fps = fps
+        self.transparent_color = transparent_color
+        self.loop = loop
+        self.finished = False
+        self.frame_index = 0
+        self.last_update_time = pygame.time.get_ticks()
+
+        ss = SpriteSheet(image_name)
+        sheet_width, sheet_height = ss.sheet.get_size()
+        if frame_height * (row_number + 1) > sheet_height:
+            raise ValueError(
+                f"Row {row_number} is outside the sprite sheet. "
+                f"The sheet is {sheet_width}x{sheet_height}, "
+                f"but row {row_number} with frame height {frame_height} "
+                f"would end at y={frame_height * (row_number + 1)}."
+            )
+        if frame_width * frame_count > sheet_width:
+            raise ValueError(
+                f"The requested frames go past the edge of the sprite sheet. "
+                f"The sheet is {sheet_width} pixels wide, but "
+                f"{frame_count} frames with width {frame_width} need "
+                f"{frame_width * frame_count} pixels."
+            )
+
+        first_rect = (
+            0,
+            frame_height * row_number,
+            frame_width,
+            frame_height,
+        )
+        self.images = ss.load_strip(first_rect, frame_count, transparent_color)
+
+        if not self.images:
+            raise ValueError("Sprite must contain at least one frame")
+
+    @property
+    def image(self):
+        return self.images[self.frame_index]
+
+    def copy(self):
+        return Sprite(
+            self.image_name,
+            self.frame_width,
+            self.frame_height,
+            self.row_number,
+            self.frame_count,
+            self.fps,
+            self.transparent_color,
+            self.loop,
+        )
+
+    def reset(self):
+        self.set_frame(0)
+
+    def set_frame(self, frame_index):
+        if frame_index < 0 or frame_index >= len(self.images):
+            raise ValueError(f"Frame index {frame_index} is out of range")
+
+        self.frame_index = frame_index
+        self.finished = False
+        self.last_update_time = pygame.time.get_ticks()
+        return self.image
+
+    def next_frame(self):
+        if self.finished:
+            return self.image
+
+        current_time = pygame.time.get_ticks()
+        frame_duration_ms = 1000 / self.fps
+
+        if current_time - self.last_update_time >= frame_duration_ms:
+            if self.frame_index < len(self.images) - 1:
+                self.frame_index += 1
+            elif self.loop:
+                self.frame_index = 0
+            else:
+                self.finished = True
+
+            self.last_update_time = current_time
+
+        return self.image
+
+
+class SpriteActor(Actor):
+    def __init__(
+        self,
+        sprite,
+        pos=POS_TOPLEFT,
+        anchor=ANCHOR_CENTER,
+        collision_rect=None,
+        **kwargs,
+    ):
+        self._sprite = sprite
+        self._paused = False
+
+        super().__init__(
+            sprite.image,
+            pos=pos,
+            anchor=anchor,
+            collision_rect=collision_rect,
+            **kwargs,
+        )
+
+    @property
+    def sprite(self):
+        return self._sprite
+
+    @sprite.setter
+    def sprite(self, sprite):
+        old_sprite = self._sprite
+        self._sprite = sprite
+        if old_sprite is not sprite:
+            self._sprite.reset()
+        self.image = self._sprite.image
+
+    def pause(self):
+        self._paused = True
+
+    def resume(self):
+        self._paused = False
+
+    @property
+    def paused(self):
+        return self._paused
+
+    def update_animation(self):
+        if not self._paused:
+            frame = self._sprite.next_frame()
+            if frame is not self._orig_surf:
+                self.image = frame
+
+    def draw(self):
+        self.update_animation()
+        super().draw()

pgzero/storage.py

@@ -0,0 +1,191 @@
+import json
+import os
+import platform
+from hashlib import sha1
+
+
+__all__ = ['StorageCorruptionException', 'JSONEncodingException', 'Storage']
+
+
+class StorageCorruptionException(Exception):
+    """The data in the storage is corrupted."""
+
+
+class JSONEncodingException(Exception):
+    """The data in the storage is corrupted."""
+
+
+def _get_platform_pgzero_path():
+    r"""Get the storage directory for pgzero save data.
+
+    Under Windows, return %APPDATA%\pgzero. Under Linux/MacOS, return
+    ~/.config/pgzero/saves.
+
+    """
+    if platform.system() == 'Windows':
+        try:
+            appdata = os.environ['APPDATA']
+        except KeyError:
+            raise KeyError(
+                "Couldn't find the AppData directory for Pygame Zero save "
+                "data. Please set the %APPDATA% environment variable."
+            )
+        return os.path.join(appdata, 'pgzero')
+    return os.path.expanduser(os.path.join('~', '.config/pgzero/saves'))
+
+
+class Storage(dict):
+    """Behaves like a dictionary that serialises itself to disk.
+
+    The name of the file will be based on the basename of the script plus
+    a hash of the script's path, ensuring that each script on the filesystem
+    has a unique save file.
+
+    """
+    STORAGE_DIR = _get_platform_pgzero_path()
+
+    # Keep a reference to all defined storages
+    storages = []
+
+    def __init__(self, filename=None):
+        super().__init__()
+        self.loaded = False
+        self._save_file = filename
+        self.storages.append(self)
+
+    @classmethod
+    def save_all(cls):
+        """Save all instances of Storage."""
+        cls._ensure_save_path()
+        for storage in cls.storages:
+            storage.save()
+
+    @classmethod
+    def _ensure_save_path(cls):
+        """Ensure that the directory for all save game data exists."""
+        try:
+            os.makedirs(cls.STORAGE_DIR)
+        except (IsADirectoryError, PermissionError):
+            pass
+        except FileExistsError:
+            pass
+
+    def _set_filename_from_path(self, file_path):
+        """Set the path to save to from the given filename.
+
+        We include the basename of the game script, to help with identifying
+        the save data, as well as the sha1 hash of the full path of the file on
+        disk, to ensure that every separate game has its own storage.
+
+        """
+        if not os.path.isabs(file_path):
+            file_path = os.path.abspath(file_path)
+
+        fn_hash = sha1(file_path.encode('utf-8')).hexdigest()
+        base, _ = os.path.splitext(os.path.basename(file_path))
+        self._save_file = '{}-{}.json'.format(base, fn_hash)
+        self.load()
+
+    @property
+    def path(self):
+        """Get the path for data data."""
+        if self._save_file is None:
+            raise ValueError(
+                "Cannot save/load storage as no filename is set."
+            )
+        return os.path.join(self.STORAGE_DIR, self._save_file)
+
+    def load(self):
+        """Load data into the storage from disk.
+
+        This replaces all previous contents of the storage. If there is no save
+        file found then the storage will be empty.
+
+        """
+        self.clear()
+
+        try:
+            with open(self.path, 'r') as f:
+                data = json.load(f)
+        except FileNotFoundError:
+            # If no file exists, it's fine
+            pass
+        except json.JSONDecodeError:
+            raise StorageCorruptionException(
+                "Storage is corrupted. Couldn't load the data."
+            )
+        else:
+            self.update(data)
+            self.loaded = True
+
+    def save(self):
+        """Save data to disk."""
+        if not self and not self.loaded:
+            return
+        try:
+            data = json.dumps(self)
+        except TypeError:
+            msgs = [
+                "{} - type {}".format(*item)
+                for item in self._get_json_error_keys(self)
+            ]
+            if not msgs:
+                # Didn't find an explanation, so let original error propagate
+                raise
+            raise JSONEncodingException(
+                "The following storage entries cannot be stored, because "
+                "they are not JSON serializable types:\n{}\n\n"
+                "Only the following types of objects are JSON-serialisable: "
+                "dict, list/tuple, str, float/int, bool, and None".format(
+                    "\n".join(msgs)
+                )
+            )
+        else:
+            path = self.path
+            with open(path, 'w+') as f:
+                f.write(data)
+            print("Saved storage to", path)
+
+    # Constants for use with isinstance in _get_json_error_keys()
+    JSON_PRIMITIVES = (float, int, str, bool, type(None))
+    JSON_SEQ = (list, tuple)
+    JSON_MAPPING = dict
+
+    @classmethod
+    def _get_json_error_keys(cls, obj, json_path='storage'):
+        """Identify the paths with the storage which failed to be JSON encoded.
+
+        Return an iterable of message strings.
+
+        """
+        if isinstance(obj, dict):
+            # TODO: also check/report that k is a string, as only strings are
+            # valid as object keys in JSON.
+            for k, v in obj.items():
+                if isinstance(v, cls.JSON_PRIMITIVES):
+                    continue
+                subpath = '{}[{!r}]'.format(json_path, k)
+                yield from cls._get_json_error_keys(v, subpath)
+        elif isinstance(obj, (list, tuple)):
+            for i, value in enumerate(obj):
+                if isinstance(value, cls.JSON_PRIMITIVES):
+                    continue
+                subpath = '{}[{}]'.format(json_path, i)
+                yield from cls._get_json_error_keys(value, subpath)
+        elif isinstance(obj, cls.JSON_PRIMITIVES):
+            return
+        else:
+            # TODO: Could have a custom JSONEncoder in the future, in which
+            # case we would have to actually run json.dumps on it to get the
+            # result and possibly even drill down on the parameters we got
+            # back, if that object happens to have a list as an attribute, for
+            # example.
+            t = type(obj)
+            if t.__module__ != 'builtins':
+                typename = '{t.__module__}.{t.__qualname__}'.format(t=t)
+            else:
+                typename = t.__qualname__
+            yield json_path, typename
+
+
+storage = Storage()