Python Projects

This application is a data visualization and business intelligence tool developed in Python. It is designed to process and visualize data from CSV or Excel files in an intuitive and interactive manner. Built using the PyQt5 library for the graphical user interface, pandas for data manipulation, and matplotlib for generating various types of charts, the application follows a modular architecture for evolvability and maintainability.

• Platform & Technologies: Desktop application developed in Python using PyQt5 for the GUI. The UI layout is designed using Qt Designer, resulting in a `.ui` file that is converted to a Python script (`ui_mainwindow.py`). Custom styling is applied via a `.qss` file.
• Libraries Used: Leverages pandas for efficient data loading, processing, and manipulation (e.g., filtering, calculations). matplotlib is used for generating diverse graphical representations of the data.
• Data Source: The application can open and import data from external files, specifically supporting CSV and Excel (`.xlsx`) formats.
• Architecture: Structured modularly with distinct Python files for different concerns (e.g., `data_analyzer.py` for data processing and calculation logic, `plotter.py` for chart generation, `pandas_model.py` for data handling using pandas, `main_window.py` for UI logic).
• Functionalities & Modules: The application presents a tabbed interface:
  • Data (Données): Displays the imported data in a table. Includes filtering options to show specific subsets of the data based on column values (e.g., filtering sales data by 'Region' like 'Bretagne').
  • Summary (Résumé): Shows key business indicators (KPIs) calculated from the loaded data for a specified period (defined by date pickers). Examples shown include total revenue (Chiffre d'Affaires Total), number of orders (Nombre de Commandes), and average basket value (Panier Moyen).
  • Graphs (Graphiques): Allows users to select a type of analysis (e.g., Sales Trend (Curve), Sales by Region (Bars), Sales by Category (Bars), Sales Amount Distribution (Histogram)) and generate the corresponding plot using the data within the selected date range. Graphs can be interactively zoomed and panned.
  • File Operations: Includes buttons to 'Open File' (Ouvrir Fichier) for importing data and saving generated graphs as image files (e.g., PNG).
  • Help & Quit: Standard 'Help' (Aide) and 'Quit' (Quitter) buttons are available.
• Data Processing: The `data_analyzer.py` module provides functions to calculate aggregate metrics and filter data based on user input, providing the necessary data points for the summary and graphical modules. Date formatting is handled to ensure correct processing of date-based filters.

This tool serves as an effective example of building a desktop Business Intelligence application with Python, demonstrating strong data processing capabilities with pandas and flexible visualization through matplotlib, all wrapped in a user-friendly GUI developed with PyQt5.

This project is a desktop application I developed using Python, leveraging the Tkinter library for the graphical user interface and SQLite3 for data storage. Designed for an educational institution, the application provides a straightforward and minimal interface for managing teacher payroll information.

• Intuitive GUI: Developed using Tkinter, the interface is split into sections for teacher information and payroll calculation, providing an easy-to-use experience.
• Data Input and Management: Allows users to input and manage various teacher details such as name, contact information, and educational background.
• Payroll Calculation: Features a section to calculate the net salary based on variables like month, year, hours worked, and hourly rate. Supports specifying payment methods like bank transfer.
• Integrated Database (SQLite3): Utilizes an integrated SQLite3 database to persistently store all teacher and payroll records.
• Search Functionality: Enables quick retrieval of teacher information and their associated payroll data using a unique teacher code.
• Save and Reset: Provides functions to save new or updated payroll information to the database and a reset button to clear fields for new entries.
• PDF Report Generation: Generates a detailed pay slip in PDF format for printing or archiving, summarizing the payroll calculation and teacher details.
• Planned Features: Includes a placeholder for "Payroll History" functionality for future expansion.

This project demonstrates my skills in Python desktop application development, GUI design, database integration, and the implementation of data management and reporting features. It highlights my ability to create practical software tools for administrative tasks.

This desktop application, developed in Python using the PyQt5 library for its graphical user interface, is designed to create intelligent and ATS-friendly (Applicant Tracking System) résumés with the help of Artificial Intelligence. It aims to produce CVs that are clear, concise, visually appealing, and optimized to pass through automated recruitment filters while presenting information effectively to human recruiters.

• Platform & Libraries: Desktop application in Python using PyQt5 for the GUI. Integrates an AI model (demonstrated with Gemini API) for content generation.
• Purpose: Helps users create clear, concise, and visually appealing CVs optimized for both human recruiters and automated ATS software by focusing on relevant structure and keywords, avoiding artifice.
• UI Design: User interface designed with Qt Designer (.ui files), converted to Python code. Custom styling is applied via a `.qss` file to enhance visual appeal.
• Functionality:
  • Provides a structured interface with tabs for different sections of a CV (Identity/Contact, Résumé/Professional Accroche, Professional Experience, Skills, Education, Languages, Projects, Extras).
  • Automated generation of the professional summary/accroche using an AI model based on the provided information. This helps create a compelling and optimized summary.
  • Allows adding details for each section (e.g., work experience, education, skills, projects with links) in a structured manner.
  • Exports the complete CV to a PDF file, maintaining the designed layout and content.
  • Aims to produce CVs that bypass typical ATS filters by ensuring appropriate structure and content elements are present.

The Smart CV Builder demonstrates the power of combining GUI development with Python libraries for structured data input and AI integration to automate and optimize the creation of professional résumés for the competitive job market.

This project is a desktop application I developed using Python, leveraging the PyQT5 library for the graphical user interface and SQLite3 for data storage. Designed for managing a supermarket, the application provides an interface for handling products, sales, stock, and user administration, adhering to the Model-View-Controller (MVC) architectural pattern.

• GUI Development with PyQT5: The graphical user interface is built using PyQT5. UI elements were designed using QT Designer (generating `.ui` files) and converted into Python code (`.py` files) using `pyuic`. Custom styling is applied using CSS (`styles.css`).
• MVC Architecture: The application follows the MVC pattern:
  • `model.py`: Handles the business logic and interacts with the SQLite3 database (`supermarket.db`). It contains methods for CRUD (Create, Read, Update, Delete) operations on data like users, products, sales, and stock movements.
  • `view.py`: Contains the PyQT5 classes responsible for the visual presentation of the data and user interface elements. It doesn't contain business logic.
  • `controller.py`: Acts as the intermediary between the Model and the View. It receives user input from the View, processes it (often by interacting with the Model), and updates the View based on the results.
  • `main.py`: The application's entry point, responsible for initializing the PyQT5 application, showing the login dialog, and launching the main application window after successful authentication. It also handles application cleanup.
• User Authentication and Roles: Features a login dialog (`login_dialog.py`) requiring username and password. Supports different user roles (e.g., Administrator, Vendeuse/Salesperson) with varying permissions.
• Dashboard (`Accueil`): Displays summary statistics like the total number of products and users.
• Sales Management (`Ventes`): Allows users to select products from a dropdown (showing current stock), enter quantity, add items to a virtual cart, and validate sales.
• Product Management (`Produits`): Enables administrators to add, modify, and delete product information (Name, Category, Price, initial Stock). Requires administrator authentication for these actions.
• Stock Management (`Stock`): Provides statistics on the total value of the stock, total number of articles, products in rupture (out of stock or below a configurable low stock threshold), and products with low stock. Displays a history of stock movements (sales). Allows administrators to adjust stock levels for selected products, requiring authentication.
• User Configuration (`Paramètres`): Allows administrators to manage user accounts, including adding new users with specific roles (admin or salesperson) and deleting existing users. Requires administrator authentication.
• Reporting (PDF Export): The stock section includes functionality to export the sales history within a specified date range as a PDF report, optionally including details of products sold in each transaction.
• Database Integration (SQLite3): All application data (users, products, sales, stock movements) is persistently stored in a local SQLite3 database file (`supermarket.db`).

This project demonstrates my skills in Python desktop application development using PyQT5, implementing the MVC architectural pattern, integrating with an SQLite3 database, designing user interfaces, managing user authentication and permissions, and developing core business logic for a supermarket management system including sales, stock tracking, and reporting.