Untitled

 avatar
unknown
plain_text
8 days ago
8.1 kB
4
Indexable
Here's an example of a simple stock inventory management application using Python and Tkinter for the GUI, with SQLite for the database:

```python
import tkinter as tk
from tkinter import ttk, messagebox
import sqlite3
from datetime import datetime

class InventoryApp:
    def __init__(self, root):
        self.root = root
        self.root.title("Stock Inventory Management")
        
        # Database setup
        self.conn = sqlite3.connect('inventory.db')
        self.create_table()
        
        # Create GUI components
        self.create_widgets()
        self.view_inventory()

    def create_table(self):
        cursor = self.conn.cursor()
        cursor.execute('''CREATE TABLE IF NOT EXISTS items (
                        id INTEGER PRIMARY KEY,
                        name TEXT NOT NULL,
                        quantity INTEGER NOT NULL,
                        price REAL NOT NULL,
                        category TEXT,
                        last_updated TIMESTAMP)''')
        self.conn.commit()

    def create_widgets(self):
        # Input Frame
        input_frame = ttk.LabelFrame(self.root, text="Item Details")
        input_frame.grid(row=0, column=0, padx=10, pady=10, sticky="ew")

        # Input fields
        ttk.Label(input_frame, text="Name:").grid(row=0, column=0, padx=5, pady=5)
        self.name_entry = ttk.Entry(input_frame)
        self.name_entry.grid(row=0, column=1, padx=5, pady=5)

        ttk.Label(input_frame, text="Quantity:").grid(row=0, column=2, padx=5, pady=5)
        self.quantity_entry = ttk.Entry(input_frame)
        self.quantity_entry.grid(row=0, column=3, padx=5, pady=5)

        ttk.Label(input_frame, text="Price:").grid(row=1, column=0, padx=5, pady=5)
        self.price_entry = ttk.Entry(input_frame)
        self.price_entry.grid(row=1, column=1, padx=5, pady=5)

        ttk.Label(input_frame, text="Category:").grid(row=1, column=2, padx=5, pady=5)
        self.category_entry = ttk.Entry(input_frame)
        self.category_entry.grid(row=1, column=3, padx=5, pady=5)

        # Buttons
        button_frame = ttk.Frame(self.root)
        button_frame.grid(row=1, column=0, padx=10, pady=10, sticky="ew")

        ttk.Button(button_frame, text="Add Item", command=self.add_item).grid(row=0, column=0, padx=5)
        ttk.Button(button_frame, text="Update Quantity", command=self.update_quantity).grid(row=0, column=1, padx=5)
        ttk.Button(button_frame, text="Remove Item", command=self.remove_item).grid(row=0, column=2, padx=5)
        ttk.Button(button_frame, text="Generate Report", command=self.generate_report).grid(row=0, column=3, padx=5)

        # Inventory List
        self.tree = ttk.Treeview(self.root, columns=("ID", "Name", "Quantity", "Price", "Category"), show="headings")
        self.tree.grid(row=2, column=0, padx=10, pady=10, sticky="nsew")

        self.tree.heading("ID", text="ID")
        self.tree.heading("Name", text="Name")
        self.tree.heading("Quantity", text="Quantity")
        self.tree.heading("Price", text="Price")
        self.tree.heading("Category", text="Category")

    def view_inventory(self):
        # Clear current view
        for row in self.tree.get_children():
            self.tree.delete(row)
            
        # Get data from database
        cursor = self.conn.cursor()
        cursor.execute("SELECT * FROM items")
        rows = cursor.fetchall()
        
        # Insert data into treeview
        for row in rows:
            self.tree.insert("", "end", values=row)

    def add_item(self):
        name = self.name_entry.get()
        quantity = self.quantity_entry.get()
        price = self.price_entry.get()
        category = self.category_entry.get()
        
        if not name or not quantity or not price:
            messagebox.showerror("Error", "Please fill all required fields")
            return
            
        try:
            cursor = self.conn.cursor()
            cursor.execute("INSERT INTO items (name, quantity, price, category, last_updated) VALUES (?, ?, ?, ?, ?)",
                        (name, int(quantity), float(price), category, datetime.now()))
            self.conn.commit()
            self.view_inventory()
            self.clear_entries()
        except ValueError:
            messagebox.showerror("Error", "Invalid input format")

    def update_quantity(self):
        selected_item = self.tree.selection()
        if not selected_item:
            messagebox.showerror("Error", "Please select an item")
            return
            
        new_quantity = self.quantity_entry.get()
        if not new_quantity:
            messagebox.showerror("Error", "Please enter new quantity")
            return
            
        try:
            item_id = self.tree.item(selected_item)['values'][0]
            cursor = self.conn.cursor()
            cursor.execute("UPDATE items SET quantity = ?, last_updated = ? WHERE id = ?",
                        (int(new_quantity), datetime.now(), item_id))
            self.conn.commit()
            self.view_inventory()
            self.clear_entries()
        except ValueError:
            messagebox.showerror("Error", "Invalid quantity format")

    def remove_item(self):
        selected_item = self.tree.selection()
        if not selected_item:
            messagebox.showerror("Error", "Please select an item")
            return
            
        item_id = self.tree.item(selected_item)['values'][0]
        cursor = self.conn.cursor()
        cursor.execute("DELETE FROM items WHERE id = ?", (item_id,))
        self.conn.commit()
        self.view_inventory()

    def generate_report(self):
        cursor = self.conn.cursor()
        cursor.execute("SELECT * FROM items")
        rows = cursor.fetchall()
        
        with open("inventory_report.txt", "w") as f:
            f.write(f"Inventory Report - {datetime.now()}\n\n")
            f.write("ID\tName\tQuantity\tPrice\tCategory\n")
            for row in rows:
                f.write(f"{row[0]}\t{row[1]}\t{row[2]}\t{row[3]}\t{row[4]}\n")
                
        messagebox.showinfo("Success", "Report generated successfully")

    def clear_entries(self):
        self.name_entry.delete(0, tk.END)
        self.quantity_entry.delete(0, tk.END)
        self.price_entry.delete(0, tk.END)
        self.category_entry.delete(0, tk.END)

    def __del__(self):
        self.conn.close()

if __name__ == "__main__":
    root = tk.Tk()
    app = InventoryApp(root)
    root.mainloop()
```

