DEV Community: penncurtis

How to Simplify Your App.py Using 'functools'

penncurtis — Tue, 18 Jul 2023 20:37:49 +0000

Introduction

When building out my first ever full-stack python/react project I came across an interesting conundrum. I knew that I wanted my website to essentially "read only" unless the person navigating through it was a logged in user. Initially I thought I may have to simply conditionally render many components of the website by setting a state for a logged-in user, building a whole lot of ternaries, and so forth, and so forth...

Then, I came across the functools module. This module provides a powerful toolset for functional programming. One of its most commonly used features is the ability to create function decorators, which allow you to modify the behavior of functions without changing their source code. In this blog post, I'll explore how to leverage the functools module to implement the @login_required decorator in an app.py file. By using this decorator, you can easily enforce authentication and authorization checks in your web application.

Implementing the @login-required Decorator

The @login_required decorator will be used to protect routes that require authentication. It will redirect unauthenticated users to the login page and only allow access to authenticated users. Here's an example implementation:

app = Flask(__name__)

def login_required(view_func):
    @wraps(view_func)
    def wrapper(*args, **kwargs):
        if not current_user.is_authenticated:
            return redirect(url_for('login'))
        return view_func(*args, **kwargs)
    return wrapper

Let's break down the implementation:

The login_required function takes a view_func as an argument, which represents the protected view or route.
The wraps decorator from functools is used to preserve the original function's name, module, and docstring. This is important to maintain compatibility with Flask and other libraries.
Inside the wrapper function, we perform the authentication check. In this example, we assume there is a current_user object that has an is_authenticated property indicating whether the user is logged in.
If the user is not authenticated, we redirect them to the login page using redirect(url_for('login')). Adjust the 'login' route according to your application's route configuration.
If the user is authenticated, we allow the view function to be executed by calling view_func(*args, **kwargs).
Finally, we return the wrapper function, which will replace the original view function when the @login_required decorator is applied.

Using the @login_required Decorator

Now that we have implemented the @login_required decorator, we can apply it to any route that requires authentication. For example:

@app.route('/dashboard')
@login_required
def dashboard():
    # Protected view code
    return 'Welcome to the dashboard!'

In this example, the dashboard route is protected by the @login_required decorator. If a user tries to access the /dashboard URL without being authenticated, they will be redirected to the login page. Otherwise, they will be granted access to the protected view.

Conclusion

In this blog post, we explored how to leverage the functools module to implement the @login_required decorator in an app.py file. By using this decorator, you can easily enforce authentication and authorization checks in your web application. The @login_required decorator simplifies the code by centralizing the authentication logic and promoting code reusability. It's a powerful tool that enhances the security and user experience of your Flask-based applications.

Building a Seed.py File and Synchronizing it Models in Python

penncurtis — Fri, 30 Jun 2023 15:25:59 +0000

Understanding the Seed.py file:

The seed.py is the file that runs once in order to populate the database with data. Hand in hand with the built out models.py, it allows the user to automate the process of table creation and because of this, you can ensure that your initial database has a consistency in how it is built out.

Step by Step on how to Synchronize Data with Models:

First things first, make sure you are importing the necessary models. These will be important to access the models.py and will allow you to interact with the database.
In the seed.py file, create instances of the models you've defined and imported. These instances represent the data that you want to insert into your database. At this step you can manipulate the data as you please, manipulating key names, values, and so forth.
Now that you've created your instances, and you're happy with how they look as well as the information they contain, it's time to insert them into the database. Use the methods provided by your database (likely SQLAlchemy) to insert the data. It is important that you ensure that the attributes of the models are mapped out to the correct fields in your database.
All that's left to do is the big part: execute the seed.py file. You can execute it manually through terminal or sometimes as part of a larger automated process. This will trigger the insertion of pre-made data into the corresponding fields of the database.

If you have done everything correctly, you should see your pristine tables filled with the data that you assigned to them in your seed.py file.

Tips and Tricks

If it didn't populate as you had hoped, here are a few tips/tricks that I have found useful in my time with building out seed files.

