DEV Community: John Pinto

Updated scenestamps post

John Pinto — Fri, 20 Dec 2024 20:13:44 +0000

Scenestamps: Your Cinephile Community

John Pinto ・ Jul 4 '24

Scenestamps: Your Cinephile Community

John Pinto — Thu, 04 Jul 2024 15:32:45 +0000

Remember that scene in The Dark Knight where the Joker makes a pencil disappear? Or that heartbreaking moment in Up that tells a love story in just a few minutes? We all have those movie moments etched in our memories—scenes that made us laugh, cry, or sit at the edge of our seats. But finding these exact moments when you want to revisit them or share them with friends? That's been surprisingly difficult. Until now.

What is Scenestamps?

Scenestamps is a new platform that revolutionizes how we discover, share, and discuss specific scenes from movies and TV shows. Think of it as a combination of IMDB's comprehensive database and Letterboxd's social features, but focused on individual scenes rather than entire movies.

Why Scenes Matter

Movies and TV shows are more than just complete works—they're collections of moments that resonate with us personally. Sometimes it's a powerful monologue that struck a chord, a visually stunning sequence that left us in awe, or a subtle character interaction that perfectly captured an emotion. These scenes become part of our cultural conversation, our reference points, and our shared experiences.

How Scenestamps Works

At its core, Scenestamps provides exact timestamps for scenes across different streaming platforms, along with detailed information about each scene. When you find a scene you're interested in, you get:

Precise timestamps to locate the scene in any version of the movie
A detailed summary of what happens in the scene
User discussions and comments
Related scenes and recommendations

More Than Just Timestamps

But Scenestamps isn't just a technical tool—it's a community platform for movie and TV enthusiasts. You can:

Create lists of your favorite scenes, movies, tvshows, celebs and quotes
Share scenes with other users
Write reviews and analyses
Engage in discussions about specific moments
Follow other users with similar tastes
Discover new content through scene recommendations

For Every Kind of Movie Lover

Whether you're a casual viewer or a serious cinephile, Scenestamps has something for you. Film students can use it to study specific sequences. Critics can reference exact moments in their reviews. Friends can share their favorite scenes with each other. Teachers can easily find relevant clips for their classes. The possibilities are endless.

Cross-Platform Freedom

Unlike platform-specific features, Scenestamps works across all streaming services. Found a great scene on Netflix? Want to reference something from Prime Video? Looking for that perfect moment from HBO Max? Scenestamps brings it all together in one place.

Join the Scene Revolution

We're building something special at Scenestamps—a place where movie moments come alive through community engagement and precise organization. It's about making those perfect cinematic moments more accessible, shareable, and discoverable.

Movies and TV shows have evolved. The way we watch them has changed. Isn't it time the way we find and share our favorite scenes evolved too?

Visit scenestamps.com to start discovering and sharing your favorite movie moments today.

Scenestamps is currently in its growing phase, with an active community of movie enthusiasts already using the platform to discover and share their favorite scenes. Join us in shaping the future of how we experience and share the movies we love.

Nostrdev

John Pinto — Sun, 25 Jun 2023 14:26:05 +0000

This application presents capabilities of the new Nostr-PHP library

Generate Key Pair

Add relays

Github : https://github.com/pj8912/nostrdev

Blog Automation using Python🐍& Blogger

John Pinto — Thu, 22 Jun 2023 08:46:21 +0000

I was wondering what are the things I could automate with python.

I know A LOT! 😝😝

🧐 How about movies??

I had nothing specific in mind, but I know I could build something.

We all use Wikipedia a lot for many topics and movies being one of them , an idea clicked.

I'd like reading movie plots alot why not scrape the Plot section of the movie articles and build a website to read only movie plots??

Felt like doing something creative is a good exercise, but what movies??

With the Wikipedia a part already figured out, luckily I discovered python package for IMDb. So there is a module to fetch top200 movies list from IMDb using python.

Now

wikipedia(data scraping, python package, api)
imdb(python package) What about the website??

I'm not gonna spend $$$ for my side-project that much, instead decided to use bloggerAPI service, which allows use to create free blog websites with Google.

I can create a blogger website with a click and use it's API to upload posts.

🎞🎞🎞🎞🎞🎞🎞🎞🎞🎞🎞🎞🎞🎞🎞🎞🎞🎞🎞

Workflow

It's very simple:

Fetch top200 movie title list
For each movie title, check if the title has topic "movie"
If yes, get the article(url+python) from wikipedia, and scrape the data between Plot section and the Cast section. I said between Plot and cast since the html structure of Wikipedia articles makes it difficult scrape the particular section but, since all the movies articles almost follow the same pattern, that is the decision I made.
Finally, bloggerAPI. Nothing special here:
- Create a project in the Google API Console
- Enable the Blogger API for your project
- Create an API key and OAuth 2.0 Client ID

