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:
    ()

# 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]

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

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

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'}

# 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.")

# 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}")

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}")

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}")

pip install ultralytics opencv-python playsound

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

# Hashtags: #Setup #Python #OpenCV #YOLOv8

# 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

# 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

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

import sys
import csv
from PyQt5.QtWidgets import *
import database as db # Import our database module

class WarehouseApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Warehouse ERP System")
        self.setGeometry(100, 100, 1000, 700)
        db.setup_database() # Ensure tables are created

        self.tabs = QTabWidget()
        self.setCentralWidget(self.tabs)
        
        # Create tabs
        self.inventory_tab = QWidget()
        self.purchase_tab = QWidget() # Incoming
        self.sales_tab = QWidget()    # Outgoing
        self.production_tab = QWidget()
        self.reports_tab = QWidget()

        self.tabs.addTab(self.inventory_tab, "Inventory")
        # Add other tabs later...

        self.setup_inventory_ui()
        self.load_inventory_data()

    def setup_inventory_ui(self):
        layout = QVBoxLayout()
        # Table view
        self.inventory_table = QTableWidget()
        self.inventory_table.setColumnCount(4)
        self.inventory_table.setHorizontalHeaderLabels(['ID', 'Name', 'Quantity', 'Price'])
        self.inventory_table.setEditTriggers(QAbstractItemView.NoEditTriggers)
        layout.addWidget(self.inventory_table)
        
        # Form for adding new items
        form = QFormLayout()
        self.item_name = QLineEdit()
        self.item_qty = QSpinBox()
        self.item_qty.setRange(0, 99999)
        self.item_price = QLineEdit()
        form.addRow("Name:", self.item_name)
        form.addRow("Quantity:", self.item_qty)
        form.addRow("Price:", self.item_price)
        add_btn = QPushButton("Add New Item")
        add_btn.clicked.connect(self.add_item)
        layout.addLayout(form)
        layout.addWidget(add_btn)
        
        self.inventory_tab.setLayout(layout)

    def load_inventory_data(self):
        items = db.get_inventory()
        self.inventory_table.setRowCount(len(items))
        for row_num, row_data in enumerate(items):
            for col_num, data in enumerate(row_data):
                self.inventory_table.setItem(row_num, col_num, QTableWidgetItem(str(data)))

    def add_item(self):
        name = self.item_name.text()
        qty = self.item_qty.value()
        price = float(self.item_price.text())
        if not name:
            QMessageBox.warning(self, "Input Error", "Item name cannot be empty.")
            return
        if db.add_inventory_item(name, qty, price):
            self.load_inventory_data() # Refresh table
            self.item_name.clear()
            self.item_qty.setValue(0)
            self.item_price.clear()
        else:
            QMessageBox.warning(self, "DB Error", f"Item '{name}' already exists.")

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = WarehouseApp()
    window.show()
    sys.exit(app.exec_())

# Hashtags: #PyQt5 #GUI #CRUD #InventoryManagement

def create_invoice(invoice_type, party_name, items):
    conn = connect()
    cursor = conn.cursor()
    # Create the invoice record
    cursor.execute("INSERT INTO invoices (type, party_name) VALUES (?, ?)", (invoice_type, party_name))
    invoice_id = cursor.lastrowid
    
    # Add items to the invoice and update inventory
    for item in items:
        item_id, quantity, price = item['id'], item['quantity'], item['price']
        cursor.execute(
            "INSERT INTO invoice_items (invoice_id, item_id, quantity, price_per_unit) VALUES (?, ?, ?, ?)",
            (invoice_id, item_id, quantity, price)
        )
        # Update inventory quantity
        change = quantity if invoice_type == 'PURCHASE' else -quantity
        cursor.execute("UPDATE inventory SET quantity = quantity + ? WHERE id = ?", (change, item_id))
    
    conn.commit()
    conn.close()
    return invoice_id

# In __init__, add the tab and call the setup
self.tabs.addTab(self.purchase_tab, "Purchasing (Incoming)")
self.setup_purchase_ui()

# In __init__, add the sales tab and call setup
self.tabs.addTab(self.sales_tab, "Sales (Outgoing)")
self.setup_sales_ui()

# New methods for the class
def setup_purchase_ui(self):
    # This is a simplified UI for demonstration
    layout = QVBoxLayout()
    form = QFormLayout()
    self.supplier_name = QLineEdit()
    self.purchase_item = QComboBox()
    self.purchase_qty = QSpinBox()
    self.purchase_qty.setRange(1, 1000)
    
    form.addRow("Supplier Name:", self.supplier_name)
    form.addRow("Item:", self.purchase_item)
    form.addRow("Quantity:", self.purchase_qty)
    
    add_purchase_btn = QPushButton("Record Purchase")
    add_purchase_btn.clicked.connect(self.record_purchase)
    
    layout.addLayout(form)
    layout.addWidget(add_purchase_btn)
    self.purchase_tab.setLayout(layout)
    self.update_item_combos()

def setup_sales_ui(self):
    # UI is very similar to purchase
    layout = QVBoxLayout()
    form = QFormLayout()
    self.customer_name = QLineEdit()
    self.sales_item = QComboBox()
    self.sales_qty = QSpinBox()
    self.sales_qty.setRange(1, 1000)
    
    form.addRow("Customer Name:", self.customer_name)
    form.addRow("Item:", self.sales_item)
    form.addRow("Quantity:", self.sales_qty)
    
    add_sale_btn = QPushButton("Record Sale")
    add_sale_btn.clicked.connect(self.record_sale)
    
    layout.addLayout(form)
    layout.addWidget(add_sale_btn)
    self.sales_tab.setLayout(layout)

