DEV Community: Yassine Sallami

📈✨9 Free (or access option) computer science courses for building your skills!

Yassine Sallami — Fri, 01 Nov 2024 18:51:05 +0000

Harvard CS50: Introduction to Computer Science (edX)

A comprehensive intro to CS, covering everything from algorithms to web development.

Python for Everybody (Coursera, University of Michigan)

Perfect for beginners wanting to learn Python and programming fundamentals.

Algorithms Specialization (Coursera, Stanford University)

Dive deep into core CS algorithms with hands-on problem-solving.

Introduction to Data Science (Kaggle)

Covers Python basics, data visualization, and data analysis.

Introduction to Artificial Intelligence (Udacity)

A beginner's course on AI covering search algorithms, knowledge representation, and more.

Machine Learning (Coursera, Andrew Ng)

A highly popular course explaining ML concepts in a simple, beginner-friendly way.

HTML, CSS, and JavaScript for Web Developers (Coursera, Johns Hopkins University)

Learn the basics of web development and start building web pages.

Introduction to Cybersecurity (University of Washington, edX)

Covers essential concepts in digital security and data protection.

Google IT Automation with Python (Coursera)

Develop Python skills to automate tasks and solve real-world problems.

🛠️ Command Line Tips for Boosting Efficiency

Yassine Sallami — Sat, 26 Oct 2024 21:41:00 +0000

Ever found yourself needing to search through your command history? Here are some quick tricks to make your terminal life easier:

🔍 Search History

You can instantly rerun your last command by typing !!. Want to search for a specific command you ran? Pair history with grep:

$ history | grep conda
3 conda activate dnakey
5 history | grep conda

Need only your last few commands? Try using tail:

$ history | tail -n 3
4 history
5 history | grep conda
6 history | tail -n 3

💡 Quick Command Fix
Made a typo in your last command? Use ^oldtext^newtext^ to replace part of it without retyping everything. For example:

$ ^conda^pip^

This reruns the previous command, but with conda replaced by pip.

🧹 Cleaning Up History
Need to delete a specific command from your history? Just specify the line number:

$ history -d <line number>

Or clear your entire history file with history -c.

These shortcuts make navigating your command history faster and more efficient.

#? List vs Tuples in python

Yassine Sallami — Sat, 26 Oct 2024 00:34:39 +0000

In Python, Lists and Tuples are both sequence data types that can store collections of items, but they have some crucial differences that impact performance, flexibility, and usage.

1. Mutability
Lists are mutable, meaning you can modify, add, or remove items after creation.
Tuples are immutable, so once created, their elements cannot be changed.

2. Syntax
Lists use square brackets: a = [1, 2, 3, 4, 5]
Tuples use parentheses: b = (1, 2, 3, 4, 5)

3. Performance
Tuples are generally faster than lists due to their immutability.
If you don’t need to modify the data, using a tuple can make your code slightly more efficient.

4. Use Cases
Lists are preferred for collections that require frequent updates, like adding, removing, or changing items.
Tuples are best for fixed data collections, like storing coordinates (x, y) or returning multiple values from a function.

5. Methods
Lists have more built-in methods like .append(), .remove(), .reverse(), which allow in-place modifications.
Tuples have fewer methods since they are immutable.

📛Stop Hardcoding Database Calls: Simplify with a Config Manager

Yassine Sallami — Fri, 25 Oct 2024 00:55:42 +0000

Working with databases is inevitable in any modern software project. However, hardcoding database connections and operations in your main code can lead to poor scalability, difficult maintenance, and security issues. To combat these challenges, consider creating a Config Manager to handle all interactions with your database efficiently.
In this post, we'll walk through the advantages of using a Config Manager and how it can be implemented. Let’s start by looking at an example in Python using MongoDB and Streamlit.

Why You Shouldn't Call Your Database Directly
When your application grows, having direct database calls littered throughout the code can cause:

Hard to manage changes: If you need to change database settings or schema, you have to search through your codebase to modify each instance.
Lack of centralized error handling: Error-prone operations, such as connecting to the database or handling connection timeouts, become harder to manage when scattered.
Tight coupling: Direct database operations in the main code introduce tight coupling, making the code harder to test and refactor.

To avoid these issues, you should encapsulate database operations inside a Config Manager.

What is a Config Manager?
A Config Manager is a class or module that centralizes all database operations, handles error management, and makes your code more modular. It abstracts the details of the database, providing clean methods to interact with it.

Example: MongoDB Config Manager