That's it! Run the script which will take care of the rest.

The Blogger Website : https://movieplotzz.blogspot.com/

Here is the github : https://github.com/pj8912/wiki-blog-automation clone it and follow the instructions to automate the process of creating your own movie plots website and have fun! 😉

How @shnai0 built her first Open Source project with ChatGPT and Next.js. 10k users in 24 hours 🤯

John Pinto — Mon, 19 Jun 2023 15:13:03 +0000

Blog Link

File uploading in Flask

John Pinto — Thu, 01 Jun 2023 14:09:11 +0000

I've used two ways of uploading files

only directly to folder
directly into database from a folder

Upload to a folder

You can choose the folder of your choice to receive uploaded files, here in my project when a file is uploaded the file is taken , sperated by extension, rename the file to current timestamp and upload the file to folder and the name to the database. The file is only saved in the folder.

app = Flask(__name__, static_folder='uploads')

So the file into the folder and the name to the database.

Upload to database from a folder

So if you wanna a directly upload any file to the database, you need to save it as BLOB.
File size by MySQL type:

TINYBLOB 255 bytes = 0.000255 Mb
BLOB 65535 bytes = 0.0655 Mb
MEDIUMBLOB 16777215 bytes = 16.78 Mb
LONGBLOB 4294967295 bytes = 4294.97 Mb =4.295 G

So basically you'd have to convert the file into binary form and then upload it to the database.

def convertToBinaryData(filename):
    with open(filename, 'rb') as file:
        binaryData = file.read()
    return binaryData

Eventhough we are saving the file directly into the database we are forced to assign a location of file upload as same as the previous method. If you don't, flask will throw a error such as No such filename as filename.type.

So we follow the same steps as before,and we add a step in converting the uploaded file to binary and upload the file and the file's name to the database.

You can delete the file from the folder after upload to the database if you want to.

Please check if the upload works!!

Here's the view of the BLOB file and their names in the mysql database

Give it a shot and enjoy!! THANKS!

Project Installation

Requirements

Python 3.10.6

Install

clone

git clone https://github.com/pj8912/flask-file-upload.git

Create virtual environment and activate
Install requirements

pip install -r requirements.txt

Configuration

I used mysql database for this project
create an .env and add appropiate values for your mysql setup
.env variables :
- DB_HOST=
- DB_USERNAME=
- DB_PWD=
- DB_NAME=file-test

Host, username, password and database name

My database name is file-test

SQL file

Import sql file from mysql/file-test.sql

Run

python app.py

Publish/Subscribe Model

John Pinto — Tue, 30 May 2023 09:29:10 +0000

What is publish/subscribe (pub/sub) model ?

The publish/subscribe (pub/sub) model is a messaging pattern in which publishers send messages to a message broker, and subscribers express interest in receiving certain messages. The message broker is responsible for delivering the messages to the subscribed clients.

In the pub/sub model, publishers and subscribers are decoupled, meaning that they do not need to be aware of each other’s existence in order to communicate. This allows for a more flexible and scalable system, as publishers and subscribers can be added or removed without affecting the others.

Pub/sub systems can be implemented using a variety of technologies, such as message queues, event buses, and topic-based publish/subscribe systems. They are commonly used in distributed systems, microservices architectures, and event-driven architectures.

What are ‘topics’ in pub/sub?

In a publish/subscribe system, topics are used to categorize messages and allow subscribers to express interest in specific types of messages.

In a topic-based publish/subscribe system, publishers send messages to specific topics, and subscribers express interest in one or more topics. The message broker is responsible for delivering the messages to the subscribed clients.

For example, in a news publishing system, there may be topics for different categories of news, such as politics, sports, and entertainment. Subscribers can express interest in receiving messages from specific topics, such as only sports and entertainment. When a publisher sends a message to the sports topic, it will be delivered to all subscribers interested in that topic.

Using topics allows for more fine-grained control over the messages that are delivered to subscribers, as they can choose to receive only the messages that are relevant to them. It also allows for a more scalable system, as publishers and subscribers do not need to be aware of each other’s specific identities.

Events in pub/sub

Events are messages that are published by a publisher and delivered to subscribed clients.

An event is typically a notification of something that has happened or is about to happen. It can contain data about the event, such as the event type, a description, and any relevant details.

In an event-driven architecture, events are used to trigger actions or behaviors in other parts of the system. For example, an event might be used to notify a service that a new user has signed up, or that a payment has been processed. The service can then respond to the event by performing some action, such as sending a welcome email or updating a database.

