# Reading files
with open('file.txt', 'r') as f:
    content = f.read()

# Writing files
with open('file.txt', 'w') as f:
    f.write('Hello World')

# Working with JSON (structured data)
import json
data = json.load(open('data.json'))
json.dump(data, open('output.json', 'w'))

import os
from pathlib import Path

# Get current directory
os.getcwd()

# List files
os.listdir('/path/to/folder')

# Create directories
os.makedirs('new_folder', exist_ok=True)

# Check if file exists
Path('file.txt').exists()

# Get file extension
Path('image.jpg').suffix  # .jpg

from datetime import datetime, date, timedelta

# Current date/time
now = datetime.now()
today = date.today()

# Format dates
formatted = now.strftime('%Y-%m-%d %H:%M')

# Parse dates
parsed = datetime.strptime('2026-07-20', '%Y-%m-%d')

# Date arithmetic
tomorrow = today + timedelta(days=1)
days_left = (exam_date - today).days

import requests
from bs4 import BeautifulSoup

# Fetch webpage
response = requests.get('https://example.com')
soup = BeautifulSoup(response.text, 'html.parser')

# Find elements
links = soup.find_all('a')
titles = soup.find_all('h1')

import smtplib
from email.mime.text import MIMEText

# Create email
msg = MIMEText('Hello from Python!')
msg['Subject'] = 'Automated Email'

# Send via SMTP
server = smtplib.SMTP('smtp.gmail.com', 587)
server.starttls()
server.login('email', 'password')
server.send_message(msg)

import requests

# GET request
response = requests.get('https://api.example.com/data')

# POST request
response = requests.post('https://api.example.com/create', 
                        json={'name': 'Task'})

# With authentication
headers = {'Authorization': 'Bearer YOUR_TOKEN'}
response = requests.get(url, headers=headers)

import schedule
import time

def job():
    print("Task executed!")

# Schedule tasks
schedule.every().day.at("09:00").do(job)
schedule.every(1).hour.do(job)
schedule.every().monday.do(job)

# Run scheduler
while True:
    schedule.run_pending()
    time.sleep(1)

Extract → Read data from source (file, API, database)
Transform → Clean, filter, modify data
Load → Save to destination (file, database, API)

Watch → Listen for event (new file, deadline approaching)
Check → Evaluate condition
Act → Perform automation

Schedule → Set time (daily, weekly, hourly)
Execute → Run the automation
Report → Log results

Input → Process 1 → Process 2 → Process 3 → Output

try:
    # Risky operation
    result = risky_function()
except FileNotFoundError:
    print("File not found, skipping...")
except PermissionError:
    print("Permission denied, check access")
except Exception as e:
    print(f"Unexpected error: {e}")

# Bad - hardcoded
file = 'C:/Users/John/Desktop/file.txt'

# Good - dynamic
from pathlib import Path
desktop = Path.home() / 'Desktop'
file = desktop / 'file.txt'

# Cross-platform compatible
# Works on Windows, Mac, Linux automatically

# Bad - loads entire file
data = open('large.csv').read()  # Memory error!

# Good - processes line by line
with open('large.csv', 'r') as f:
    for line in f:
        process(line)  # Memory efficient

# Or use generators
def read_large_file(file):
    with open(file) as f:
        for line in f:
            yield line

# Always handle API limits
import time

def api_call_with_retry(url, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = requests.get(url)
            if response.status_code == 200:
                return response.json()
        except requests.exceptions.RequestException:
            time.sleep(2 ** attempt)  # Exponential backoff
    return None

# Never hardcode passwords
# Bad
password = "mysecret123"

# Good
import getpass
password = getpass.getpass("Enter password: ")

# Or use environment variables
import os
password = os.environ.get('PASSWORD')

"""
Deadline Reminder System
Purpose: Send email reminders for upcoming deadlines
"""
import json
import smtplib
from datetime import datetime, date
from email.mime.text import MIMEText
from pathlib import Path
import logging

# Setup logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[logging.FileHandler('deadline.log'), logging.StreamHandler()]
)

class DeadlineReminder:
    """
    Handles deadline tracking and email notifications
    """
    
    def __init__(self, config_file='config.json'):
        self.config = self.load_config(config_file)
        self.tasks = self.load_tasks()
    
    def load_config(self, config_file):
        """Load configuration from JSON file"""
        try:
            with open(config_file) as f:
                return json.load(f)
        except FileNotFoundError:
            logging.error("Config file not found")
            return {}
    
    def load_tasks(self):
        """Load tasks from JSON file"""
        try:
            with open(self.config.get('tasks_file', 'tasks.json')) as f:
                return json.load(f)
        except FileNotFoundError:
            return []
    
    def save_tasks(self):
        """Save tasks to JSON file"""
        with open(self.config.get('tasks_file', 'tasks.json'), 'w') as f:
            json.dump(self.tasks, f, indent=2)
    
    def add_task(self, name, course, due_date, priority='medium'):
        """Add a new task"""
        task = {
            'name': name,
            'course': course,
            'due_date': due_date,
            'priority': priority,
            'completed': False,
            'created': datetime.now().isoformat()
        }
        self.tasks.append(task)
        self.save_tasks()
        logging.info(f"Task added: {name} - Due: {due_date}")
    
    def get_upcoming(self, days=3):
        """Get tasks due within specified days"""
        today = date.today()
        upcoming = []
        
        for task in self.tasks:
            if task['completed']:
                continue
            
            due = datetime.strptime(task['due_date'], '%Y-%m-%d').date()
            days_left = (due - today).days
            
            if 0 <= days_left <= days:
                upcoming.append((task, days_left))
        
        return sorted(upcoming, key=lambda x: x[1])
    
    def send_reminders(self):
        """Send email reminders for upcoming tasks"""
        upcoming = self.get_upcoming()
        
        if not upcoming:
            logging.info("No upcoming deadlines")
            return
        
        body = "📚 UPCOMING DEADLINE REMINDER\n\n"
        body += "Here are your deadlines:\n\n"
        
        for task, days in upcoming:
            priority_emoji = '🔴' if task['priority'] == 'high' else '🟡'
            body += f"{priority_emoji} {task['name']} ({task['course']})\n"
            body += f"   Due: {task['due_date']} - {days} days left\n\n"
        
        body += "Good luck! 🎓"
        
        # Send email
        self._send_email(
            self.config.get('email_to'),
            "📚 Assignment Deadline Reminder",
            body
        )
    
    def _send_email(self, to_email, subject, body):
        """Internal method to send email"""
        try:
            # Configuration
            sender = self.config.get('email_sender')
            password = self.config.get('email_password')
            
            if not sender or not password:
                logging.warning("Email not configured - printing instead")
                print(body)
                return
            
            # Create message
            msg = MIMEText(body)
            msg['Subject'] = subject
            msg['From'] = sender
            msg['To'] = to_email
            
            # Send
            server = smtplib.SMTP('smtp.gmail.com', 587)
            server.starttls()
            server.login(sender, password)
            server.send_message(msg)
            server.quit()
            
            logging.info(f"Email sent to {to_email}")
            
        except Exception as e:
            logging.error(f"Email failed: {e}")

# Usage
reminder = DeadlineReminder()
reminder.add_task("Research Paper", "English", "2026-07-20", "high")
reminder.send_reminders()