DEV Community: dan crowley

Flask SQLAlchemy - Strengths and Weaknesses

dan crowley — Thu, 20 Jul 2023 02:45:03 +0000

flask sqlalchemy: strengths and weaknesses

Flask SQLAlchemy is a powerful extension for the Flask web framework that provides a convenient way to work with databases using SQLAlchemy, a popular ORM library for python. It allows developers to interact with databases using Python classes instead of writing raw SQL queries, which makes can streamlines interactions with the database. Let's look at some of its strengths and weaknesses, and cover some use cases.

strengths:

integration with flask

Flask SQLAlchemy is designed to work seamlessly with Flask, making it easy to incorporate database functionality into Flask applications. It leverages Flask's flexible architecture, allowing developers to build scalable and modular applications.

pythonic syntax

Flask SQLAlchemy embraces Python's philosophy, making it more intuitive for Python developers. It allows them to define models and perform database operations using familiar Python syntax, which enhances productivity.

orm flexibility

SQLAlchemy, the underlying ORM library, provides a high level of abstraction and supports multiple database backends. Flask SQLAlchemy inherits these features, allowing developers to switch between different database engines without significant code changes.

query generation

It offers a robust query generation system that enables developers to build complex database queries using Pythonic expressions, enhancing code readability and maintainability.

testability

Flask SQLAlchemy facilitates unit testing by allowing developers to create test databases and test data within the application context. This ensures better isolation and accurate testing of database-related code.

weaknesses:

learning curve

For developers new to Flask or SQLAlchemy, the learning curve can be steep. Understanding the concepts of both Flask and SQLAlchemy takes time and practice, which might deter some beginners.

boilerplate code

While Flask SQLAlchemy abstracts many database operations, developers may still need to write boilerplate code for common tasks, such as session handling and query execution.

performance overhead

The additional layer of abstraction introduced by SQLAlchemy can lead to a slight performance overhead compared to raw SQL queries, especially for complex and high-volume database operations.

limited advanced features

While SQLAlchemy is a powerful ORM, some advanced features and optimizations available in standalone SQLAlchemy might not be directly accessible or well-documented in Flask SQLAlchemy.

comparison with django and ruby on rails:

django:

strengths:

comprehensive built-in features//

Django comes with an "all-inclusive" approach, providing numerous built-in features like an admin interface, authentication, and template engine, which accelerate development.
high-level abstractions: Django's ORM is tightly integrated and offers a high level of abstraction, which simplifies database interactions.
django's admin interface: The built-in admin interface allows developers to manage application data without writing custom code.

weaknesses:

monolithic architecture//

Django's monolithic structure might be overwhelming for small projects or when developers prefer more modular solutions.

learning curve//

Django's extensive features can make the learning curve steep for beginners.

ruby on rails:

strengths:

convention over configuration//

Ruby on Rails follows the "Convention over Configuration" principle, reducing the need for explicit configuration, resulting in a streamlined development process.
scaffolding: Rails provides powerful scaffolding tools that generate code and basic CRUD (Create, Read, Update, Delete) operations, speeding up development.

weaknesses:

performance//

Ruby on Rails can face performance issues, especially when handling complex and resource-intensive applications.

limited language support//

While Rails has good support for Ruby, developers may find fewer resources and libraries compared to Python's extensive ecosystem.

In conclusion, Flask SQLAlchemy is a valuable tool for building Python-based web applications with relational databases. While it has its strengths, developers must consider their project's requirements and their familiarity with Flask and SQLAlchemy when choosing the right framework for their application.

It's worth noting that the strengths and weaknesses of frameworks like Flask, Django, and Ruby on Rails can vary based on the specific needs of your project and the preferences of your development team. Additionally, these frameworks are constantly evolving, so it's essential to stay up-to-date with the latest features and improvements to make informed decisions.

data classes in python

dan crowley — Fri, 09 Jun 2023 17:00:51 +0000

Python is an object-oriented programming language that provides various ways to define and use classes.

python classes

A python class is a blueprint for creating instances / objects. A normal class is a user-defined class that doesn't include any special attributes or methods. Normal classes use a constructor method, __init__ that initializes the class instance with default or provided inputs.

here's an example:

class Dog:
    def __init__(self, name, breed, age):
        self.name = name
        self.breed = breed
        self.age = age

data classes

a data class is a special class created using the @dataclass decorator. they are meant to be used for simple, immutable data structures, sans behavior.

