✨ retrieval-augmented generation (RAG) | AI Coding Glossary ✨

📖 A technique that improves a model’s outputs by retrieving relevant external documents at query time and feeding them into the model.

🏷️ #Python

✨ Logging in Python ✨

📖 If you use Python's print() function to get information about the flow of your programs, logging is the natural next step. Create your first logs and curate them to grow with your projects.

🏷️ #intermediate #best-practices #tools

Is Your Crypto Transfer Secure?

Score Your Transfer analyzes wallet activity, flags risky transactions in real time, and generates downloadable compliance reports—no technical skills needed. Protect funds & stay compliant.



Sponsored By WaybienAds

💡 Python Tips Part 1

A collection of essential Python tricks to make your code more efficient, readable, and "Pythonic." This part covers list comprehensions, f-strings, tuple unpacking, and using enumerate.

# Create a list of squares from 0 to 9
squares = [x**2 for x in range(10)]

print(squares)
# Output: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

• List Comprehensions: A concise and often faster way to create lists. The syntax is [expression for item in iterable].

name = "Alex"
score = 95.5

# Using an f-string for easy formatting
message = f"Congratulations {name}, you scored {score:.1f}!"

print(message)
# Output: Congratulations Alex, you scored 95.5!

• F-Strings: The modern, readable way to format strings. Simply prefix the string with f and place variables or expressions directly inside curly braces {}.

numbers = (1, 2, 3, 4, 5)

# Unpack the first, last, and middle elements
first, *middle, last = numbers

print(f"First: {first}")   # 1
print(f"Middle: {middle}") # [2, 3, 4]
print(f"Last: {last}")     # 5

• Extended Unpacking: Use the asterisk * operator to capture multiple items from an iterable into a list during assignment. It's perfect for separating the "head" and "tail" from the rest.

items = ['keyboard', 'mouse', 'monitor']

for index, item in enumerate(items):
    print(f"Item #{index}: {item}")

# Output:
# Item #0: keyboard
# Item #1: mouse
# Item #2: monitor

• Using enumerate: The Pythonic way to get both the index and the value of an item when looping. It's much cleaner than using range(len(items)).

#Python #Programming #CodeTips #PythonTricks

━━━━━━━━━━━━━━━
By: @DataScience4 ✨

💡 Python Tips Part 2

More essential Python tricks to improve your code. This part covers dictionary comprehensions, the zip function, ternary operators, and using underscores for unused variables.

# Create a dictionary of numbers and their squares
squared_dict = {x: x**2 for x in range(1, 6)}

print(squared_dict)
# Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

• Dictionary Comprehensions: A concise way to create dictionaries, similar to list comprehensions. The syntax is {key_expr: value_expr for item in iterable}.

students = ["Alice", "Bob", "Charlie"]
scores = [88, 92, 79]

for student, score in zip(students, scores):
    print(f"{student}: {score}")

# Output:
# Alice: 88
# Bob: 92
# Charlie: 79

• Using zip: The zip function combines multiple iterables (like lists or tuples) into a single iterator of tuples. It's perfect for looping over related lists in parallel.

age = 20

# Assign a value based on a condition in one line
status = "Adult" if age >= 18 else "Minor"

print(status)
# Output: Adult

• Ternary Operator: A shorthand for a simple if-else statement, useful for conditional assignments. The syntax is value_if_true if condition else value_if_false.

# Looping 3 times without needing the loop variable
for _ in range(3):
    print("Hello, Python!")

# Unpacking, but only needing the last value
_, _, last_item = (10, 20, 30)
print(last_item) # 30

• Using Underscore _: By convention, the underscore _ is used as a variable name when you need a placeholder but don't intend to use its value. This signals to other developers that the variable is intentionally ignored.

#Python #Programming #CodeTips #PythonTricks

━━━━━━━━━━━━━━━
By: @DataScience4 ✨

💡 Python Tips Part 3

Advancing your Python skills with more powerful techniques. This part covers safe dictionary access with .get(), flexible function arguments with *args and **kwargs, and context managers using the with statement.

user_data = {"name": "Alice", "age": 30}

# Safely get a key that exists
name = user_data.get("name")

# Safely get a key that doesn't exist by providing a default
city = user_data.get("city", "Not Specified")