This application includes the following features:

1. **Database Integration**:
   - SQLite database for storage
   - Table creation for inventory items
   - CRUD (Create, Read, Update, Delete) operations

2. **GUI Features**:
   - Add new items with name, quantity, price, and category
   - Update existing item quantities
   - Remove items from inventory
   - View inventory in a sortable table
   - Generate text report of current inventory

3. **Validation**:
   - Input validation for required fields
   - Numeric validation for quantity and price
   - Selection validation for update/delete operations

4. **Reporting**:
   - Generate timestamped inventory reports
   - Save reports as text files

To run this application:

1. Save the code as `inventory_app.py`
2. Install Python (if not already installed)
3. Run the script: `python inventory_app.py`

**Key Components**:

- **Database**: Uses SQLite for local storage
- **GUI Framework**: Tkinter for interface elements
- **Treeview**: Tabular display of inventory items
- **Input Validation**: Ensures data integrity
- **Reporting**: Simple text-based report generation

**Enhancement Ideas**:

1. Add barcode scanning integration
2. Implement low stock alerts
3. Add search functionality
4. Include inventory history tracking
5. Add user authentication
6. Implement CSV import/export
7. Add graphical reports and analytics
8. Include supplier management
9. Add multi-location inventory support
10. Implement REST API for remote access

This provides a basic foundation for inventory management that can be extended based on specific business requirements.
Leave a Comment