#!/usr/bin/env python
# coding: utf-8

# # Timer
# 
# The code in this notebook helps with measuring time.

# **Prerequisites**
# 
# * This notebook needs some understanding on advanced concepts in Python, notably 
#     * classes
#     * the Python `with` statement
#     * measuring time

# ## Synopsis
# <!-- Automatically generated. Do not edit. -->
# 
# To [use the code provided in this chapter](Importing.ipynb), write
# 
# ```python
# >>> from fuzzingbook.Timer import <identifier>
# ```
# 
# and then make use of the following features.
# 
# 
# The `Timer` class allows you to measure elapsed real time (in fractional seconds).  Its typical usage is in conjunction with a `with` clause:
# 
# ```python
# >>> with Timer() as t:
# >>>     some_long_running_function()
# >>> t.elapsed_time()
# 0.024238083002273925
# ```
# 

# ## Measuring Time
# 
# The class `Timer` allows measuring the elapsed time during some code execution.

# In[1]:


import bookutils.setup


# In[2]:


import time


# In[3]:


# ignore
from typing import Type, Any


# In[4]:


def clock() -> float:
    """
    Return the number of fractional seconds elapsed since some point of reference.
    """
    return time.perf_counter()


# In[5]:


from types import TracebackType


# In[6]:


class Timer:
    def __init__(self) -> None:
        """Constructor"""
        self.start_time = clock()
        self.end_time = None

    def __enter__(self) -> Any:
        """Begin of `with` block"""
        self.start_time = clock()
        self.end_time = None
        return self

    def __exit__(self, exc_type: Type, exc_value: BaseException,
                 tb: TracebackType) -> None:
        """End of `with` block"""
        self.end_time = clock()  # type: ignore

    def elapsed_time(self) -> float:
        """Return elapsed time in seconds"""
        if self.end_time is None:
            # still running
            return clock() - self.start_time
        else:
            return self.end_time - self.start_time  # type: ignore


# Here's an example:

# In[7]:


def some_long_running_function() -> None:
    i = 1000000
    while i > 0:
        i -= 1


# In[8]:


print("Stopping total time:")
with Timer() as t:
    some_long_running_function()
print(t.elapsed_time())


# In[9]:


print("Stopping time in between:")
with Timer() as t:
    for i in range(10):
        some_long_running_function()
        print(t.elapsed_time())


# That's it, folks – enjoy!

# ## Synopsis
# 
# The `Timer` class allows you to measure elapsed real time (in fractional seconds).  Its typical usage is in conjunction with a `with` clause:

# In[10]:


with Timer() as t:
    some_long_running_function()
t.elapsed_time()


# ## Lessons Learned
# 
# * With the `Timer` class, it is very easy to measure elapsed time.