print(f"Name: {name}, City: {city}")
# Output: Name: Alice, City: Not Specified

• Dictionary .get() Method: Access dictionary keys safely. .get(key, default) returns the value for a key if it exists, otherwise it returns the default value (which is None if not specified) without raising a KeyError.

def dynamic_function(*args, **kwargs):
    print("Positional args (tuple):", args)
    print("Keyword args (dict):", kwargs)

dynamic_function(1, 'go', True, user="admin", status="active")
# Output:
# Positional args (tuple): (1, 'go', True)
# Keyword args (dict): {'user': 'admin', 'status': 'active'}

• *args and **kwargs: Use these in function definitions to accept a variable number of arguments. *args collects positional arguments into a tuple, and **kwargs collects keyword arguments into a dictionary.

# The 'with' statement ensures the file is closed automatically
try:
    with open("notes.txt", "w") as f:
        f.write("Context managers are great!")
    # No need to call f.close()
    print("File written and closed.")
except Exception as e:
    print(f"An error occurred: {e}")

• The with Statement: The with statement creates a context manager, which is the standard way to handle resources like files or network connections. It guarantees that cleanup code is executed, even if errors occur inside the block.

#Python #Programming #CodeTips #PythonTricks

━━━━━━━━━━━━━━━
By: @DataScience4 ✨

💡 Python Tips Part 4

Level up your Python code with more advanced tips. This part covers chaining comparisons, using sets for uniqueness, and powerful tools from the collections module like Counter and defaultdict.

x = 10

# Check if x is between 5 and 15 in a clean way
if 5 < x < 15:
    print("x is in range.")

# Output: x is in range.

• Chaining Comparisons: Python allows you to chain comparison operators for more readable and concise range checks. This is equivalent to (5 < x) and (x < 15).

numbers = [1, 2, 2, 3, 4, 4, 4, 5]

# Use a set to quickly get unique elements
unique_numbers = list(set(numbers))

print(unique_numbers)
# Output: [1, 2, 3, 4, 5]

• Sets for Uniqueness: Sets are unordered collections of unique elements. Converting a list to a set and back is the fastest and most Pythonic way to remove duplicates.

from collections import Counter

words = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
word_counts = Counter(words)

print(word_counts)
# Output: Counter({'apple': 3, 'banana': 2, 'orange': 1})
print(word_counts.most_common(1))
# Output: [('apple', 3)]

• collections.Counter: A specialized dictionary subclass for counting hashable objects. It simplifies frequency counting tasks and provides useful methods like .most_common().

from collections import defaultdict

data = [('fruit', 'apple'), ('fruit', 'banana'), ('veg', 'carrot')]
grouped_data = defaultdict(list)

for category, item in data:
    grouped_data[category].append(item)

print(grouped_data)
# Output: defaultdict(<class 'list'>, {'fruit': ['apple', 'banana'], 'veg': ['carrot']})

• collections.defaultdict: A dictionary that provides a default value for a non-existent key, avoiding KeyError. It's perfect for grouping items into lists or dictionaries without extra checks.

#Python #Programming #CodeTips #DataStructures

━━━━━━━━━━━━━━━
By: @DataScience4 ✨

💡 Python True & False: A Mini-Guide

This guide covers Python's boolean values, True and False. We'll explore how they result from comparisons, are used with logical operators, and how other data types can be evaluated as "truthy" or "falsy".

x = 10
y = 5

print(x > y)
print(x == 10)
print(y != 5)
# Output:
# True
# True
# False

• Comparison Operators: Operators like >, ==, and != evaluate expressions and always return a boolean value: True or False.

is_sunny = True
is_warm = False

print(is_sunny and is_warm)
print(is_sunny or is_warm)
print(not is_warm)
# Output:
# False
# True
# True

• Logical and: Returns True only if both operands are true.
• Logical or: Returns True if at least one operand is true.
• Logical not: Inverts the boolean value (True becomes False, and vice-versa).

# "Falsy" values evaluate to False
print(bool(0))
print(bool(""))
print(bool([]))
print(bool(None))

# "Truthy" values evaluate to True
print(bool(42))
print(bool("hello"))
# Output:
# False
# False
# False
# False
# True
# True

• Truthiness: In a boolean context (like an if statement), many values are considered True ("truthy").
• Falsiness: Only a few specific values are False ("falsy"): 0, None, and any empty collection (e.g., "", [], {}).

