Added the Decorator code files

sreekanthpogula · sreekanthpogula · commit 2c44bb9b8a26 · 2023-03-27T11:53:38.000+05:30
diff --git a/access_control_decorators.py b/access_control_decorators.py
@@ -0,0 +1,95 @@
+# Define a decorator function that takes a function as input
+def login_required(func):
+    # Define a new function that wraps the original function
+    def wrapper(*args, **kwargs):
+        # Check if the user is logged in
+        if user_is_logged_in():
+            # If the user is logged in, call the original function
+            return func(*args, **kwargs)
+        else:
+            # If the user is not logged in, raise an exception or redirect to login page
+            raise Exception("User not logged in")
+    # Return the new function
+    return wrapper
+
+# Define a function that requires login
+@login_required
+def do_something_secure():
+    # This function can only be called if the user is logged in
+    pass
+
+def delete_account(user_id):
+    if current_user_id() == user_id:
+        delete_user_account(user_id)
+    else:
+        raise Exception("You can only delete your own account")
+    
+# Define a global variable to store the current user ID
+current_user = None
+
+# Define a function to log in a user
+def login(user_id):
+    global current_user
+    current_user = user_id
+
+# Define a function to log out the current user
+def logout():
+    global current_user
+    current_user = None
+
+# Define a function to check if the user is logged in
+def user_is_logged_in():
+    global current_user
+    return current_user is not None
+
+# Define a function to get the ID of the currently logged in user
+def current_user_id():
+    global current_user
+    return current_user
+
+# Define a function to delete a user account
+def delete_user_account(user_id):
+    global current_user
+    if current_user == user_id:
+        print(f"Deleting user account with ID {user_id}")
+        current_user = None
+    else:
+        raise Exception("You can only delete your own account")
+
+# Define the login_required decorator
+def login_required(func):
+    def wrapper(*args, **kwargs):
+        if user_is_logged_in():
+            return func(*args, **kwargs)
+        else:
+            raise Exception("User not logged in")
+    return wrapper
+
+# Define a function that requires login
+@login_required
+def delete_account(user_id):
+    if current_user_id() == user_id:
+        delete_user_account(user_id)
+    else:
+        raise Exception("You can only delete your own account")
+
+# Test the delete_account function
+login(1)
+delete_account(1)  # Should print "Deleting user account with ID 1"
+logout()
+
+try:
+    delete_account(2)  # Should raise an exception
+except Exception as e:
+    print(e)
+
+login(2)
+
+try:
+    delete_account(1)  # Should raise an exception
+except Exception as e:
+    print(e)
+
+delete_account(2)  # Should print "Deleting user account with ID 2"
+logout()
+
diff --git a/class_based_decorator.py b/class_based_decorator.py
@@ -0,0 +1,21 @@
+# A class-based decorator is a decorator that is implemented as a Python class. It works in the same way as a regular function-based decorator but allows for more advanced functionality by using the object-oriented features of Python.
+
+# To create a class-based decorator, you define a class with a __call__() method that takes a function as its argument. This method is called whenever the decorated function is called, allowing you to modify its behavior.
+
+# Here is an example of a class-based decorator that adds a prefix to the result of a function:
+
+class PrefixDecorator:
+    def __init__(self, prefix):
+        self.prefix = prefix
+
+    def __call__(self, func):
+        def wrapper(*args, **kwargs):
+            result = func(*args, **kwargs)
+            return self.prefix + result
+        return wrapper
+    
+@PrefixDecorator('Result: ')
+def my_function():
+    return 'Hello World'
+
+print(my_function())
diff --git a/context_manager.py b/context_manager.py
@@ -0,0 +1,17 @@
+# A context manager is an object that defines the methods __enter__ and __exit__. The __enter__ method is called when the context manager is entered, and the __exit__ method is called when the context manager is exited. The with statement is used to enter and exit the context manager.
+
+# Here's an example of how to create a context manager using the contextlib.contextmanager decorator:
+
+from contextlib import contextmanager
+
+@contextmanager
+def my_context_manager():
+    # code to enter the context
+    print("Entering the context")
+    yield
+    # code to exit the context
+    print("Exiting the context")
+
+#using the context manager
+with my_context_manager():
+    print("Inside the context")
diff --git a/context_manager_complex_example.py b/context_manager_complex_example.py
@@ -0,0 +1,15 @@
+import time
+from contextlib import contextmanager
+
+@contextmanager
+def timer():
+    start_time = time.time()
+    yield
+    end_time = time.time()
+    elapsed_time = end_time - start_time
+    print(f"Elapsed time: {elapsed_time:.6f} seconds")
+
+
+# example usuage
+with timer():
+    time.sleep(1)
diff --git a/decorator_chaining.py b/decorator_chaining.py
@@ -0,0 +1,16 @@
+def bold(func):
+    def wrapper():
+        return "<b>" + func() + "</b>"
+    return wrapper
+
+def italic(func):
+    def wrapper():
+        return "<i>" + func() + "</i>"
+    return wrapper
+
+@bold
+@italic
+def hello():
+    return "Hello, world!"
+
+print(hello())
diff --git a/dependecy_injection.py b/dependecy_injection.py
@@ -0,0 +1,32 @@
+# Dependency Injection is a software design pattern that allows the application components to depend on abstractions instead of concrete implementations. The goal of Dependency Injection is to decouple the components of an application, making them more reusable, testable, and maintainable. Decorators can be used to implement Dependency Injection in Python.
+
+# Here's an example of how to use a decorator to implement Dependency Injection:
+
+# Define a decorator that injects a dependency
+def inject_dependency(dependency):
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            # Inject the dependency into the function's arguments
+            return func(dependency, *args, **kwargs)
+        return wrapper
+    return decorator
+
+# Define a class that represents a dependency
+class MyDependency:
+    def some_method(self):
+        return "Hello, Sreekanth!"
+
+# Define a class that represents a service
+@inject_dependency(MyDependency())
+class MyService:
+    def __init__(self, dependency):
+        self.dependency = dependency
+    
+    def do_something(self):
+        # Use the injected dependency
+        result = self.dependency.some_method()
+        print(result)
+
+# Create an instance of the service and call the method
+service = MyService()
+service.do_something()
diff --git a/descriptors_as_decorators.py b/descriptors_as_decorators.py
@@ -0,0 +1,25 @@
+# Descriptors in Python are objects that define how attribute access works for an instance of a class. Decorators, on the other hand, are functions that take another function as input and extend or modify its behavior. In Python, it is possible to use descriptors as decorators to modify the behavior of a class attribute.
+
+# To use a descriptor as a decorator, we can define the descriptor object, and then apply it to a class attribute using the @ syntax. For example, let's say we have a descriptor called UpperCase, which ensures that a string attribute is always in upper case. Here's how we can use it as a decorator:
+
+class PositiveNumber:
+    def __get__(self, instance, owner):
+        return instance._value
+
+    def __set__(self, instance, value):
+        if value < 0:
+            raise ValueError("Value must be positive")
+        instance._value = value
+
+class MyClass:
+    def __init__(self, value):
+        self._value  = value
+
+    my_number = PositiveNumber()
+
+my_instance = MyClass(5)
+print(my_instance.my_number)
+try:
+    my_instance.my_number = 5 # should raise a ValueError
+except ValueError as e:
+    print(e)
diff --git a/extend_func_using_decorators.py b/extend_func_using_decorators.py
@@ -0,0 +1,20 @@
+def add_one(func):
+    def wrapper(x):
+        return func(x) + 1
+    return wrapper
+
+def subtract_one(func):
+    def wrapper(x):
+        return func(x) - 1
+    return wrapper
+
+@add_one
+def foo(x):
+    return x * 2
+
+@subtract_one
+def bar(x):
+    return x * 3
+
+print(foo(3)) # output: 7
+print(bar(4)) # output: 11
diff --git a/types_of_decorators.py b/types_of_decorators.py
@@ -0,0 +1,21 @@
+# In Python, decorators are a way to modify the behavior of functions or classes by wrapping them with another function. Decorators can accept arguments, which allows for more flexibility in their usage.
+
+# To create a decorator that accepts arguments, you first define a function that takes the arguments you want to use. This function will then return another function, which will be the actual decorator. The decorator function takes the function or class you want to modify as an argument, and returns a new version of that function or class with the modifications you specified.
+
+def repeat(num):
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            for i in range(num):
+                result = func(*args, **kwargs)
+            return result
+        return wrapper
+    return decorator
+
+@repeat(3)
+def greet(name):
+    print(f"Hello, {name}!")
+
+greet("Sreekanth")
+
+
+
