We can take advantage of the fact that integers cannot overflow in Python to construct a conditionally infinite loop. We still have some work to do, since the function is basically doing the same thing in two different places. def repeat_call(func: Callable, interval_ms: int, n_times: int = None) -> None: Depending on the final limit we either check for stopping or never stop. Instead, we can wait for a certain period of time and repeat. If you insert a print statement to your while loop, you can see that it runs a bunch of times without calling the function. In this case it isn't, but there's a much better way of doing it. Now all that's left is defining the function body, which can be arbitrarily complicated. This becomes our starting point when we define a function. What does the user of the function choose, versus us that write it? From your question we can gather that the user chooses a callable, the interval and maybe whether it is called indefinitely or stopped at some point. Let's employ a bit of design to construct our function. The difference between the two classes is that you can't have multiple of the latter because of the class attribute and So even if you made multiple instance of the class, they'd all share that value. If milliseconds - cls.last_milliseconds >= interval: Last_milliseconds = set(cls, interval: int, function: Callable) -> None: First, we can create an instance of the timer and configure it.
It provides a useful way to execute a function after an interval of time. The threading.Timer is an extension of the threading.Thread class, meaning that we can use it just like a normal thread instance.
Or, even better, you can have a static class if your workflow allows it: class StaticTimer: Python provides a timer thread in the threading.Timer class. If milliseconds - self.last_milliseconds >= interval: Strictly speaking about the implementation, if you're not tied to using a function and want to get rid of the usage of global, I'd use a class: from time import timeĭef set(self, interval: int, function: Callable) -> None: You can also remove the parentheses from your condition since - has a higher precedence than >=. If milliseconds - last_milliseconds >= interval: The done variable can also be omitted and added directly to the condition itself: def set_timer(interval: int, function: Callable) -> None: More, round() already returns an int in your case so that can be removed as well. This is subjective and it's just my personal preference but I usually tend to use type annotations only when dealing with function / class definitions and their arguments.įor example, milliseconds: int = int(round(time.time() * 1000)) it's obviously going to be an integer since we can see the cast to int().
Timer function python code#
Still related to type annotations, I find it kinda hard to read your code with annotations everywhere. You can either use -> None or use nothing at all.
Timer function python how to#
This will hopefully eliminate, Rhino crashes from the object move being called too quickly for Rhino to keep up with.First of all, your function doesn't return anything and so you can remove -> bool since it only creates confusion. How to use Python time.time() for Timer The time function in the Python time module returns a number of seconds that have passed since the last defined epoch.
1 seconds in the same location, then the objects will be moved in Rhino to the current position. This would allow the script to restart the timer every time the event is called, then if the timer reaches, say. I feel like a viable solution to this problem would having the .ValueChanged() event begin a timer on a separate thread removed from the main script thread. I have a general idea of what I need to do but as of yet I have been unsuccessful in implementing a working situation.
When Rhino is unable to keep up with the change of the TrackBar, Rhino inevitably crashes. In this situation the TrackBar.Value may have changed from 1 to 100 in the space of 1 second in increments of one. However this becomes a problem when a more complicated script is called by the event, for example when the user is “scrubbing” across the TrackBar. This method works fine when doing simple operations like print. Whenever the .ValueChanged() event is triggered it will run all the way whatever code is called by the event. My current script has all it functions on the same main thread. The script moves several rhino object to various positions depending on the position of the TrackBar. I am working on a python script that is animated by positioning a ()
0 kommentar(er)
