I screwed up, I meant to do it on https://github.com/pythonarcade/arcade/pull/1720 but I did it on the wrong branch.

arcade/gui/property.py

@@ -1,6 +1,6 @@
 import sys
 import traceback
-from typing import TypeVar
+from typing import TypeVar, Callable, Any
 from weakref import WeakKeyDictionary, ref
 
 
@@ -11,10 +11,10 @@ class _Obs:
 
     __slots__ = "value", "listeners"
 
-    def __init__(self):
-        self.value = None
+    def __init__(self) -> None:
+        self.value: Optional[Any] = None
         # This will keep any added listener even if it is not referenced anymore and would be garbage collected
-        self.listeners = set()
+        self.listeners: Set[Callable] = set()
 
 
 P = TypeVar("P")
@@ -31,32 +31,32 @@ class Property:
     __slots__ = "name", "default_factory", "obs"
     name: str
 
-    def __init__(self, default=None, default_factory=None):
+    def __init__(self, default: Any=None, default_factory: Callable=None) -> None:
         if default_factory is None:
             default_factory = lambda prop, instance: default
 
         self.default_factory = default_factory
-        self.obs = WeakKeyDictionary()
+        self.obs: [WeakKeyDictionary[object: _Obs]] = WeakKeyDictionary()
 
-    def _get_obs(self, instance) -> _Obs:
-        obs = self.obs.get(instance)
+    def _get_obs(self, instance: Any) -> _Obs:
+        obs: _Obs = self.obs.get(instance)
         if obs is None:
             obs = _Obs()
             obs.value = self.default_factory(self, instance)
             self.obs[instance] = obs
         return obs
 
-    def get(self, instance):
+    def get(self, instance: Any) -> Any:
         obs = self._get_obs(instance)
         return obs.value
 
-    def set(self, instance, value):
+    def set(self, instance: Any, value: Any) -> None:
         obs = self._get_obs(instance)
         if obs.value != value:
             obs.value = value
             self.dispatch(instance, value)
 
-    def dispatch(self, instance, value):
+    def dispatch(self, instance: Any, value: Any) -> None:
         obs = self._get_obs(instance)
         for listener in obs.listeners:
             try:
@@ -68,25 +68,25 @@ def dispatch(self, instance, value):
                 )
                 traceback.print_exc()
 
-    def bind(self, instance, callback):
-        obs = self._get_obs(instance)
+    def bind(self, instance: Any, callback: Callable) -> None:
+        obs: _Obs = self._get_obs(instance)
         # Instance methods are bound methods, which can not be referenced by normal `ref()`
         # if listeners would be a WeakSet, we would have to add listeners as WeakMethod ourselves into `WeakSet.data`.
         obs.listeners.add(callback)
 
-    def __set_name__(self, owner, name):
+    def __set_name__(self, owner, name: str) -> None:
         self.name = name
 
-    def __get__(self, instance, owner):
+    def __get__(self, instance: Any, owner) -> Any:
         if instance is None:
             return self
         return self.get(instance)
 
-    def __set__(self, instance, value):
+    def __set__(self, instance: Any, value: Any) -> None:
         self.set(instance, value)
 
 