Using events allows for a more flexible and scalable system, as publishers and subscribers do not need to be directly coupled and can communicate asynchronously. It also allows for a more decoupled and modular system, as components can respond to events without the need to be aware of the specific identities of the publishers.

Event Bus

An event bus is a messaging system that allows publishers to send events to subscribers. It is a type of publish/subscribe system that is commonly used in event-driven architectures.

In an event bus, events are published to a central message broker, which is responsible for delivering the events to the subscribed clients. Subscribers express interest in receiving events by registering with the event bus and specifying a list of events that they want to receive.

Example of pub/sub model in python

Example1: Basic publish/subscribe model implemented using Python’s built-in `queue` module:

Here the Publisher class has a message queue and a list of subscribers. When a message is published using the publish method, it is added to the queue and delivered to all subscribed clients by calling their receive method. The Subscriber class has a receive method that simply prints the received message.

import queue

class Publisher:
    def __init__(self):
        self.message_queue = queue.Queue()
        self.subscribers = []

    def subscribe(self, subscriber):
        self.subscribers.append(subscriber)

    def publish(self, message):
        self.message_queue.put(message)
        for subscriber in self.subscribers:
            subscriber.receive(message)

class Subscriber:
    def __init__(self, name):
        self.name = name

    def receive(self, message):
        print(f"{self.name} received message: {message}")

# Example usage
publisher = Publisher()

subscriber_1 = Subscriber("Subscriber 1")
subscriber_2 = Subscriber("Subscriber 2")

publisher.subscribe(subscriber_1)
publisher.subscribe(subscriber_2)

publisher.publish("Hello World")
# Output:
# "Subscriber 1 received message: Hello World"
# "Subscriber 2 received message: Hello World"

Example2: Publish/Subscribe model implemented using Python’s threading module, the Event class, and a dictionary to store subscribers by topic :

import threading

class Publisher:
    def __init__(self):
        self.subscribers = {}

    def subscribe(self, subscriber, topic):
        if topic not in self.subscribers:
            self.subscribers[topic] = []
        self.subscribers[topic].append(subscriber)

    def publish(self, message, topic):
        if topic in self.subscribers:
            for subscriber in self.subscribers[topic]:
                subscriber.event.set()
                subscriber.message = message

class Subscriber:
    def __init__(self, name):
        self.name = name
        self.event = threading.Event()
        self.message = None

    def receive(self):
        self.event.wait()
        print(f"{self.name} received message: {self.message}")
        self.event.clear()

# Example usage
publisher = Publisher()

subscriber_1 = Subscriber("Subscriber 1")
subscriber_2 = Subscriber("Subscriber 2")
subscriber_3 = Subscriber("Subscriber 3")

publisher.subscribe(subscriber_1, "sports")
publisher.subscribe(subscriber_2, "entertainment")
publisher.subscribe(subscriber_3, "sports")

publisher.publish("Soccer match result", "sports")
# Output:
# "Subscriber 1 received message: Soccer match result"
# "Subscriber 3 received message: Soccer match result

In this example, the Publisher class has a dictionary of subscribers, where the keys are topics and the values are lists of subscribers. The subscribe method adds a subscriber to the list for the specified topic. The publish method checks if there are any subscribers for the specified topic and, if there are, sets the event and stores the message for each subscriber. The Subscriber class and receive method are the same as in the previous example.

This implementation allows subscribers to express interest in specific topics and receive only the messages that are relevant to them. It also allows the publisher to publish messages to specific topics without needing to be aware of the specific identities of the subscribers.

php-bard-api

John Pinto — Thu, 18 May 2023 07:02:25 +0000

php-bard-api

A package that returns Response of Google Bard through API

Prerequisites

PHP 8.1
composer

Install

 composer require pj8912/php-bard-api

Usage

<?php
require_once 'vendor/autoload.php';
use Pj8912\PhpBardApi\Bard;

$_ENV['_BARD_API_KEY'] = "Your Key";

$bard = new Bard();
$input_text = "Hello, Bard!";  // Input text for the conversation
$result = $bard->get_answer($input_text);  

// Access the result data
$conversation_id = $result["conversation_id"];
$response_id = $result["response_id"];
$factualityQueries = $result["factualityQueries"];
$textQuery = $result["textQuery"];
$choices = $result["choices"];

// reply for query 
$content = $result["content"];
print($content);
?>

Github

https://github.com/pj8912/php-bard-api

Terminal Chat with Bard using bardAPI and Python

John Pinto — Tue, 16 May 2023 11:51:51 +0000