def update_item_combos(self):
    self.purchase_item.clear()
    self.sales_item.clear()
    items = db.get_inventory()
    for item in items:
        # Store the full item tuple as userData
        self.purchase_item.addItem(item[1], userData=item) 
        self.sales_item.addItem(item[1], userData=item)

def record_purchase(self):
    supplier = self.supplier_name.text()
    item_data = self.purchase_item.currentData()
    qty = self.purchase_qty.value()
    if not supplier or not item_data:
        QMessageBox.warning(self, "Input Error", "Please fill all fields.")
        return
        
    invoice_item = {'id': item_data[0], 'quantity': qty, 'price': item_data[3]}
    db.create_invoice('PURCHASE', supplier, [invoice_item])
    
    QMessageBox.information(self, "Success", "Purchase recorded successfully.")
    self.load_inventory_data() # Refresh all UIs
    self.update_item_combos()

def record_sale(self):
    customer = self.customer_name.text()
    item_data = self.sales_item.currentData()
    qty_to_sell = self.sales_qty.value()
    
    if not customer or not item_data:
        QMessageBox.warning(self, "Input Error", "Please fill all fields.")
        return
    
    # Check for sufficient stock
    if item_data[2] < qty_to_sell:
        QMessageBox.critical(self, "Stock Error", f"Not enough {item_data[1]} in stock. Available: {item_data[2]}")
        return

    invoice_item = {'id': item_data[0], 'quantity': qty_to_sell, 'price': item_data[3]}
    db.create_invoice('SALE', customer, [invoice_item])
    
    QMessageBox.information(self, "Success", "Sale recorded successfully.")
    self.load_inventory_data()
    self.update_item_combos()

# In __init__, add the tabs and call the setups
self.tabs.addTab(self.production_tab, "Production")
self.setup_production_ui()
self.tabs.addTab(self.reports_tab, "Reporting")
self.setup_reports_ui()

# Define Bill of Materials (can be moved to DB in a real app)
self.bill_of_materials = {
    'Wooden Table': {'Wood Plank': 5, 'Varnish': 1},
    'Wooden Chair': {'Wood Plank': 2, 'Nail': 10}
}

def setup_production_ui(self):
    layout = QVBoxLayout()
    form = QFormLayout()
    self.product_to_make = QComboBox()
    self.product_to_make.addItems(self.bill_of_materials.keys())
    self.production_qty = QSpinBox()
    self.production_qty.setRange(1, 100)
    
    form.addRow("Product:", self.product_to_make)
    form.addRow("Quantity:", self.production_qty)
    produce_btn = QPushButton("Produce Items")
    produce_btn.clicked.connect(self.run_production)
    
    layout.addLayout(form)
    layout.addWidget(produce_btn)
    self.production_tab.setLayout(layout)

def run_production(self):
    product_name = self.product_to_make.currentText()
    qty_to_make = self.production_qty.value()
    bom = self.bill_of_materials[product_name]
    
    # 1. Check stock for all required materials
    for material, required_qty in bom.items():
        item_data = db.find_item_by_name(material)
        if not item_data or item_data[2] < required_qty * qty_to_make:
            QMessageBox.critical(self, "Production Halt", f"Not enough {material} in stock.")
            return

    # 2. If stock is sufficient, consume materials
    for material, required_qty in bom.items():
        item_data = db.find_item_by_name(material)
        db.update_item_quantity(item_data[0], - (required_qty * qty_to_make))

    # 3. Add finished product to inventory
    finished_product = db.find_item_by_name(product_name)
    if finished_product:
        db.update_item_quantity(finished_product[0], qty_to_make)
    else:
        # You'd calculate a price here in a real app
        db.add_inventory_item(product_name, qty_to_make, price=50.0)

    QMessageBox.information(self, "Success", f"Produced {qty_to_make} of {product_name}.")
    self.load_inventory_data()
    self.update_item_combos()

def setup_reports_ui(self):
    layout = QVBoxLayout()
    label = QLabel("Select a report to export to CSV:")
    self.report_type = QComboBox()
    self.report_type.addItems(["Current Inventory", "Sales History"]) # Add more as needed
    export_btn = QPushButton("Export Report")
    export_btn.clicked.connect(self.export_report)
    
    layout.addWidget(label)
    layout.addWidget(self.report_type)
    layout.addWidget(export_btn)
    layout.addStretch()
    self.reports_tab.setLayout(layout)

def export_report(self):
    report = self.report_type.currentText()
    path, _ = QFileDialog.getSaveFileName(self, "Save CSV", "", "CSV Files (*.csv)")
    if not path:
        return

    try:
        if report == "Current Inventory":
            data = db.get_inventory()
            headers = ['ID', 'Name', 'Quantity', 'Price']
            with open(path, 'w', newline='') as f:
                writer = csv.writer(f)
                writer.writerow(headers)
                writer.writerows(data)
        # Add other report types here
        # elif report == "Sales History": ...
        
        QMessageBox.information(self, "Success", f"Report exported to {path}")
    except Exception as e:
        QMessageBox.critical(self, "Export Error", f"An error occurred: {e}")

# Hashtags: #Production #Reporting #CSVExport #BusinessLogic