Une autre technologie pour créer un système de recommandation

#!/usr/bin/env python

import os

from dotenv import find_dotenv, load_dotenv
from neomodel import (
    IntegerProperty,
    StructuredNode,
    StringProperty,
    RelationshipFrom,
    RelationshipTo,
    config,
    db,
)
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

import pmb_orm


class Book(StructuredNode):
    title = StringProperty(unique_index=True)
    isbn = StringProperty()
    patrons = RelationshipFrom("Patron", "BORROW")


class Patron(StructuredNode):
    id = IntegerProperty()
    fullname = StringProperty()
    firstname = StringProperty()
    lastname = StringProperty()
    books = RelationshipTo("Book", "BORROW")


def run():
    load_dotenv(find_dotenv())

    config.DATABASE_URL = os.getenv("NEO4J_URL")

    e = create_engine(os.getenv("DB_DSN"))
    PMB = sessionmaker(bind=e)
    session = PMB()

    patrons = session.query(pmb_orm.Patron).all()
    for patron in patrons:
        p = Patron(
            id=patron.id,
            fullname=patron.full_name,
            firstname=patron.first_name,
            lastname=patron.last_name,
        ).save()
        for book in patron.borrowed_titles:
            b = Book.nodes.get_or_none(title=book)
            if not b:
                res = session.query(pmb_orm.Record).filter(
                    pmb_orm.Record.main_title == book
                ).first()
                b = Book(title=book, isbn=res.isbn).save()
            p.books.connect(b)


if __name__ == "__main__":
    run()

#!/usr/bin/env python

import argparse
import os

from dotenv import load_dotenv, find_dotenv

import pmb2neo4j


def get_recommandations_by(title):
    title_query = """
MATCH (b:Book {title: $title})<-[:BORROW]-()-[b1:BORROW]->(sim_book)
RETURN b, sim_book, COUNT(b1) AS sim_score
ORDER BY sim_score DESC
"""

    results, meta = pmb2neo4j.db.cypher_query(title_query, {"title": title})
    books = [(pmb2neo4j.Book.inflate(r[1]), r[2]) for r in results[:20]]

    return books


def get_recommandations_for(patron):
    patron_query = """
MATCH (p:Patron {lastname: $lastname})-[:BORROW]->(b)<-[b1:BORROW]-(sim_user)
WITH p, sim_user, COUNT(b1) AS sim_score
ORDER BY sim_score DESC
MATCH (sim_user)-[b2:BORROW]->(title)
WHERE NOT((p)-->(title))
RETURN title, COUNT(b2) AS score_title
ORDER BY score_title DESC
"""

    results, meta = pmb2neo4j.db.cypher_query(patron_query, {"lastname": patron})
    books = [(pmb2neo4j.Book.inflate(r[0]), r[1]) for r in results[:20]]

    return books


if __name__ == "__main__":
    load_dotenv(find_dotenv())
    pmb2neo4j.config.DATABASE_URL = os.getenv("NEO4J_URL")
    parser = argparse.ArgumentParser(
        description="Getting recommendations for a patron or based on a title."
    )

    parser.add_argument("-p", "--patron", help="Lastname of the patron", required=False)
    parser.add_argument("-t", "--title", help="Title of the book", required=False)
    args = parser.parse_args()

    if args.patron:
        for book, _ in get_recommandations_for(patron=args.patron):
            print(f"{book.title} (ISBN : {book.isbn})")

    if args.title:
        for book, _ in get_recommandations_by(title=args.title):
            print(f"{book.title} (ISBN : {book.isbn})")