-def bind(instance, property: str, callback):
+def bind(instance, property: str, callback: Callable) -> None:
     """
     Binds a function to the change event of the property. A reference to the function will be kept,
     so that it will be still invoked, even if it would normally have been garbage collected.
@@ -116,41 +116,41 @@ class MyObject:
 
 class _ObservableDict(dict):
     # Internal class to observe changes inside a native python dict.
-    def __init__(self, prop: Property, instance, *largs):
+    def __init__(self, prop: Property, instance: Dict, *largs: list) -> None:
         self.prop: Property = prop
         self.obj = ref(instance)
         super().__init__(*largs)
 
-    def dispatch(self):
+    def dispatch(self) -> None:
         self.prop.dispatch(self.obj(), self)
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key: Any, value: Any) -> None:
         dict.__setitem__(self, key, value)
         self.dispatch()
 
-    def __delitem__(self, key):
+    def __delitem__(self, key: Any) -> None:
         dict.__delitem__(self, key)
         self.dispatch()
 
-    def clear(self):
+    def clear(self) -> None:
         dict.clear(self)
         self.dispatch()
 
-    def pop(self, *largs):
+    def pop(self, *largs: list) -> Any:
         result = dict.pop(self, *largs)
         self.dispatch()
         return result
 
-    def popitem(self):
+    def popitem(self) -> Any:
         result = dict.popitem(self)
         self.dispatch()
         return result
 
-    def setdefault(self, *largs):
+    def setdefault(self, *largs: list) -> None:
         dict.setdefault(self, *largs)
         self.dispatch()
 
-    def update(self, *largs):
+    def update(self, *largs: list) -> None:
         dict.update(self, *largs)
         self.dispatch()
 
@@ -161,72 +161,72 @@ class DictProperty(Property):
     Only dict are allowed. Any other classes are forbidden.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(default_factory=_ObservableDict)
 
-    def set(self, instance, value: dict):
+    def set(self, instance: Any, value: dict) -> None:
         value = _ObservableDict(self, instance, value)
         super().set(instance, value)
 
 
 class _ObservableList(list):
     # Internal class to observe changes inside a native python list.
-    def __init__(self, prop: Property, instance, *largs):
+    def __init__(self, prop: Property, instance: list, *largs: list) -> None:
         self.prop: Property = prop
         self.obj = ref(instance)
         super().__init__(*largs)
 
-    def dispatch(self):
+    def dispatch(self) -> None:
         self.prop.dispatch(self.obj(), self)
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key: Any, value: list) -> None:
         list.__setitem__(self, key, value)
         self.dispatch()
 
-    def __delitem__(self, key):
+    def __delitem__(self, key: Any) -> None:
         list.__delitem__(self, key)
         self.dispatch()
 
-    def __iadd__(self, *largs):  # type: ignore
+    def __iadd__(self, *largs: list) -> _ObservableList:  # type: ignore
         list.__iadd__(self, *largs)
         self.dispatch()
         return self
 
-    def __imul__(self, *largs):  # type: ignore
+    def __imul__(self, *largs: list) -> _ObservableList:  # type: ignore
         list.__imul__(self, *largs)
         self.dispatch()
         return self
 
-    def append(self, *largs):
+    def append(self, *largs: list) -> None:
         list.append(self, *largs)
         self.dispatch()
 
-    def clear(self):
+    def clear(self) -> None:
         list.clear(self)
         self.dispatch()
 
-    def remove(self, *largs):
+    def remove(self, *largs: list) -> None:
         list.remove(self, *largs)
         self.dispatch()
 
-    def insert(self, *largs):
+    def insert(self, *largs: list) -> None:
         list.insert(self, *largs)
         self.dispatch()
 
-    def pop(self, *largs):
+    def pop(self, *largs: list) -> None:
         result = list.pop(self, *largs)
         self.dispatch()
         return result
 
-    def extend(self, *largs):
+    def extend(self, *largs: list) -> None:
         list.extend(self, *largs)
         self.dispatch()
 
-    def sort(self, **kwargs):
+    def sort(self, **kwargs: dict) -> None:
         list.sort(self, **kwargs)
         self.dispatch()
 
-    def reverse(self):
+    def reverse(self) -> None:
         list.reverse(self)
         self.dispatch()
 
@@ -237,9 +237,9 @@ class ListProperty(Property):
     Only list are allowed. Any other classes are forbidden.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(default_factory=_ObservableList)
 
-    def set(self, instance, value: dict):
+    def set(self, instance: Any, value: dict):
         value = _ObservableList(self, instance, value)  # type: ignore
         super().set(instance, value)

arcade/scene.py

@@ -277,7 +277,7 @@ def remove_sprite_list_by_name(
 
     def remove_sprite_list_by_object(self, sprite_list: SpriteList) -> None:
         """
-        Remove a SpriteList by object.
+        Remove a SpriteList from the Scene.
 
         This function serves to completely remove the SpriteList from the Scene.