Clean up code and fix type annotations

Author: CoolCat467

.gitignore

@@ -0,0 +1,135 @@
+# Saved example model
+AI_Data.json
+
+# Binaries from virtual environment
+bin/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/

Vector2.py

@@ -1,91 +1,104 @@
 #!/usr/bin/env python3
+# -*- coding: utf-8 -*-
 # Vector2 Class for games
-# Original version by Will McGugan, modified extensively by CoolCat467
 
-from math import sqrt
+# Created by Will McGugan, modified extensively by CoolCat467
+
+from __future__ import annotations
 
-__title__ = 'Vector2'
-__author__ = 'CoolCat467 & Will McGugan'
-__version__ = '0.1.0'
+__title__ = "Vector2"
+__author__ = "CoolCat467 & Will McGugan"
+__version__ = "0.2.0"
 __ver_major__ = 0
-__ver_minor__ = 1
+__ver_minor__ = 2
 __ver_patch__ = 0
 
-class Vector2(object):
-    __slots__ 'x', 'y'
-    def __init__(self, x=0, y=0):
+from math import sqrt
+from typing import Any, Iterable, Iterator
+
+
+class Vector2:
+    """Vector with X and Y component"""
+
+    __slots__ = ("x", "y")
+
+    def __init__(
+        self,
+        x: int | float | list[int | float] | tuple[int | float, int | float] = 0,
+        y: int | float = 0,
+    ) -> None:
         if isinstance(x, (list, tuple)):
             x, y = x
         self.x = x
         self.y = y
-    
-    def __str__(self):
-        return f'({self.x}, {self.y})'
-    
-    def __repr__(self):
-        x, y = self.x, self.y
-        return f'Vector2({self.x}, {self.y})'
-    
-    @staticmethod
-    def from_points(frompoint, topoint):
-        """Return a vector with the direction of frompoint to topoint"""
-        P1, P2 = list(frompoint), list(topoint)
-        return self.__class__(P2[0] - P1[0], P2[1] - P1[1])
-    
-    def get_magnitude(self):
+
+    def __str__(self) -> str:
+        return f"({self.x}, {self.y})"
+
+    def __repr__(self) -> str:
+        return f"Vector2({self.x}, {self.y})"
+
+    @classmethod
+    def from_points(
+        cls, frompoint: Iterable[int | float] | "Vector2", topoint: "Vector2"
+    ) -> Any:
+        """Return a vector with the direction of from point to to point"""
+        p1, p2 = list(frompoint), list(topoint)
+        return cls(p2[0] - p1[0], p2[1] - p1[1])
+
+    def get_magnitude(self) -> float:
         """Return the magnitude (length) of the vector"""
         return sqrt(self.x**2 + self.y**2)
-    
-    def get_distance_to(self, point):
+
+    def get_distance_to(self, point: Iterable[int | float] | "Vector2") -> float:
         """Get the magnitude to a point"""
-        return self.__class__.from_points(point, self).get_magnitude()
-    
-    def normalize(self):
-        """Normalize self (make into a unit vector)"""
+        vec: "Vector2" = self.__class__.from_points(point, self)
+        return vec.get_magnitude()
+
+    def normalize(self) -> None:
+        """Normalize self (make into a unit vector) **IN PLACE**"""
         magnitude = self.get_magnitude()
         if not magnitude == 0:
             self.x /= magnitude
             self.y /= magnitude
-    
-    def copy(self):
+
+    def __copy__(self) -> "Vector2":
         """Make a copy of self"""
         return self.__class__(self.x, self.y)
-    
-    def __copy__(self):
-        return self.copy()
-    
-    def get_normalized(self):
+
+    copy = __copy__
+
+    def get_normalized(self) -> "Vector2":
         """Return a normalized vector (heading)"""
         vec = self.copy()
         vec.normalize()
         return vec
-    
-    #rhs is Right Hand Side
-    def __add__(self, rhs):
+
+    # rhs is Right Hand Side
+    def __add__(self, rhs: "Vector2") -> "Vector2":
         return self.__class__(self.x + rhs.x, self.y + rhs.y)
-    
-    def __sub__(self, rhs):
+
+    def __sub__(self, rhs: "Vector2") -> "Vector2":
         return self.__class__(self.x - rhs.x, self.y - rhs.y)
-    
-    def __neg__(self):
+
+    def __neg__(self: "Vector2") -> "Vector2":
         return self.__class__(-self.x, -self.y)
-    
-    def __mul__(self, scalar):
+
+    def __mul__(self, scalar: int | float) -> "Vector2":
         return self.__class__(self.x * scalar, self.y * scalar)
-    
-    def __truediv__(self, scalar):
+
+    def __truediv__(self, scalar: int | float) -> "Vector2":
         try:
             x, y = self.x / scalar, self.y / scalar
         except ZeroDivisionError:
             x, y = self.x, self.y
         return self.__class__(x, y)
-    
-    def __len__(self):
+
+    def __len__(self) -> int:
         return 2
-    
-    def __iter__(self):
+
+    def __iter__(self) -> Iterator[int | float]:
         return iter([self.x, self.y])
-    
-    def __getitem__(self, idx):
-        return [self.x, self.y][idx]
-    pass
+
+    def __getitem__(self, idx: int) -> int | float:
+        return (self.x, self.y)[idx]