here's an example of.a nifty little data class in Python:

from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int

normal & data classes: differences

brevity:

Data classes are more concise than normal classes, as they require much less code to define. The parameters are automatically generated, and a __repr__ is provided for us.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):
        return f"Point(x={self.x}, y={self.y})"

@dataclass
class Point2:
    x: int
    y: int

Writing attributes is a lot quicker too in a data class. Let's have a look below.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def get_name(self):
        return self.name

    def set_name(self, name):
        self.name = name

    def get_age(self):
        return self.age

    def set_age(self, age):
        self.age = age

Here, we created a normal class named Person and defined two attributes, name and age using a couple pairs of setter and getter functions.

Now, let's create a data class with two attributes.

from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int

Super brief, super legible, super cool!

mutability:

Data classes are immutable by default, while normal classes are mutable.
Which means after instances of data classes are made, their attributes can't be edited.

Is it good to have an object that can't be edited? Like most things in life, it depends.

type-hinting:

Type hinting is another area where data classes and normal classes differ. With data classes, we can specify the types of our attributes in the class definition. This is done using Python's built-in type annotations. Here's an example:

from typing import List

@dataclass
class Person:
    name: str
    age: int
    hobbies: List[str]

As you can see, we specified the types of the name, age, and hobbies attributes. This allows Python's type checker to catch any type errors during development, which can help prevent bugs and improve the reliability of our code.

In contrast, with normal classes, we have to manually specify the types of our attributes in the constructor or in the class definition. Here's an example:

from typing import List

class Person:
    def __init__(self, name: str, age: int, hobbies: List[str]):
        self.name = name
        self.age = age
        self.hobbies = hobbies

equality:

By default, data classes define equality based on the values of their attributes, meaning that two instances of a data class are considered equal if all their attributes have the same values.

from dataclasses import dataclass

@dataclass
class Person:
    name: str
    age: int

p1 = Person("Alice", 30)
p2 = Person("Alice", 30)
print(p1 == p2)  # True

In contrast, normal classes define equality based on object identity, meaning that two instances of a normal class are considered equal only if they are the same object in memory.

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

p1 = Person("Alice", 30)
p2 = Person("Alice", 30)
print(p1 == p2)  # False

Wow!

conclusion

we use both data and normal classes in python to represnt objects. While data classes are more concise and legible, normal classes give us much more versatility.

TLDR: @dataclass(es) are great for simple data structures and "Normal" classes are good when you need more flexibility and function inside your class. thank you please #like #subscribe #comment #follow #your #heart

Using the State Hook to Search and Filter Data

dan crowley — Wed, 17 May 2023 14:59:38 +0000

What is a Hook? A Hook is a special function that lets you “hook into” React features. useState is a special hook that allows us to add React State to function components.

Before React.js, in order to add state, one had to convert a function to class, but that's no longer necessary with the useState hook.

Let's begin by importing the hook to our React app.


import { useState } from "react";
import React from "react";

Once we've imported the hook, we need to create our state variable and setter function:


const [searchText, setSearchText] = useState('')

searchText is our state variable. It will hold the value of whatever the user types into the input box.

setSearchText is our setter function. By invoking it, we can change or update the state variable.

Finally, the value in the parenthesis attached to useState is our default state. We would like the box to be empty, so we will simply pass an empty string as the parameter.

If, for any reason, you wanted the search box to already have text inside of it when the user loads the page, you can place something between these parenthesis.

setting state with `onChange`