Be consistent with naming. It may sound cliche, but make sure that you are using the same name to refer to the same thing throughout your files. Capitalize what needs to be capitalized, add and 's' to what needs to be plural, and so forth. Pick a name for something and stick it, you'll thank yourself later.
Maintenance and Upkeep. Regularly review and update the seed file as needed. It may seem intimidating, but you can always just follow the instructions above to successfully re-seed your data. You've done the hard part, don't stress if you have to update.

Conclusion

Building a seed.py file aligned with your models.py file is crucial for maintaining consistency and efficiency when populating your database with initial or test data. By following the steps outlined above and being mindful of best practices, you can ensure that your seed data accurately reflects the structure of your models. Embrace the power of the seed.py file and enjoy a streamlined approach to managing your database initialization process.

The Versatility of The 'isinstance' Method in Python

penncurtis — Tue, 06 Jun 2023 20:36:22 +0000

What & Why

Of all the methods that I have encountered so far in my time using Python, I found the 'isinstance' method to be the most useful, versatile, and reliable.

This method thrives in scenarios that involve many to many relationships, exchanges of information between files and classes, and even within methods themselves.

To put it as simply as possible, the 'isinstance' method is useful to check if an object or variable is of a specified data type or class type.

Structure & Syntax

The 'isinstance' method takes two arguments, both of which are mandatory for its functionality. The first argument is the name of the object/variable that we want to check. The second argument is the type of class that we want to cross-check the object/variable against. You can also check for multiple classes or types.

Execution and Examples

Using 'isinstance' we can check to see if a variable is a number or a string:

n = 100
result = isinstance(n, int)
if result:
    print('Yes')
else:
    print('No')


## output
Yes

As we can see in the example above, the isinstance method checks to see if the value of 'n' is indeed an integer. The boolean value that the method returns results in the output of 'Yes'. If we were to check to see if 'n' was a string we would get the opposite output.

n = 100
result = isinstance(n, str)
if result:
    print('Yes')
else:
    print('No')


## output
No

To check for multiple classes or types, we would simply include them in parenthesis as the second variable.

greeting = "hello world!"
result = isinstance(greeting, (int, float))
if result:
    print('Yes')
else:
    print('No')


## output
No

Obviously, since the greeting is not an integer or a float, the method returns False. We can also compare our variable/object to other python classes.

class Employee:

    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

emp = Employee("Emma", 100000)

## checking if emp is an Employee
print(isinstance(emp, Employee))

## output 
True

Because our emp "Emma" met the criteria dictated by the Employee class, the method returns True.

Culmination & Conclusion

Understanding 'isinstance' is pivotal to successfully coding in python. Hopefully this blog post has helped resolve any outstanding queries the reader may have had with regards to this method. As one of the most powerful tools I have encountered so far in this coding language, I hope I did it justice in portraying its efficacy.

Conditional Rendering in React

penncurtis — Tue, 16 May 2023 19:08:53 +0000

What is Conditional Rendering?

In React, once we have successfully compiled our components, as well as the subsequent elements we want to display on the webpage, we can add nifty effects onto those objects to determine if/what details we want to show.

To enact conditional rendering on a piece of information, we can use one of two methods: an "if" statement or a "ternary" operator.

By using these, we can swiftly change the state of our application, and in turn, affect the what is displayed on the page. Having laid the groundwork, let's dive right in.

Conditional Rendering with "if"

For the purposes of this blog post, let's say we are showing a list of flowers.

// db.json

{
  "flowers": [
    {
      "id": 1,
      "name": "Rose",
      "inBloom": true,
    },
    {
      "id": 2,
      "name": "Orchid",
      "inBloom": false,
    }
  ]
}

For each flower in our database, we are provided a boolean value to determine if that flower is in bloom or not.

Since not every flower will be in bloom at the same time, we can conditionally render that information on the webpage using an "if".

function FlowerCard({flower}) {

  function inBloomFlower(flower){
     if(flower.inBloom === true){
       return "IN BLOOM :)"
     }
       return "NOT IN BLOOM :("
  }

  return (
    <div className="card">
      <h2>{flower.name}</h2>
      <img src={flower.image} alt={flower.name} />
      { inBloomFlower }
    </div>
  )
}

export default FlowerCard