import streamlit as st
from pymongo import MongoClient
from pymongo.errors import ServerSelectionTimeoutError, AutoReconnect
from dotenv import load_dotenv
import os, datetime

load_dotenv()

# Get MongoDB URI from environment variables
mongo_uri = os.getenv("MONGODB_URI")

class ConfigManager:
    def __init__(self, user_id: str, db_name: str = "your_database", collection_name: str = "your_collection") -> None:
        self.user_id = user_id
        self.client = self.connect_to_mongo(mongo_uri)

        if self.client:
            self.db = self.client[db_name]
            self.collection = self.db[collection_name]
            self.user = self.collection.find_one({"badge_id": self.user_id})
            self.create_date = datetime.datetime.now()
            self.formatted_datetime = self.create_date.isoformat()

            if not self.user:
                self.add_new_user()
                self.user = self.collection.find_one({"badge_id": self.user_id})
        else:
            st.toast(":red[Failed to connect to MongoDB. User initialization aborted.]")

    def connect_to_mongo(self, uri, retries=3):
        client = None
        for attempt in range(retries):
            try:
                print(f"Attempting to connect to MongoDB (Attempt {attempt + 1})")
                client = MongoClient(uri, serverSelectionTimeoutMS=20000)
                client.server_info()  # Will raise an exception if unable to connect
                print("Connection to MongoDB successful.")
                return client
            except ServerSelectionTimeoutError as err:
                print(f"Connection attempt {attempt + 1} failed: {err}")
            except AutoReconnect as err:
                print(f"AutoReconnect error on attempt {attempt + 1}: {err}")
        print(f"Failed to connect to MongoDB after {retries} attempts.")
        return None

    def add_new_user(self):
        new_user = {
            "badge_id": self.user_id,
            "created_at": self.formatted_datetime,
            "badge_usage": 0,
            "created_docs": 0,
            "limitation": 10,
            "doc_params": self._get_default_doc_params(),
            "security": self._get_default_security(),
            "user_activity": {"vault": [], "action_merge": []}
        }
        self.collection.insert_one(new_user)

    def _get_default_doc_params(self) -> dict:
        return {
            "includes": ["upper", "lower", "number", "symbol", "arabic"],
            "input": {"length": {"max": 13, "min": 3}, "types": ["text", "image", "pdf", "audio", "video"]}
        }

    def _get_default_security(self) -> dict:
        return {"encryption": "cryptography.fernet", "encrypted_data": "json format", "file_extension": ".dkp"}

Key Features of the Config Manager

Centralized Database Handling: The ConfigManager is responsible for connecting to the MongoDB database. By abstracting this logic, you ensure that the rest of the application doesn’t need to worry about connection details or handling retries.
Automatic User Initialization: When a user (in this case identified by user_id) interacts with the application, the manager checks if the user exists in the database. If not, it automatically creates a new user record, maintaining consistency in your database operations.
Retry Logic: The connect_to_mongo() method includes a retry mechanism for connection failures. This reduces the likelihood of total failure and ensures resilience in unstable network environments.
Separation of Concerns: The rest of the application doesn’t need to know about database internals, reducing dependencies and making it easier to modify database behavior in the future.

Benefits of Using a Config Manager

Easier Maintenance: By having all database interactions in one place, it’s easier to update or debug any issues related to the database.
Error Handling: With a Config Manager, you can define custom error-handling logic that applies to all database interactions, avoiding unexpected crashes due to database timeouts or connection issues.
Scalability: When your project grows, you won’t need to refactor code scattered across different modules. You can easily add new database operations or modify existing ones in the manager.
Enhanced Security: Database URIs and other sensitive information are abstracted away from the main code and retrieved securely using environment variables.

Conclusion

A Config Manager is essential for building scalable and maintainable applications that interact with databases. It allows you to centralize connection logic, error handling, and security concerns. By abstracting these details away from the main code, you create a cleaner, more modular, and future-proof project structure.

Instead of hardcoding database operations in your main application, invest in building a Config Manager and see the difference it makes in your code’s cleanliness and maintainability.

Thank you for reading my post :)

How to create an image authentication system with python streamlit and canva!

Yassine Sallami — Wed, 23 Oct 2024 22:54:04 +0000

The includes

import streamlit as st
import # your database manager here!
from cryptography.fernet import Fernet
from PIL import Image, PngImagePlugin
import base64, hashlib, uuid

Initialize a session with streamlit if you want to

def initialize_session_state():
   pass

The main script:

