List Comprehension: ORM

Andrew Fuller — Fri, 25 Oct 2024 01:58:11 +0000

Need a swift way to create lists when mapping object relations? List comprehensions are the way to go! You can easily connect all of our data in a programmatic way and manipulate it as you please. The example code below is for a one-to-many relationship between a Author, Book, and Contract.

class Book:

    all = []

    def __init__(self, title) -> None:
        self.title = title
        Book.all.append(self)

    def contracts(self):
        return [contract for contract in Contract.all if contract.book == self]

    def authors(self):
        return [contract.author for contract in self.contracts()]


    pass

You will see repeatedly that list comprehensions are taken advantage of you algorithmically connect all of the objects and create usable lists out of them based simple criteria like: if this instance's attribute book is present or author in a list of objects.

class Author:

    all = []

    def __init__(self, name) -> None:
        self.name = name
        Author.all.append(self)

    def contracts(self):
        return [contract for contract in Contract.all if contract.author == self]

    def books(self): 
        return [contract.book for contract in self.contracts()]

    def sign_contract(self, book, date, royalties):
        return Contract(self, book, date, royalties)

    def total_royalties(self):
        return sum([contract.royalties for contract in self.contracts()])

    pass

Again and again list comprehensions can be used simply to make accessible data from other classes in ORM. You can even use them in class methods to add more functionality like checking if a passed in date matches that of a book/author contract.

class Contract:

    all = []

    def __init__(self, author, book, date, royalties):
        self.author = author
        self.book = book
        self.date = date
        self.royalties = royalties
        Contract.all.append(self)

    @property
    def author(self):
        return self._author

    @author.setter
    def author(self, value):
        if not isinstance(value, Author):
            raise Exception
        self._author = value

    @property
    def book(self):
        return self._book

    @book.setter
    def book(self, value):
        if not isinstance(value, Book):
            raise Exception
        self._book = value

    @property
    def date(self):
        return self._date

    @date.setter
    def date(self, value):
        if not isinstance(value, str):
            raise Exception
        self._date = value

    @property
    def royalties(self):
        return self._royalties

    @royalties.setter
    def royalties(self, value):
        if not isinstance(value, int):
            raise Exception
        self._royalties = value

    @classmethod
    def contracts_by_date(cls, date):
        return [contract for contract in cls.all if contract.date == date]

Overall, it is a very easy way of iterating through your data as opposed to creating 500 lines of code to associate what could be simple relations.

React rendering lists with .map()

Andrew Fuller — Fri, 04 Oct 2024 15:59:26 +0000

Intro
One of the more confusing but simple concepts I had to wrap my mind around when first working with Javascript and React was programmatically rendering "cards" that usually display some image, button and variable information. You can then make lists of these cards from information stored in an API or a local db.json file.

This is actually quite simple to do when using a powerful tool like React, once you know how to go about it. By the time I built a list of plant cards for a "Plantsy App", I had it mastered. This list had a search feature and could be added to by a controlled form but I won't go into those features today.

List of Plant Cards

Plant Card JSX Code

The plant card component took in a prop "plant" that contained info from a db.json file with id, name, image, and price keys from an array of objects. This info was fetched and then passed down the card component give it all it needed to render the way we wanted. It even had condimental rendering with an in/out of stock button.

Mapping the Plant Cards

Now for the part you came for - mapping the plant cards. The plant list component was passed a prop of "plants" which could be changed via filtering or adding to our list with a form. It is important to note that you need to create a key attribute for this mapping to work properly and it is bad practice to use an index variable. Our information came with ids but you could also use the plant (not plants) variable for this.

Put all of this inside a <ul> or <ol> element and viola! All of your cards are easily and programmatically rendered with ease.

React Lists and Keys

React has many guides on it features. I recommend you give there website a look if you are still iffy on the technical aspect of mapping lists.

Lists and Keys – React

legacy.reactjs.org

Forem: Andrew Fuller

List Comprehension: ORM

React rendering lists with .map()

Lists and Keys – React