API

pytimer

Table of Contents

• pytimer.PyTimer

  • PyTimer.microseconds
  • PyTimer.milliseconds
  • PyTimer.nanoseconds
  • PyTimer.rounding
  • PyTimer.seconds
  • PyTimer.elapsed() (static)
  • PyTimer.time_it() (static)
  • PyTimer.average()
  • PyTimer.averages()
  • PyTimer.decorator()
  • PyTimer.deviation()
  • PyTimer.deviations()
  • PyTimer.display_average()
  • PyTimer.display_averages()
  • PyTimer.display_deviation()
  • PyTimer.display_deviations()
  • PyTimer.display_overall_time()
  • PyTimer.display_split()
  • PyTimer.display_splits()
  • PyTimer.log()
  • PyTimer.overall_time()
  • PyTimer.pause()
  • PyTimer.reset()
  • PyTimer.resume()
  • PyTimer.setup_decorator()
  • PyTimer.split()
  • PyTimer.start()
  • PyTimer.time()
  • PyTimer.times()
  • PyTimer.write_output()

• PyTimer

  PyTimer is a class for easily timing execution of sections of codes. PyTimer supports splitting to allow different segments of code to be timed separately.

  • Constants

    • microseconds = us
    • milliseconds = ms
    • nanoseconds = ns
    • rounding = 4
    • seconds = s

  • Static Methods

    • elapsed(display=True, message="")]

      Allows the elapsed time to be easily checked using repeated calls to this. There must be an initial call that gets the start time.

      • display (optional): whether to display the elapsed time, or to return it as a value
      • message (optional): if display==True, this message will be attached with the output that is displayed

    • time_it(block, *args, reps=1, iterations=10, display=True, message="", **kwargs)]

      A static method that allows timing a function or string of code without creating a PyTimer object

      • block: either a callable, or a string
      • args: any positional arguments to be passed into block if it is a function
      • reps (optional): the number of reps for each iteration
      • iterations (optional): the number of iterations to average together
      • display (optional): if True, then display the calculated time, else, return the value
      • message (optional): if display==True, then this message will be displayed with the calculated value
      • kwargs: any keyword arguments to be passed into block if it is a function

  • Methods

    • average(self, i)]

      Calculates average for split i

      • i: Index of split to determine average for

    • averages(self)]

      Returns list of averages for every split

    • decorator(self, func)]

      Returns a decorator so that functions can be timed with having to use evaluate, but functions can't take any parameters

      • func: takes a function as a parameter

    • deviation(self, i)]

      Calculates standard deviation for split i

      • i: split index

    • deviations(self)]

      Calculates standard deviations for every split

    • display_average(self, i)]

      Display average for split i if valid index and split is not empty, otherwise displays appropriate message

      • i: split index

    • display_averages(self)]

      Display averages for all splits unless split i is empty, in which case it is skipped

    • display_deviation(self, i)]

      Display standard deviation for split i if valid index and split is not empty, otherwise displays appropriate message

      • i: split index

    • display_deviations(self)]

      Display standard deviation for all splits unless split is empty, in which case that split is skipped

    • display_overall_time(self)]

      Display time since last start() or reset(). This time includes that time taken to execute PyTimer method calls

    • display_split(self, i)]

      Display all values in split i if valid index and split is not empty, otherwise displays appropriate message

      • i: split index

    • display_splits(self)]

      Display all values for all splits unless split is empty, in which case the split is skipped

    • log(self, message="")]

      Log elapsed time, log will have no affect if timer is paused

      • message (optional): optional: store message with the log

    • overall_time(self)]

    • pause(self)]

      Pause the timer, meaning no actions can be performed, allows portions of code to be skipped

    • reset(self)]

      Clear the timer back to its defaults

    • resume(self)]

      Resume the timer from being paused, updates the internal clock to the current time

    • setup_decorator(self, reps=1, iterations=10)]

      Allow decorator to run function for multiple reps and iterations

      • reps (optional): number of times to run the function before logging the time
      • iterations (optional): number of times to calculate the time

    • split(self, message="")]

      • message (optional):

    • start(self)]

    • time(self, block, *args, reps=10, iterations=10, split_message="", **kwargs)]

      Times a string of code or a function and times how long it takes for each iteration. If block is a function, then parameters can be passed to it like so: time(bar, "something", 12, iterations=100) -> bar("something", 12). No error checking is done, meaning any error that is raised within block will crash the entire program.

      • block: either function or string of code
      • args: any arguments that needs to be passed into block if block is a function
      • reps (optional): number of reps to run the block before log is called
      • iterations (optional): number of times to run rep number of times
      • split_message (optional): the message that will be recorded with this split
      • kwargs: keyword arguments that will be passed into block if it is a function

    • times(self, i)]

      Return list of elapsed times for split i

      • i: index of split

    • write_output(self, folder_path, basename, file_per_run=False)]

      Write all collected output to a file, assuming that _collect_output was set in constructor. File is either written to folder_path + basename if file_per_run is false or folder_path + basename + date_time where date_time is formatted "-day-month-year-hours-minutes-seconds". All files are written to .txt format

      • folder_path: Path of folder to write to
      • basename: Name of file
      • file_per_run (optional): Create a new file with every run