class BadgeConfig:
        def __init__(self):
          initialize_session_state()
          # Ensure badge_id is stored as a class attribute
          self.badge_id = None

        # Generate a SHA-256 hash from image data
        def generate_image_hash(self, image_data):
            return hashlib.sha256(image_data).hexdigest()

        # Create the encryption signature using Fernet
        def create_signature(self, unique_id):
            id_image_bytes = unique_id.encode("utf-8")
            # Ensure 32-byte length
            padded_id_image_bytes = id_image_bytes.ljust(32)[:32] 
            encoded_key = base64.urlsafe_b64encode(padded_id_image_bytes)
            return Fernet(encoded_key)

        # Check if image was created on Canva using PngImagePlugin
        def is_canva_image(self, image):
            if isinstance(image, PngImagePlugin.PngImageFile):
                # Extract metadata from the image
                metadata = image.info  # Info contains the metadata

                # Checking if 'Canva' appears in the 'xmp:CreatorTool' field
                xmp_metadata = metadata.get('XML:com.adobe.xmp', '')
                if "Canva" in xmp_metadata:
                    return True
                return False

        # Display the uploaded badge and validate its dimensions and source
        def process_image(self, user_badge):
            try:
                image = Image.open(user_badge)
                WIDTH, HEIGHT = image.size
                if WIDTH != 1080 or HEIGHT != 1920:
                    st.warning("This is not a valid dnakey-badge!")
                    st.stop()

                # Check if the image is created on Canva
                if not self.is_canva_image(image):
                    st.warning("The uploaded image is not a Canva PNG image!")
                    st.stop()

                st.image(user_badge, caption="Uploaded Image", use_column_width=True)

                # Reset the file pointer and read the image data for hashing
                user_badge.seek(0)
                return user_badge.read()
            except Exception as e:
                st.error(f"Error processing the image: {str(e)}")
                st.stop()

        # Handle badge activation and update session
        def activate_badge(self, badge_usage, config_manager):
            if not st.session_state['toast_shown']:
                st.toast("**:blue[Your Id Badge is activated now!]**", icon="🧁")
                st.session_state['toast_shown'] = True

            if not st.session_state['usage_updated'] and badge_usage > 0:
                config_manager.update_usage_badge_count()
                st.session_state['usage_updated'] = True

        # Main function to create a session and handle badge logic
        def create_session(self, user_badge):
            # Process image and generate its unique ID
            image_data = self.process_image(user_badge)
            unique_id = self.generate_image_hash(image_data)

            # Create an encryption signature
            signature = self.create_signature(unique_id)

            # Create a UUID (version 5) based on the existing unique_id
            self.badge_id = str(uuid.uuid5(uuid.NAMESPACE_DNS, unique_id))

            # Initialize config manager
            config_manager = ConfigManager(self.badge_id)
            badge_usage = config_manager.get_badge_usage()

            # Handle badge activation and session updates
            self.activate_badge(badge_usage, config_manager)

            return signature, self.badge_id  # Return the badge_id as well

# call the script
with st.sidebar:
     st.title("Log-In Here:")
     with st.popover("Upload Your Agent Badge!", use_container_width=True):
     user_badge = st.file_uploader("Your Agent Badge!", type=["png"], key="agent_badge")

     if user_badge:
        # User badge is uploaded
        signature, badge_id = BadgeConfig().create_session(user_badge)

Introducing the DNA-KEY System: Taking the Password Generator to the Next Level! 🔐

Yassine Sallami — Wed, 23 Oct 2024 21:49:46 +0000

🚀 Introducing the DNA-KEY System: Taking the Password Generator to the Next Level! 🔐

Our innovative DNA-KEY system integrates cryptographic techniques to ensure document integrity and protection (the document acts like a brain 🧠). Here’s a sneak peek of how it works:

🖼️ Badge Verification:
Your user badge (image type) is transformed into a unique hash, which is then turned into a user ID and a signature for the document, ensuring only original images are accepted.

🔒 Document Validation:
Documents are securely linked to badge IDs, with a checksum ensuring data consistency. The engine creates smart documents that are compressed, encrypted, and personalized with the user’s signature.

🧑‍💻 Complex Password Generation:
A text or hybrid input system (more on the hybrid type next time!) turns simple keys into complex passwords, ensuring top-tier security for every document.

📂 Database Integration:
Store and track user activity, document IDs, and checksums for robust auditing and transparency.
Note: Dna-Key does not store your signature.

Stay tuned for more updates on how the DNA-KEY system is pushing the boundaries of security!