Merge pull request #14 from codeasarjun/deco

Deco

Author: codeasarjun

additional-materials/decorators/README.md

@@ -0,0 +1,43 @@
+## What is a Decorator?
+
+A decorator is a special type of function that takes another function as an argument and extends or alters its behavior. This is achieved by defining a wrapper function inside the decorator that wraps around the original function. Decorators are commonly used for:
+
+- **Logging:** Automatically log function calls, arguments, and results.
+- **Timing:** Measure the execution time of functions.
+- **Authentication:** Restrict access to functions based on user credentials.
+- **Caching:** Store and retrieve results of expensive function calls to improve performance.
+- **Rate Limiting:** Control how frequently a function can be called.
+
+## Why Use Decorators?
+
+Decorators offer several benefits:
+
+- **Code Reusability:** Define functionality once and apply it to multiple functions or methods.
+- **Separation of Concerns:** Keep the core logic of functions separate from cross-cutting concerns like logging or authentication.
+- **Maintainability:** Easier to modify or extend functionality without changing the original function code.
+- **Readability:** Enhances the readability and organization of your code.
+
+## File Descriptions
+
+### `decorators_example.py`
+
+This file contains various decorator implementations.
+
+- **`log_function_call`**: Logs details of function calls, including arguments and results.
+- **`timing_decorator`**: Measures and prints the execution time of functions.
+- **`requires_authentication`**: Restricts access to functions based on user authentication status.
+- **`cache_results`**: Caches function results to improve performance.
+- **`rate_limit`**: Limits the frequency of function calls to prevent rate limiting issues.
+
+
+## dec_call_functions.py
+
+This file contains functions that utilize the decorators from `decorators_example.py`. It demonstrates how to apply various decorators to functions to enhance their functionality.
+
+- **add:** A simple function to add two numbers, with logging applied.
+- **compute_square:** Computes the square of numbers up to `n`, with timing applied.
+- **view_profile:** Displays a user profile if authenticated, with authentication applied.
+- **fibonacci:** Computes the Fibonacci sequence, with result caching applied.
+- **fetch_data:** Retrieves data with rate limiting applied.
+
+

additional-materials/decorators/__pycache__/dec_call_functions.cpython-39.pyc

@@ -0,0 +1,24 @@
+
+from decorators_example import log_function_call, timing_decorator, requires_authentication, cache_results, rate_limit
+
+@log_function_call
+def add(a, b):
+    return a + b
+
+@timing_decorator
+def compute_square(n):
+    return [i ** 2 for i in range(n)]
+
+@requires_authentication
+def view_profile(user):
+    return f"Welcome to your profile, {user['name']}!"
+
+@cache_results
+def fibonacci(n):
+    if n <= 1:
+        return n
+    return fibonacci(n - 1) + fibonacci(n - 2)
+
+@rate_limit(max_calls=1, period=5)
+def fetch_data():
+    return "Data fetched successfully!"

additional-materials/decorators/__pycache__/decorators_example.cpython-39.pyc

@@ -0,0 +1,60 @@
+# decorators.py
+
+import time
+import logging
+from functools import wraps
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+
+def log_function_call(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        logging.info(f"Calling function '{func.__name__}' with arguments {args} and keyword arguments {kwargs}")
+        result = func(*args, **kwargs)
+        logging.info(f"Function '{func.__name__}' returned {result}")
+        return result
+    return wrapper
+
+def timing_decorator(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        result = func(*args, **kwargs)
+        end_time = time.time()
+        execution_time = end_time - start_time
+        print(f"Function '{func.__name__}' took {execution_time:.4f} seconds to execute")
+        return result
+    return wrapper
+
+def requires_authentication(func):
+    @wraps(func)
+    def wrapper(user, *args, **kwargs):
+        if not user.get('authenticated'):
+            return "Access Denied: User not authenticated"
+        return func(user, *args, **kwargs)
+    return wrapper
+
+def cache_results(func):
+    cache = {}
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        if args in cache:
+            return cache[args]
+        result = func(*args, **kwargs)
+        cache[args] = result
+        return result
+    return wrapper
+
+def rate_limit(max_calls, period):
+    def decorator(func):
+        last_called = [0]
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            current_time = time.time()
+            if current_time - last_called[0] < period:
+                return "Rate limit exceeded. Please try again later."
+            last_called[0] = current_time
+            return func(*args, **kwargs)
+        return wrapper
+    return decorator

additional-materials/decorators/dec_call_functions.py

@@ -0,0 +1,16 @@
+import time
+from dec_call_functions import add, compute_square, view_profile, fibonacci, fetch_data
+
+if __name__ == "__main__":
+    print(add(5, 7))
+    compute_square(1000000)
+    user1 = {'name': 'Alice', 'authenticated': True}
+    user2 = {'name': 'Bob', 'authenticated': False}
+    print(view_profile(user1))
+    print(view_profile(user2))
+    print(fibonacci(10))
+    print(fetch_data())
+    time.sleep(3)
+    print(fetch_data())
+    time.sleep(5)
+    print(fetch_data())