Merge branch 'bugfix_player_from_userid' into cached_property

Author: jordanbriere

addons/source-python/packages/source-python/entities/_base.py

@@ -54,6 +54,8 @@
 from listeners import OnEntityDeleted
 from listeners import on_entity_deleted_listener_manager
 from listeners.tick import Delay
+from listeners.tick import Repeat
+from listeners.tick import RepeatStatus
 #   Mathlib
 from mathlib import NULL_VECTOR
 #   Memory
@@ -75,6 +77,9 @@
 # Get a dictionary to store the delays
 _entity_delays = defaultdict(set)
 
+# Get a dictionary to store the repeats
+_entity_repeats = defaultdict(set)
+
 # Get a set to store the registered entity classes
 _entity_classes = WeakSet()
 
@@ -92,11 +97,13 @@ def __init__(cls, classname, bases, attributes):
 
         # Set whether or not this class is caching its instances by default
         try:
-            cls._caching = signature(
-                cls.__init__
-            ).parameters['caching'].default
+            cls._caching = bool(
+                signature(
+                    vars(cls)['__init__']
+                ).parameters['caching'].default
+            )
         except KeyError:
-            cls._caching = True
+            cls._caching = bool(vars(cls).get('caching', False))
 
         # Add the class to the registered classes
         _entity_classes.add(cls)
@@ -331,14 +338,16 @@ def find_or_create(cls, classname):
         return entity
 
     @classmethod
-    def from_inthandle(cls, inthandle):
+    def from_inthandle(cls, inthandle, caching=None):
         """Create an entity instance from an inthandle.
 
         :param int inthandle:
             The inthandle.
+        :param bool caching:
+            Whether to lookup the cache for an existing instance or not.
         :rtype: Entity
         """
-        return cls(index_from_inthandle(inthandle))
+        return cls(index_from_inthandle(inthandle), caching=caching)
 
     @classmethod
     def _obj(cls, ptr):
@@ -941,7 +950,7 @@ def _set_property(self, name, prop_type, value):
     def delay(
             self, delay, callback, args=(), kwargs=None,
             cancel_on_level_end=False):
-        """Execute a callback after the given delay.
+        """Create the delay which will be stopped after removing the entity.
 
         :param float delay:
             The delay in seconds.
@@ -984,6 +993,34 @@ def _callback(*args, **kwargs):
         # Return the delay instance...
         return delay
 
+    def repeat(
+            self, callback, args=(), kwargs=None,
+            cancel_on_level_end=False):
+        """Create the repeat which will be stopped after removing the entity.
+        :param callback:
+            A callable object that should be called at the end of each loop.
+        :param tuple args:
+            Arguments that should be passed to the callback.
+        :param dict kwargs:
+            Keyword arguments that should be passed to the callback.
+        :param bool cancel_on_level_end:
+            Whether or not to cancel the delay at the end of the map.
+        :raise ValueError:
+            Raised if the given callback is not callable.
+        :return:
+            The repeat instance.
+        :rtype: Repeat
+        """
+
+        # Get the repeat instance...
+        repeat = Repeat(callback, args, kwargs, cancel_on_level_end)
+
+        # Add the repeat to the dictionary...
+        _entity_repeats[self.index].add(repeat)
+
+        # Return the repeat instance...
+        return repeat
+
     def get_output(self, name):
         """Return the output instance matching the given name.
 
@@ -1263,13 +1300,22 @@ def _on_entity_deleted(base_entity):
     except ValueError:
         return
 
-    with suppress(KeyError):
-        # Loop through all delays...
-        for delay in _entity_delays[index]:
+    # Get the registered delays for this entity
+    delays = _entity_delays.pop(index, ())
 
-            # Cancel the delay...
-            with suppress(ValueError):
-                delay.cancel()
+    # Loop through all delays...
+    for delay in delays:
+
+        # Cancel the delay...
+        with suppress(ValueError):
+            delay.cancel()
+
+    # Get the registered repeats for this entity
+    repeats = _entity_repeats.pop(index, ())
+
+    # Loop through all repeats...
+    for repeat in repeats:
 
-        # Remove the entity from the dictionary...
-        del _entity_delays[index]
+        # Stop the repeat if running
+        if repeat.status is RepeatStatus.RUNNING:
+            repeat.stop()

addons/source-python/packages/source-python/players/_base.py

@@ -92,14 +92,16 @@ def __init__(self, index, caching=True):
         Entity.__init__(self, index)
 
     @classmethod
-    def from_userid(cls, userid):
+    def from_userid(cls, userid, caching=None):
         """Create an instance from a userid.
 
         :param int userid:
             The userid.
+        :param bool caching:
+            Whether to lookup the cache for an existing instance or not.
         :rtype: Player
         """
-        return cls(index_from_userid(userid))
+        return cls(index_from_userid(userid), caching=caching)
 
     @cached_property
     def net_info(self):