By putting an "if" statement within a function outside of the return, we tell the program to read the value of each flower's inBloom key in the database. Based on what the program reads, it will determine what to insert into the rendered page.

Therefore, on our webpage we will see the "rose" labeled as in bloom, and the orchid as not being in bloom.

Conditional Rendering with "Ternary" Operator

The other way we could achieve the same result is using the ternary operator. In this method, we can save ourselves the hassle of writing a new function outside of the return and can instead write everything we need in line.

function FlowerCard({flower}) {

  return (
    <div className="card">
      <h2>{flower.name}</h2>
      <img src={flower.image} alt={flower.name} />
      { flower.inBloom ? 
          <h3> IN BLOOM :) </h3> 
        : 
          <h3> NOT IN BLOOM :( </h3> 
      }
    </div>
  )
}

export default FlowerCard

In this example, we turned what was previously an "if" statement into a "ternary". We're telling the program to read that same value of the inBloom key in the database. If it reads that key as 'true' is will return the value that precedes the colon, and if it reads it as false, it will return the value that succeeds it.

I hope that this blog has helped the reader better understand the power of conditional rendering in react as well as the efficiency with which it can be enacted.

Modifying Objects in JavaScript Made Easy

penncurtis — Tue, 25 Apr 2023 18:26:36 +0000

In using JavaScript, you will inevitably come across 'Objects' on a regular basis. Assuming you already possess a basic understanding on how to actually create them, it will also be important to understand how to modify them. In an effort to ease comprehension of the subject, I will flesh out each of the three main methods of object modification individually.

Modifying Objects with Dot or Bracket Notation

This method is especially convenient when adding properties to an 'Object'. Let's say we find ourselves in front of an empty 'Object'.

const city = {};

And let's say we want to fill in this currently empty object with information. We could do so, very simply, using dot or bracket notation:

const city = {};

city.name = 'New York';

city['population'] = '8 million';

Now while the ways in which I added the name and the population of the city may seem different, their outcome is exactly the same. They both create a 'key' within the 'Object' and assign it a value using the assignment operator.

Now, if we call our object it will display all the information that we attached to it in the step above.

const city = {};

city.name = 'New York';

city['population'] = '8 million';

city.state = 'New York';

city;
//=> { name: New York, population: 8 million, state: New York };

Now let's say we realize we made a mistake and we want to change on the values of our object. We can do so using the same methods of bracket and dot notation.

city['name'] = 'Los Angeles';

city.population = '3.8 million';

city.state = 'California';

What this will do is go into our 'Object' and modify the values as we told it to do. It is important to note however, that modifying objects with this method does so destructively. Therefore when we call our 'city' it will no longer return the values we initially assigned.

city;
//=> { name: Los Angeles, population: 3.8 million, state: California };

Now lets say we wanted to showcase an increase in our city's population size by comparing it to what it was in the past without having to rewrite all of the data we already wrote.

Modifying Objects using the Spread Operator

Much like how we do with 'Arrays', we can use the spread operator to copy all elements of an existing 'Object' into a new one. So let's create a new 'city' to show Los Angeles' population from a century ago.

const oldCity = {...city};

At this point all we have done is create an exact copy of our 'Object'. From here we can modify our new 'Object' using the methods learned above. Using this method will leave our original 'city' unchanged, so we will still be able to call it and see the values we assigned it above.

oldCity.population = '575 thousand';

oldCity;
//=> { name: Los Angeles, population: 575 thousand, state: California };

city;
//=> { name: Los Angeles, population: 3.8 million, state: California };

As you can see, our original 'city' remained intact, and we were able to modify a value of our 'oldCity' without having to rewrite all its other properties.

Removing Properties from an Object

The final topic I'd like to touch on with regards to object modification is how to remove one of its properties.

Let's say we no longer want to include the state of our 'city'. All we have to do is tell JavaScript to delete that property.

city;
//=> { name: Los Angeles, population: 3.8 million, state: California };

delete city.state;

city;
//=> { name: Los Angeles, population: 3.8 million };

Conclusion

Objects are very useful, versatile, and above all, common in JavaScript. Knowing how to modify them is just as important. My hope is that this blog helped the reader gain even just an ounce more clarity on the topic of Object Modification.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Working_with_objects