Now that we have our setter function, we can use it to build out the function that will handle any change in the search input box.


 const handleSearchInput = (event) => {
   setSearchText(even.target.value)


      <input type="text"  onChange={handleSearchInput} value={searchText} />

So we've created a function handleSearchInput, and added it to a react event listener, onChange, so that it will be invoked with every change to the input box.

handleSearchInput simply uses our setter function, setSearchText, passing the event.target.value (the value of the text inside the search box) as a parameter. This will update our searchText state.

Finally, we also place our deconstructed searchText variable as the "value" attribute of the <input /> tag, ensuring that our value in the searchText variable and the value in the html remain constant.

filtering the data using state

Now that we have our state synced, we need to do something with this data. Let's filter it, so that we will only show items with a title that matches the search query. We can use the built in js filter method. This method takes a callback function and returns an array that matches the search criterion.


const filteredData = data.filter((d) => {
      return d.title.toLowerCase().includes(searchText.toLowerCase())

Here we name a new constant, that will return an array of data items with a title that matches the search query. As our setter function is being invoked with each keypress, the user does not need to press enter. This is a responsive search.

Yet, what if there's nothing in the search box? If we want to display all of the available data, we can add an if statement to our function.


const filteredData = data.filter((item) => {
    if (searchText === "") {
      return true;
    }
    return item.title.toLowerCase().includes(searchText.toLowerCase())

filtering for multiple cases

Finally, what if we want to return items that match the title or another piece of data, such as an item's description?

To handle this case, we can add a simple OR statement
( || )
to check for a match in either the item's title or description.




const filteredData = data.filter((item) => {
    if (searchText === "") {
      return true;
    }
    return item.title.toLowerCase().includes(searchText.toLowerCase()) 

||

items.description.toLowerCase().includes(searchText.toLowerCase())

Javascript Anonymous Functions and Event Listeners

dan crowley — Wed, 26 Apr 2023 13:10:45 +0000

Event listeners and anonymous functions are a few difficult concepts for beginner developers to properly grasp. I am constantly receiving questions regarding these concepts from frazzled and frustrated students. If this sounds like you, fear not, for in this post we will define these concepts, explore their interactions with each other, and discuss potential use cases of each.

Event Listeners: addEventListener() method

What is an event listener? An event listener is a method that we pass upon an object, most often Element, Document, or Window. The method works by adding a function that will be called whenever the specified event is 'heard'. Let's look at a simple example:

let timesClicked = 0;
const newImg = document.createElement('img');
 newImg.addEventListener('click', timesClicked++);

The code above creates an image element, and attaches an event listener that is listening for a click event. When the image element is clicked, the second parameter, timesClicked++, is executed. This will simply increment the variable timesClicked by one with each click.

We often provide a callback function as the second parameter of the event listener. Let's see what that might look like:

function incrementVariable() {
 timesClicked++ };

newImg.addEventListener('click', incrementVariable)

This code will do the exact same thing as the previous example, but instead of providing instructions in the second parameter, we insert just the function name, without any parenthesis. If we add parenthesis at the end of our function, the function will be called when the code is ran. We don't want that, we want the function to execute only on the click event.

Anonymous Functions and Event Listeners

So when do we add parenthesis to our eventListener callback function?

The answer is simple: when we need to pass data from a parent function. Let's look at an example:

function addToNav(array) {
    const navList = document.getElementById('cake-list')
    const navName = document.createElement('li')
    navName.textContent = array.name
    navList.appendChild(navName)
    navName.addEventListener('click', () => {
        displayDetails(array)}

In this function, we have one parameter, which is array. This function takes an array, creates a list element with the name, and appends the list element of the item as a child to the navList. Finally, it adds an event listener, which will listen for a click on the newly created list element. When clicked, it will execute the function displayDetails and pass the array as a parameter.

Here, we use an anonymous function as the second argument of the event listener because we need to pass the array to the callback function in order for the function to properly execute. If we simply point to the function, it will not work. As we need to pass information into displayDetails, we must employ an anonymous function, and pass the 'array' variable as the parameter. This way, our displayDetails function will know which information to display when the list element is clicked.

Event listeners and anonymous functions can be a bit confusing, but don't get discouraged! With some practice, one will find they are much less complex than they appear!

DEV Community: dan crowley

Flask SQLAlchemy - Strengths and Weaknesses

flask sqlalchemy: strengths and weaknesses

strengths:

integration with flask

pythonic syntax

orm flexibility

query generation

testability

weaknesses:

learning curve

boilerplate code

performance overhead

limited advanced features

django:

strengths:

comprehensive built-in features//

weaknesses:

monolithic architecture//

learning curve//

ruby on rails:

strengths:

convention over configuration//

weaknesses:

performance//

limited language support//

data classes in python

python classes

data classes

normal & data classes: differences

brevity:

mutability:

type-hinting:

equality:

conclusion

TLDR: @dataclass(es) are great for simple data structures and "Normal" classes are good when you need more flexibility and function inside your class. thank you please #like #subscribe #comment #follow #your #heart

Using the State Hook to Search and Filter Data

setting state with onChange

filtering the data using state

filtering for multiple cases

Javascript Anonymous Functions and Event Listeners

Event Listeners: addEventListener() method

Anonymous Functions and Event Listeners

setting state with `onChange`