Merge branch 'larymak:main' into main

Author: Neagu Marinel

AUTOMATION/PDF Page Color Counter/README.md

@@ -0,0 +1,63 @@
+<!--Please do not remove this part-->
+![Star Badge](https://img.shields.io/static/v1?label=%F0%9F%8C%9F&message=If%20Useful&style=style=flat&color=BC4E99)
+![Open Source Love](https://badges.frapsoft.com/os/v1/open-source.svg?v=103)
+
+# PDF Page Color Counter
+
+## 🛠️ Description
+This Python project provides a simple yet powerful tool for analyzing PDF documents and counting the number of black and color pages. Whether you're working on document analysis, quality control, or just curious about the composition of your PDF files, this code helps you gain insights into the document's visual characteristics.
+
+**Key Features:**
+
+* Easy Integration: With a few lines of code, you can integrate this functionality into your Python applications or workflows.
+
+* PDF Expertise: Utilizing the PyMuPDF (MuPDF) library, this project efficiently processes PDF files, making it suitable for a wide range of applications.
+
+* Color Page Detection: It accurately identifies color and black & white pages within the PDF document, providing valuable statistics.
+
+* Use Cases: This code can be employed in various scenarios, such as document archiving, printing optimization, or content analysis.
+
+## ⚙️ Languages or Frameworks Used
+- **Python**: The primary programming language used for the project.
+- **FastAPI**: A modern, fast (high-performance) web framework for building APIs with Python.
+- **PyMuPDF (MuPDF)**: A lightweight and efficient PDF processing library for Python.
+- **OpenCV**: Used for image analysis and processing.
+- **Pillow (PIL)**: Python Imaging Library for working with images.
+
+## 🌟 How to run
+ - ### Install all the requirements
+    Run `pip install -r requirements.txt` to install all the requirements.
+ - ### Setup a Virtual Enviroment
+
+   - Run this command in your terminal `python -m venv myenv`.
+   - Change your directory by `cd myenv/Scripts` if on windows.
+   - Activate the virtual enviroment by running this command `source activate`.
+   - Move out from virtual env to your **Project Directory** by `cd..` .
+   - Install the packages if not present - `uvicorn`, `fastapi`, `fitz`, `frontend`, `tools`, `opencv-python`, `pillow`, `python-multipart`, `PyMuPDF`.
+   ```
+   pip install uvicorn fastapi fitz frontend tools opencv-python pillow python-multipart PyMuPDF
+   ```
+
+- ###  Now Just, Run the project
+   
+   -Now Run the following command - `uvicorn main:app --reload`.
+   -Open the localhost link on your browser and put `/docs` at your endpoint to see the fastapi docs UI.
+   ![Screenshot 2023-10-25 134746](https://github.com/Om25091210/Count-Color-Black-Pages-PDF/assets/74484315/2b5b64a2-1c00-4a5a-ab7c-99fb30e7aba6)
+
+   -Now, Click on **POST** and then **Try it out**.
+   -Click on **Choose file** to select a pdf, which you want to count the number of black and color pages.
+   -Click on **Execute**.
+
+
+## 📺 Demo
+![Screenshot 2023-10-25 133406](https://github.com/Om25091210/Count-Color-Black-Pages-PDF/assets/74484315/a84def7c-7db4-4ab5-bf0b-f8cfe5ded66b)
+
+
+## 🤖 Author
+
+Github - [OM YADAV](https://github.com/Om25091210)
+LinkedIn - [OM YADAV](www.linkedin.com/in/omyadav)
+
+
+
+

AUTOMATION/PDF Page Color Counter/main.py

@@ -0,0 +1,51 @@
+from fastapi import FastAPI, UploadFile, File
+import fitz
+import cv2
+from PIL import Image
+import numpy as np
+import os
+
+app = FastAPI()
+
+@app.post("/")
+async def get_pdf(file : UploadFile = File(...)):
+    #Initializing our variables.
+    colored_page_count = 0
+    color_list=[]
+    black_list=[]
+    num = 0
+    black_count = 0
+    #Getting the file name and then saving it in local.
+    contents = await file.read()
+    with open(file.filename, "wb") as f:
+        f.write(contents)
+    # Open the PDF file
+    # Get the full path to the uploaded file
+    file_path = os.path.join(os.getcwd(), file.filename)
+    print(file_path)
+    with fitz.open(file_path) as doc:
+        print(doc)
+        # Iterate through the pages
+        for _, page in enumerate(doc):
+            # Render the page to an image
+            pix = page.get_pixmap(alpha=False)
+            img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
+            
+
+            arr = np.array(img)
+            arr_mean = cv2.mean(arr)
+            if not (arr_mean[0] == arr_mean[1] == arr_mean[2]):
+                colored_page_count += 1
+                num += 1
+                color_list.append(num)
+                #print('colored', num)
+            else:
+                num += 1
+                black_count += 1
+                black_list.append(num)
+                #print('Black', num)
+        print("\nColored Pages: ",color_list,"\n")
+        print("Black & White Pages: ",black_list)
+        #Close the file
+    os.remove(file_path)    
+    return {"colored : ":colored_page_count,"Black Count : ":black_count} 

AUTOMATION/PDF Page Color Counter/requirements.txt

@@ -0,0 +1,16 @@
+anyio==3.6.2
+click==8.1.3
+colorama==0.4.6
+fastapi==0.92.0
+h11==0.14.0
+idna==3.4
+numpy==1.24.2
+opencv-python==4.7.0.72
+Pillow==9.4.0
+pydantic==1.10.5
+PyMuPDF==1.21.1
+python-multipart==0.0.6
+sniffio==1.3.0
+starlette==0.25.0
+typing_extensions==4.5.0
+uvicorn==0.20.0

AUTOMATION/PDF Page Color Counter/static/Screenshot 2023-10-25 133406.png

@@ -0,0 +1,44 @@
+# Introduction
+
+This Python program is a web scraper that extracts data about graphics cards from a specific website. It uses the BeautifulSoup library to parse the HTML content of the website and requests library to fetch the web page.
+
+## Requirements
+
+- Python 3.x
+- BeautifulSoup library (`beautifulsoup4`)
+- Requests library (`requests`)
+- Openpyxl library (`openpyxl`)
+
+You can install the required libraries using pip:
+
+```
+pip install beautifulsoup4 requests openpyxl
+```
+
+## How to Use
+
+1. Clone this repository or download the files.
+
+2. Open a terminal or command prompt and navigate to the project directory.
+
+3. Run the Python script `app.py`:
+
+```
+app.py
+```
+
+4. The program will start scraping data from the website and display the brand, name, and price of each graphics card on the console.
+
+5. Once the scraping is complete, the program will save the data to an Excel file named `Graphics Card.xlsx`.
+
+## Configuration
+
+You can modify the URL in the `scrape_graphics_cards_data()` function inside the `app.py` file to scrape data from a different website or adjust the parameters as needed.
+
+## Output
+
+The program will generate an Excel file `Graphics Card.xlsx` containing the scraped data. Each row in the Excel file represents a graphics card and includes the columns `Brand`, `Name`, and `Price`.
+
+## Disclaimer
+
+This web scraper is provided for educational and informational purposes only. Please be respectful of the website's terms of service and scraping policies. Always obtain proper authorization before scraping any website, and use the scraper responsibly and ethically.

AUTOMATION/PDF Page Color Counter/static/image.png

@@ -0,0 +1,54 @@
+from bs4 import BeautifulSoup
+import requests
+import openpyxl
+
+
+def extract_brand_name_and_title(name):
+    # Split the name and return the first word as the brand name and the rest as title
+    brand, title = name.split(' ', 1)
+    return brand, title
+
+
+def scrape_graphics_cards_data():
+    try:
+        # Create a new Excel workbook and set up the worksheet
+        excel = openpyxl.Workbook()
+        sheet = excel.active
+        sheet.title = "price"
+        sheet.append(['Brand', 'Name', 'Price'])
+
+        url = 'https://www.techlandbd.com/pc-components/graphics-card?sort=p.price&order=ASC&fq=1&limit=100'
+        response = requests.get(url)
+        response.raise_for_status()
+
+        # Parse the HTML content
+        soup = BeautifulSoup(response.text, 'html.parser')
+
+        # Find all product cards on the webpage
+        cards = soup.find('div', class_='main-products product-grid').find_all(
+            'div', class_='product-layout has-extra-button')
+
+        for card in cards:
+            # Extract the product name
+            name = card.find('div', class_='name').a.text
+
+            # Split the name to get the brand and title
+            brand, title = extract_brand_name_and_title(name)
+
+            # Extract the product price
+            price = card.find('div', class_='price').span.text
+
+            # Print the product details and add them to the Excel sheet
+            print(brand, title, price)
+            sheet.append([brand, title, price])
+
+        # Save the Excel file
+        excel.save('Graphics Card.xlsx')
+
+    except Exception as e:
+        print("An error occurred:", e)
+
+
+if __name__ == "__main__":
+    # Call the main scraping function
+    scrape_graphics_cards_data()

AUTOMATION/Web_Scraper/Graphics Card.xlsx

@@ -0,0 +1,9 @@
+# Genetic Algorithms in Problem Solving
+
+## Overview
+This repository contains implementations of genetic algorithms (GAs) applied to solve various problems. Genetic algorithms are a family of optimization algorithms inspired by the process of natural selection. They are commonly used to find solutions for complex, non-linear, and multi-objective optimization problems. This collection demonstrates the application of GAs to address different problem domains.
+
+
+## Problem Domains
+- [Knapsack Problem](./knapsack/): Applying GAs to find the best combination of items within a weight limit.
+

AUTOMATION/Web_Scraper/README.md

@@ -0,0 +1,123 @@
+import random
+import matplotlib.pyplot as plt
+
+"""
+This program uses a genetic algorithm to solve the 0/1 Knapsack problem. 
+In the Knapsack problem, you are given a set of items, each with a value and a weight, 
+and a knapsack with a weight limit. The goal is to select a combination of items 
+to maximize the total value without exceeding the weight limit. 
+This genetic algorithm iteratively evolves a population of candidate solutions to find the best combination.
+
+Knapsack Problem Parameters:
+- weight_limit: The weight limit of the knapsack.
+- item_list: A list of items, where each item is represented as (value, weight).
+
+Genetic Algorithm Parameters:
+- population_size: The size of the population.
+- max_generations: The maximum number of generations to run.
+- mutation_rate: The probability of mutation for each gene in the chromosome.
+- chromosome_length: The number of genes in each chromosome.
+"""
+
+# Knapsack Problem Parameters
+weight_limit = 56
+item_list = [(17, 1), (78, 20), (56, 34), (2, 15), (34, 21), (3, 10)]  # (value, weight)
+
+# Genetic Algorithm Parameters
+population_size = 100
+max_generations = 300
+mutation_rate = 0.5
+chromosome_length = len(item_list)
+
+
+def initialize_population():
+    # Initialize the population with random chromosomes
+    population = []
+    for _ in range(population_size):
+        chromosome = [random.randint(0, 1) for _ in range(chromosome_length)]
+        population.append(chromosome)
+    return population
+
+
+def calculate_fitness(chromosome):
+    # Calculate the fitness of a chromosome based on its value and weight
+    total_value = 0
+    total_weight = 0
+    for gene, item in zip(chromosome, item_list):
+        if gene == 1:
+            total_value += item[0]
+            total_weight += item[1]
+    if total_weight > weight_limit:
+        return 0  # Violates weight constraint
+    return total_value
+
+
+def selection(population):
+    # Select individuals from the population based on their fitness
+    selected = []
+    total_fitness = sum(calculate_fitness(chromosome) for chromosome in population)
+    for _ in range(population_size):
+        r = random.uniform(0, total_fitness)
+        cumulative_fitness = 0
+        for chromosome in population:
+            cumulative_fitness += calculate_fitness(chromosome)
+            if cumulative_fitness >= r:
+                selected.append(chromosome)
+                break
+    return selected
+
+
+def crossover(parent1, parent2):
+    # Perform one-point crossover to create two children
+    crossover_point = random.randint(1, chromosome_length - 1)
+    child1 = parent1[:crossover_point] + parent2[crossover_point:]
+    child2 = parent2[:crossover_point] + parent1[crossover_point:]
+    return child1, child2
+
+
+def mutation(chromosome):
+    # Apply mutation to a chromosome with a given probability
+    mutated_chromosome = chromosome[:]
+    for i in range(chromosome_length):
+        if random.random() < mutation_rate:
+            mutated_chromosome[i] = 1 - mutated_chromosome[i]
+    return mutated_chromosome
+
+
+def genetic_algorithm():
+    # Main genetic algorithm loop
+    population = initialize_population()
+    fitness_history = []
+    for generation in range(max_generations):
+        population = selection(population)
+        new_population = []
+        while len(new_population) < population_size:
+            parent1 = random.choice(population)
+            parent2 = random.choice(population)
+            child1, child2 = crossover(parent1, parent2)
+            mutated_child1 = mutation(child1)
+            mutated_child2 = mutation(child2)
+            new_population.extend([mutated_child1, mutated_child2])
+        
+        best_fit = max(calculate_fitness(chromosome) for chromosome in new_population)
+        fitness_history.append(best_fit)
+        
+        population = new_population
+
+    best_chromosome = max(population, key=calculate_fitness)
+    best_fitness = calculate_fitness(best_chromosome)
+
+    return best_chromosome, best_fitness, fitness_history
+
+
+# Run the genetic algorithm and print the result
+best_solution, best_fitness_value, fitness_history = genetic_algorithm()
+print("Best Solution:", best_solution)
+print("Best Fitness Value:", best_fitness_value)
+
+# Plot fitness history
+plt.plot(fitness_history)
+plt.title('Fitness History')
+plt.xlabel('Generation')
+plt.ylabel('Fitness')
+plt.show()