# Booleans can be treated as integers
sum_result = True + True + False
print(sum_result)

product = True * 15
print(product)
# Output:
# 2
# 15

• Internally, True is equivalent to the integer 1 and False is equivalent to 0.
• This allows you to use them in mathematical calculations, a common feature in coding challenges.

#Python #Boolean #Programming #TrueFalse #CodingTips

━━━━━━━━━━━━━━━
By: @DataScience4 ✨

✨ tagging | AI Coding Glossary ✨

📖 The process of assigning one or more discrete labels to data items so that models and tools can learn from them.

🏷️ #Python

✨ guardrails | AI Coding Glossary ✨

📖 Application-level policies and controls that constrain how a model or agent behaves.

🏷️ #Python

Python: How to easily upload a file via SSH

Want to upload a file to a remote server via SSH directly from a Python script? It's easy to do with the paramiko library - it provides a clean and reliable implementation of the SSH protocol.

Just install paramiko (pip install paramiko), specify the connection details, and use an SFTP session to send the file.

Make sure the user has write permissions to the target directory on the server. Subscribe for more tips every day!

import paramiko 

Connection settings 
hostname = "your-server.com"
port = 22
username = "your_username"
password = "your_password"  # or use a key instead of a password 

Local and remote paths 
local_file = "local_file.txt"
remote_file = "/remote/path/local_file.txt" 

Create SSH client 
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) 

try:
    ssh.connect(hostname, port=port, username=username, password=password) 

# Open SFTP session and upload the file
sftp = ssh.open_sftp()
sftp.put(local_file, remote_file)
sftp.close()

print("File uploaded successfully!")
except Exception as e:
    print(f"Error: {e}")
finally:
    ()

https://t.me/DataScience4

💡 Python Exam Cheatsheet

A quick review of core Python concepts frequently found in technical assessments and exams. This guide covers list comprehensions, dictionary methods, enumerate, and flexible function arguments.

# Create a list of squares for even numbers from 0 to 9
squares = [x**2 for x in range(10) if x % 2 == 0]
print(squares)

# Output:
# [0, 4, 16, 36, 64]

• List Comprehension: A concise, one-line syntax for creating lists.
• The structure is [expression for item in iterable if condition].
• The if condition part is optional and acts as a filter.

student_scores = {'Alice': 95, 'Bob': 87}

# Safely get a score, providing a default value if the key is missing
charlie_score = student_scores.get('Charlie', 'Not Found')
alice_score = student_scores.get('Alice', 'Not Found')

print(f"Alice: {alice_score}")
print(f"Charlie: {charlie_score}")

# Output:
# Alice: 95
# Charlie: Not Found

• Dictionary .get() Method: Safely access a dictionary key without causing a KeyError.
• The first argument is the key to look up.
• The optional second argument is the default value to return if the key does not exist.

colors = ['red', 'green', 'blue']

for index, value in enumerate(colors):
    print(f"Index: {index}, Value: {value}")

# Output:
# Index: 0, Value: red
# Index: 1, Value: green
# Index: 2, Value: blue

• Using enumerate: The Pythonic way to loop over an iterable when you need both the index and the value.
• It returns a tuple (index, value) for each item in the sequence.

def process_data(*args, **kwargs):
    print(f"Positional args (tuple): {args}")
    print(f"Keyword args (dict): {kwargs}")

process_data(1, 'hello', 3.14, user='admin', status='active')

# Output:
# Positional args (tuple): (1, 'hello', 3.14)
# Keyword args (dict): {'user': 'admin', 'status': 'active'}

• *args: Collects all extra positional arguments into a tuple.
• **kwargs: Collects all extra keyword arguments into a dictionary.
• This pattern allows a function to accept a variable number of arguments.

#Python #PythonExam #Programming #CodeCheatsheet #LearnPython

━━━━━━━━━━━━━━━
By: @DataScience4 ✨

Clean Code Tip:

The with statement simplifies resource management, like file handling. It ensures resources are automatically closed, even if errors occur. This prevents bugs and makes your code safer and cleaner than manual try...finally blocks. It's a must-know for any Python developer! 🔐

Example:

# The old, verbose way to ensure a file is closed
print("--- Old Way ---")
file = open('greeting.txt', 'w')
try:
    file.write('Hello, world!')
finally:
    # This block always runs to ensure the file is closed
    print("File is being closed in 'finally' block.")
    file.close()


# The clean, safe, and Pythonic way using 'with'
print("\n--- Clean Way ---")
with open('greeting.txt', 'w') as file:
    file.write('Hello, Python!')
    print("Inside 'with' block. File is still open here.")

# The file is now automatically and safely closed.
print("Outside 'with' block. File is guaranteed to be closed.")

━━━━━━━━━━━━━━━
By: @DataScience4 ✨

Clean Code Tip:

When you need both the index and the item while looping, avoid manual index counters. Use Python's built-in enumerate() function for cleaner, more readable, and less error-prone code. It's the Pythonic way to count! 🔢

Example:

# The old, manual way to track an index
print("--- Old Way ---")
fruits = ['apple', 'banana', 'cherry']
index = 0
for fruit in fruits:
    print(f"Index: {index}, Fruit: {fruit}")
    index += 1


# The clean and Pythonic way using enumerate()
print("\n--- Clean Way ---")
for index, fruit in enumerate(fruits):
    print(f"Index: {index}, Fruit: {fruit}")


# You can even start counting from a different number!
print("\n--- Starting from 1 ---")
for position, fruit in enumerate(fruits, start=1):
    print(f"Position: {position}, Fruit: {fruit}")

━━━━━━━━━━━━━━━
By: @DataScience4 ✨

Clean Code Tip:

For reusable setup and teardown logic, you can create your own context managers. Instead of writing a full class with __enter__ and __exit__, use the @contextmanager decorator from the contextlib module for a more concise and elegant solution. This is a pro-level technique for robust resource management. 🚀

Example:

import contextlib

# The verbose, class-based way to create a context manager
class DatabaseConnection:
    def __init__(self, db_name):
        self._db_name = db_name
        self._conn = None
        print(f"Initializing connection to {self._db_name}...")

    def __enter__(self):
        print("-> Entering context: Opening connection.")
        self._conn = f"CONNECTION_TO_{self._db_name}" # Simulate connection
        return self._conn

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("<- Exiting context: Closing connection.")
        self._conn = None # Simulate closing

print("--- Class-Based Way ---")
with DatabaseConnection("users.db") as conn:
    print(f"   Performing operations with {conn}")


# The clean, Pythonic way using a generator and @contextmanager
@contextlib.contextmanager
def managed_database(db_name):
    print(f"Initializing connection to {db_name}...")
    conn = f"CONNECTION_TO_{db_name}"
    try:
        print("-> Entering context: Yielding connection.")
        yield conn # The code inside the 'with' block runs here
    finally:
        # This code is guaranteed to run, just like __exit__
        print("<- Exiting context: Closing connection in 'finally'.")
        conn = None

print("\n--- @contextmanager Way ---")
with managed_database("products.db") as conn:
    print(f"   Performing operations with {conn}")

━━━━━━━━━━━━━━━
By: @DataScience4 ✨

Clean Code Tip:

Writing classes just to hold data often requires boilerplate methods like __init__, __repr__, and __eq__. The @dataclass decorator automates this! By simply declaring typed fields, you get a full-featured class, making your code significantly shorter, more readable, and less prone to errors. 📦

Example:

from dataclasses import dataclass

# The old, verbose way with manual boilerplate
class PointOld:
    def __init__(self, x: int, y: int):
        self.x = x
        self.y = y

    # Without this, printing the object is unhelpful
    def __repr__(self):
        return f"PointOld(x={self.x}, y={self.y})"

    # Without this, comparison checks for object identity, not value
    def __eq__(self, other):
        if not isinstance(other, PointOld):
            return NotImplemented
        return self.x == other.x and self.y == other.y

print("--- Old Way ---")
p1_old = PointOld(10, 20)
p2_old = PointOld(10, 20)
print(f"Object representation: {p1_old}")
print(f"Are they equal? {p1_old == p2_old}")


# The clean, modern way using @dataclass
@dataclass
class PointNew:
    x: int
    y: int
    # __init__, __repr__, and __eq__ are all generated automatically!

print("\n--- Clean @dataclass Way ---")
p1_new = PointNew(10, 20)
p2_new = PointNew(10, 20)
print(f"Object representation: {p1_new}")
print(f"Are they equal? {p1_new == p2_new}")

━━━━━━━━━━━━━━━
By: @DataScience4 ✨

#YOLOv8 #ComputerVision #FireDetection #Python #AI #Safety

Lesson: Real-Time Fire Detection in an Industrial Facility with YOLOv8 and Alarm System

This tutorial guides you through building a computer vision project from scratch. We will use the YOLOv8 model to detect fire in a video feed from an industrial setting and trigger an alarm sound upon detection.

---

#Step 1: Project Setup and Dependencies

First, we need to install the necessary Python libraries. We'll use ultralytics for the YOLOv8 model, opencv-python for video processing, and playsound to trigger our alarm. Open your terminal or command prompt and run the following command:

pip install ultralytics opencv-python playsound

After installation, create a Python file (e.g., fire_detector.py) and import these libraries.

import cv2
from ultralytics import YOLO
from playsound import playsound
import threading

# Hashtags: #Setup #Python #OpenCV #YOLOv8

---

#Step 2: Load the Model and Prepare the Alarm System

We will load a pre-trained YOLOv8 model. For a real-world application, you must train a custom model on a dataset of fire and smoke images. For this example, we will write the code assuming you have a custom model named fire_model.pt that knows how to detect 'fire'.

You also need an alarm sound file (e.g., alarm.wav) in the same directory as your script.

# Load your custom-trained YOLOv8 model
# IMPORTANT: The standard YOLOv8 models do not detect 'fire'. 
# You must train your own model on a fire dataset.
model = YOLO('fire_model.pt') # Replace with your custom model path

# Path to your alarm sound file
ALARM_SOUND_PATH = "alarm.wav"

# A flag to ensure the alarm plays only once per detection event
alarm_on = False

def play_alarm():
    """Plays the alarm sound in a separate thread."""
    global alarm_on
    print("ALARM: Fire Detected!")
    playsound(ALARM_SOUND_PATH)
    alarm_on = False # Reset alarm flag after sound finishes

# Hashtags: #AIModel #AlarmSystem #SafetyFirst

---

#Step 3: Main Loop for Video Processing and Detection

This is the core of our application. We will open a video file, read it frame by frame, and pass each frame to our YOLOv8 model for inference. If the model detects 'fire' with a certain confidence, we will draw a bounding box around it and trigger the alarm.

Create a video file named industrial_video.mp4 or use your own video source.

# Open the video file
video_path = 'industrial_video.mp4'
cap = cv2.VideoCapture(video_path)

# Loop through the video frames
while cap.isOpened():
    # Read a frame from the video
    success, frame = cap.read()

    if success:
        # Run YOLOv8 inference on the frame
        results = model(frame)

        # A flag to check if fire was detected in the current frame
        fire_detected_in_frame = False

        # Visualize the results on the frame
        annotated_frame = results[0].plot()

        # Process detection results
        for r in results:
            for box in r.boxes:
                # Check if the detected class is 'fire'
                # model.names[0] should correspond to 'fire' in your custom model
                if model.names[int(box.cls[0])] == 'fire' and box.conf[0] > 0.5:
                    fire_detected_in_frame = True
                    break
        
        # If fire is detected and alarm is not already on, trigger alarm
        if fire_detected_in_frame and not alarm_on:
            alarm_on = True
            # Run the alarm sound in a background thread to not block video feed
            alarm_thread = threading.Thread(target=play_alarm)
            alarm_thread.start()

        # Display the annotated frame
        cv2.imshow("YOLOv8 Fire Detection", annotated_frame)

        # Break the loop if 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord("q"):
            break
    else:
        # Break the loop if the end of the video is reached
        break

# Release the video capture object and close the display window
cap.release()
cv2.destroyAllWindows()

# Hashtags: #RealTimeDetection #VideoProcessing #OpenCV

---

#Step 4: Results and Discussion

After running the script, you will see a window playing the video. When the model detects an object it identifies as 'fire' with a confidence score above 50%, it will:
• Draw a colored box around the fire.
• Print "ALARM: Fire Detected!" to the console.
• Play the alarm.wav sound.

Discussion of Results:
Model Performance: The accuracy of this system depends entirely on the quality of your custom-trained model (fire_model.pt). A model trained on a diverse dataset of industrial fires (different lighting, angles, sizes) will perform best.
False Positives: The system might incorrectly identify orange/red lights, reflections, or welding sparks as fire. This is a common challenge. To fix this, you need to add more "negative" images (images of things that look like fire but aren't) to your training dataset.
Thresholding: The confidence threshold (box.conf[0] > 0.5) is a critical parameter. A lower value increases the chance of detecting real fires but also increases false alarms. A higher value reduces false alarms but might miss smaller or less obvious fires. You must tune this value based on your specific environment.
Real-World Implementation: For a real industrial facility, you would replace the video file with a live camera stream (cv2.VideoCapture(0) for a webcam) and integrate the alarm logic with a physical siren or a central monitoring system via an API or GPIO pins.

#ProjectComplete #AIforGood #IndustrialSafety

━━━━━━━━━━━━━━━
By: @DataScience4 ✨

✨ weight | AI Coding Glossary ✨

📖 A learned scalar or tensor that scales signals in a model and is updated during training to shape predictions.

🏷️ #Python

✨ tensor parameter | AI Coding Glossary ✨

📖 A learned multi-dimensional array that a model updates during training to shape its computations.

🏷️ #Python

#PyQt5 #SQLite #DesktopApp #WarehouseManagement #ERP #Python

Lesson: Advanced Warehouse ERP with PyQt5, SQLite, and Reporting

This tutorial covers building a complete desktop Enterprise Resource Planning (ERP) application for warehouse management. It features persistent storage using SQLite, inventory control, sales and purchase invoice management, a production module, and the ability to export reports to CSV.

---

#Step 1: Database Setup (database.py)

First, we create a dedicated file to handle all database interactions. This separation of concerns is crucial for a scalable application. Create a file named database.py.

import sqlite3
import csv

DB_NAME = 'warehouse.db'

def connect():
    return sqlite3.connect(DB_NAME)

def setup_database():
    conn = connect()
    cursor = conn.cursor()
    # Inventory Table: Stores raw materials and finished goods
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS inventory (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL UNIQUE,
            quantity INTEGER NOT NULL,
            price REAL NOT NULL
        )
    ''')
    # Invoices Table: Tracks both sales and purchases
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS invoices (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            type TEXT NOT NULL, -- 'SALE' or 'PURCHASE'
            party_name TEXT, -- Customer or Supplier Name
            date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )
    ''')
    # Invoice Items Table: Links items from inventory to an invoice
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS invoice_items (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            invoice_id INTEGER,
            item_id INTEGER,
            quantity INTEGER NOT NULL,
            price_per_unit REAL NOT NULL,
            FOREIGN KEY (invoice_id) REFERENCES invoices (id),
            FOREIGN KEY (item_id) REFERENCES inventory (id)
        )
    ''')
    conn.commit()
    conn.close()

def get_inventory():
    conn = connect()
    cursor = conn.cursor()
    cursor.execute("SELECT id, name, quantity, price FROM inventory ORDER BY name")
    items = cursor.fetchall()
    conn.close()
    return items

def add_inventory_item(name, quantity, price):
    conn = connect()
    cursor = conn.cursor()
    try:
        cursor.execute("INSERT INTO inventory (name, quantity, price) VALUES (?, ?, ?)", (name, quantity, price))
        conn.commit()
    except sqlite3.IntegrityError:
        # Item with this name already exists
        return False
    finally:
        conn.close()
    return True

def update_item_quantity(item_id, change_in_quantity):
    conn = connect()
    cursor = conn.cursor()
    cursor.execute("UPDATE inventory SET quantity = quantity + ? WHERE id = ?", (change_in_quantity, item_id))
    conn.commit()
    conn.close()
    
def find_item_by_name(name):
    conn = connect()
    cursor = conn.cursor()
    cursor.execute("SELECT * FROM inventory WHERE name = ?", (name,))
    item = cursor.fetchone()
    conn.close()
    return item

# Add more functions here for invoices, etc. as we build the app.

# Hashtags: #SQLite #DatabaseDesign #DataPersistence #Python

---

#Step 2: Main Application Shell and Inventory Tab

Now, create the main application file, main.py. We'll build the window, tabs, and fully implement the Inventory tab, which will read from and write to our SQLite database.