So I took a look at BardAPI on Github and built a simple terminal chat using python

BardAPI : https://github.com/dsdanielpark/Bard-API

My Github : https://github.com/pj8912/terminal_chat

Get the key as per the instruction on BARDAPI
Create a .env on the root folder and assign that value BARD_API_KEY variable

Code

import os
from dotenv import load_dotenv
from bardapi import Bard
load_dotenv()
os.environ['_BARD_API_KEY'] = os.getenv("BARD_API_KEY")
bard = Bard()
print('\n','*'*50,'Terminal Chat with BARD','*'*50, '\n')
try:
    while True:
        user_input = input('\U0001F464 You: ')
        print('')
        print('\U0001F916 Bard:', bard.get_answer(user_input.strip())['content'])
        print('-'*100, "\n")
except KeyboardInterrupt:
    print('Ended Chat!')
except:
    print('Ended Chat!')

As per the documentation the os.environ['_BARD_API_KEY'] is assigned the your BARD_API_KEY

Run

Run the script to start chatting with Bard

$ python app.py

ENJOY!

Lokalnotes - onBrowser notesapp

John Pinto — Tue, 09 May 2023 15:42:54 +0000

A notesapp that stores notes on your browser. Lokalnotes uses localStorage to store the notes data on your localStorage.

This will stay on your browser and will be cleared when you chose to do it manually or enabled during your browser history deletion. So it's up to you whether it stays on the browser

Why browser?

We have seen many notes application(online/offlie) and I have built one myself using PHP and SQLite so offline and on-disk storage. These are somewhat created to manage multiple features including media. These note-taking apps can't considered for quick and easy to use.

Lokalnotes is a lightweight and effective solution for managing your notes directly in your browser.

It's private, no registration required and very very easy to create and export as a .txt file.

Working and Features

In Lokalnotes we can,

Create new note
Delete all notes
Copy a note
Download a note
Delete a note

Create Note

When you create a note, a item notesData is set in localstorage and the values are stored as json converted to string.

We leverage this to create multiple notes as values for a single localstorage key, since data in localstorage are stored as key-value pairs.

LocalStorage

key : notesData, 
value : {"1683644984302": "hi", "1683644984469": "bye"}

When a note is created the note name is current timestamp. So we can create, read, update and delete a note the same we would if we use a database.

Write and Save Note

A textarea will open up at the side when you click on the notename. The clicked notename will be in bold and background converted to whitesmoke to highlight the current note you are working on.

Click 'Save Note' button to save. You can see the 'Note Saved' message at the sidenav.

You can also check the localStorage to look at your stored notes 👇

Copy and Download

Copy

Foreach note created, we can copy the contents of the note by clicking the copy icon.

You can see a popup message confirming that the contents of the note are copied to the clipboard.

Download

For download, the contents of that note will be downloaded as a .txt file with the notename as the filename.

Example :
value : {"1683644984302": "hi",...
will be downloaded as 1683644984302.txt

Techonolgies used

HTML
CSS
Javascript

Conclusion

Start using LokalNotes today and experience a hassle-free note-taking experience right in your favorite web browser.

DEV Community: John Pinto

Updated scenestamps post

Scenestamps: Your Cinephile Community

John Pinto ・ Jul 4 '24

Scenestamps: Your Cinephile Community

What is Scenestamps?

Why Scenes Matter

How Scenestamps Works

More Than Just Timestamps

For Every Kind of Movie Lover

Cross-Platform Freedom

Join the Scene Revolution

Nostrdev

Generate Key Pair

Add relays

Blog Automation using Python🐍& Blogger

Workflow

How @shnai0 built her first Open Source project with ChatGPT and Next.js. 10k users in 24 hours 🤯

File uploading in Flask

Upload to a folder

Upload to database from a folder

Project Installation

Requirements

Install

Configuration

Run

Publish/Subscribe Model

What is publish/subscribe (pub/sub) model ?

What are ‘topics’ in pub/sub?

Events in pub/sub

Event Bus

Example of pub/sub model in python

Example1: Basic publish/subscribe model implemented using Python’s built-in queue module:

Example2: Publish/Subscribe model implemented using Python’s threading module, the Event class, and a dictionary to store subscribers by topic :

php-bard-api

php-bard-api

Prerequisites

Install

Usage

Github

Terminal Chat with Bard using bardAPI and Python

Code

Run

ENJOY!

Lokalnotes - onBrowser notesapp

Why browser?

Working and Features

Create Note

LocalStorage

Write and Save Note

Copy and Download

Copy

Download

Techonolgies used

Conclusion

Example1: Basic publish/subscribe model implemented using Python’s built-in `queue` module: