import os
import subprocess
import shutil
import tempfile
import psutil
from pathlib import Path
import sys

# 1. List files and directories with detailed information
def list_directory_details():
    print("Directory contents with details:")
    for entry in os.scandir('.'):
        try:
            stat = entry.stat()
            print(f"{entry.name:<20} {stat.st_size:>8} bytes, "
                  f"modified: {stat.st_mtime}")
        except Exception as e:
            print(f"{entry.name}: Error - {e}")

# 2. Create directory and move file
def create_and_move_file():
    # Create new directory
    new_dir = "test_directory"
    os.makedirs(new_dir, exist_ok=True)
    
    # Create a test file
    test_file = "test_file.txt"
    with open(test_file, 'w') as f:
        f.write("This is a test file.")
    
    # Move file to new directory
    destination = os.path.join(new_dir, test_file)
    shutil.move(test_file, destination)
    
    print(f"Moved {test_file} to {destination}")

# 3. Execute system command and capture output
def execute_system_command():
    # List processes using ps command
    result = subprocess.run(['ps', '-eo', 'pid,comm'], 
                          capture_output=True, text=True)
    
    print("\nRunning processes:")
    print(result.stdout)

# 4. Get user information
def get_user_info():
    print(f"\nCurrent user: {os.getlogin()}")
    print(f"Home directory: {os.path.expanduser('~')}")
    print(f"Current working directory: {os.getcwd()}")

# 5. Check if process is running
def check_process_running(process_name):
    for proc in psutil.process_iter(['name']):
        try:
            if process_name.lower() in proc.info['name'].lower():
                return True
        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
            pass
    return False

# 6. Environment variables
def manage_environment_variables():
    # Get environment variables
    print(f"\nPATH variable: {os.environ.get('PATH')}")
    print(f"HOME variable: {os.environ.get('HOME')}")
    
    # Set a new environment variable
    os.environ['TEST_VAR'] = 'Hello from Python'
    print(f"Set TEST_VAR: {os.environ.get('TEST_VAR')}")

# 7. Temporary files
def use_temporary_files():
    # Create temporary file
    with tempfile.NamedTemporaryFile(delete=False) as temp:
        temp.write(b"This is a temporary file.")
        temp_path = temp.name
    
    print(f"Created temporary file: {temp_path}")
    
    # Clean up
    os.unlink(temp_path)
    print("Temporary file deleted.")

# Main function to demonstrate all techniques
def main():
    print("=== Operating System Operations Demo ===\n")
    
    # 1. List directory details
    list_directory_details()
    
    # 2. Create directory and move file
    create_and_move_file()
    
    # 3. Execute system command
    execute_system_command()
    
    # 4. Get user info
    get_user_info()
    
    # 5. Check if process is running
    print(f"\nIs Python running? {check_process_running('python')}")
    
    # 6. Manage environment variables
    manage_environment_variables()
    
    # 7. Use temporary files
    use_temporary_files()
    
    print("\nAll operations completed successfully.")

if __name__ == "__main__":
    main()

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

# Example usage
arr = [3, 6, 8, 10, 1, 2, 1]
print(quicksort(arr))  # Output: [1, 1, 2, 3, 6, 8, 10]

def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    visited.add(start)
    print(start, end=' ')

    for neighbor in graph[start]:
        if neighbor not in visited:
            dfs(graph, neighbor, visited)

# Example usage
graph = {
    'A': ['B', 'C'],
    'B': ['D', 'E'],
    'C': ['F'],
    'D': [],
    'E': ['F'],
    'F': []
}
dfs(graph, 'A')  # Output: A B D E F C

import heapq
from collections import defaultdict
import sys

def dijkstra(graph, start):
    # Priority queue: (distance, node)
    pq = [(0, start)]
    distances = {start: 0}
    visited = set()
    
    while pq:
        current_dist, current_node = heapq.heappop(pq)
        
        if current_node in visited:
            continue
        visited.add(current_node)
        
        for neighbor, weight in graph[current_node]:
            if neighbor not in distances or distances[neighbor] > current_dist + weight:
                distances[neighbor] = current_dist + weight
                heapq.heappush(pq, (distances[neighbor], neighbor))
    
    return distances

# Example usage
graph = defaultdict(list)
graph['A'] = [('B', 4), ('C', 2)]
graph['B'] = [('C', 1), ('D', 5)]
graph['C'] = [('D', 8)]
graph['D'] = []

distances = dijkstra(graph, 'A')
print(distances)  # Output: {'A': 0, 'B': 4, 'C': 2, 'D': 6}

def tower_of_hanoi(n, source, auxiliary, target):
    if n == 1:
        print(f"Move disk 1 from {source} to {target}")
        return
    tower_of_hanoi(n - 1, source, target, auxiliary)
    print(f"Move disk {n} from {source} to {target}")
    tower_of_hanoi(n - 1, auxiliary, source, target)

# Example usage
tower_of_hanoi(3, 'A', 'B', 'C')

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import cifar10
from tensorflow.keras.utils import to_categorical

# Load and preprocess data
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
y_train, y_test = to_categorical(y_train), to_categorical(y_test)

# Build CNN model
model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

# Compile and train
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

model.fit(x_train, y_train, epochs=10, validation_data=(x_test, y_test))

# Evaluate
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test Accuracy: {test_acc}")

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import imdb
from tensorflow.keras.preprocessing.sequence import pad_sequences

# Load and preprocess data
vocab_size = 10000
max_length = 250
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=vocab_size)
x_train = pad_sequences(x_train, maxlen=max_length)
x_test = pad_sequences(x_test, maxlen=max_length)

# Build RNN model
model = models.Sequential([
    layers.Embedding(vocab_size, 128, input_length=max_length),
    layers.SimpleRNN(64, return_sequences=False),
    layers.Dense(32, activation='relu'),
    layers.Dense(1, activation='sigmoid')
])

# Compile and train
model.compile(optimizer='adam',
              loss='binary_crossentropy',
              metrics=['accuracy'])

model.fit(x_train, y_train, epochs=5, validation_data=(x_test, y_test))

# Evaluate
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test Accuracy: {test_acc}")

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

# Load dataset
X, y = datasets.make_classification(n_samples=100, n_features=2, n_redundant=0, n_informative=2, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Scale features
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# Train SVM with linear kernel
svm_linear = SVC(kernel='linear')
svm_linear.fit(X_train, y_train)

# Predict and evaluate
y_pred = svm_linear.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.2f}")

# Plot decision boundary
plt.figure(figsize=(8, 6))
plt.scatter(X[:, 0], X[:, 1], c=y, cmap='viridis', edgecolor='k')
ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()

# Create grid to evaluate model
xx, yy = np.meshgrid(np.linspace(xlim[0], xlim[1], 50),
                     np.linspace(ylim[0], ylim[1], 50))
Z = svm_linear.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

# Plot decision boundary and margins
plt.contour(xx, yy, Z, colors='k', levels=[-1, 0, 1], alpha=0.5,
            linestyles=['--', '-', '--'])
plt.scatter(svm_linear.support_vectors_[:, 0], svm_linear.support_vectors_[:, 1],
            s=100, facecolors='none', edgecolors='k')
plt.title("SVM with Linear Kernel")
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, confusion_matrix
import seaborn as sns

# Load dataset
data = datasets.load_iris()
X = data.data
y = data.target
feature_names = data.feature_names
target_names = data.target_names

# Split and scale data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Train KNN model with k=5
knn = KNeighborsClassifier(n_neighbors=5, metric='euclidean')
knn.fit(X_train_scaled, y_train)

# Predict and evaluate
y_pred = knn.predict(X_test_scaled)
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.2f}")

# Confusion Matrix
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(6, 4))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=target_names, yticklabels=target_names)
plt.title('Confusion Matrix')
plt.ylabel('True Label')
plt.xlabel('Predicted Label')
plt.show()

# Visualize decision boundaries (for first two features only)
plt.figure(figsize=(8, 6))
X_plot = X[:, :2]  # Use only first two features for visualization
X_plot_scaled = scaler.fit_transform(X_plot)
knn_visual = KNeighborsClassifier(n_neighbors=5)
knn_visual.fit(X_plot_scaled, y)
h = 0.02
x_min, x_max = X_plot_scaled[:, 0].min() - 1, X_plot_scaled[:, 0].max() + 1
y_min, y_max = X_plot_scaled[:, 1].min() - 1, X_plot_scaled[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
Z = knn_visual.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, alpha=0.3, cmap=plt.cm.Paired)
for i, color in enumerate(['red', 'green', 'blue']):
    idx = np.where(y == i)
    plt.scatter(X_plot_scaled[idx, 0], X_plot_scaled[idx, 1], c=color, label=target_names[i], edgecolors='k')
plt.xlabel(feature_names[0])
plt.ylabel(feature_names[1])
plt.title('KNN Decision Boundaries (First Two Features)')
plt.legend()
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.svm import SVC
from sklearn.metrics import classification_report, confusion_matrix
import seaborn as sns

# Load dataset
data = datasets.load_iris()
X = data.data
y = data.target
feature_names = data.feature_names
target_names = data.target_names

# Split data into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Create a pipeline with preprocessing and model
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('classifier', SVC(kernel='rbf', random_state=42))
])

# Train the model
pipeline.fit(X_train, y_train)

# Make predictions
y_pred = pipeline.predict(X_test)

# Evaluate the model
accuracy = pipeline.score(X_test, y_test)
print(f"Accuracy: {accuracy:.2f}")

# Classification report
print("Classification Report:")
print(classification_report(y_test, y_pred, target_names=target_names))

# Confusion Matrix
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(6, 4))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=target_names, yticklabels=target_names)
plt.title('Confusion Matrix')
plt.ylabel('True Label')
plt.xlabel('Predicted Label')
plt.show()

# Cross-validation
cv_scores = cross_val_score(pipeline, X_train, y_train, cv=5)
print(f"Cross-validation scores: {cv_scores}")
print(f"Mean CV Score: {cv_scores.mean():.2f} ± {cv_scores.std():.2f}")

# Hyperparameter tuning using GridSearchCV
param_grid = {
    'classifier__C': [0.1, 1, 10],
    'classifier__gamma': ['scale', 'auto', 0.1, 1]
}
grid_search = GridSearchCV(pipeline, param_grid, cv=5, scoring='accuracy')
grid_search.fit(X_train, y_train)

print("Best parameters:", grid_search.best_params_)
print("Best cross-validation score:", grid_search.best_score_)

# Final model with best parameters
best_model = grid_search.best_estimator_
final_predictions = best_model.predict(X_test)
final_accuracy = accuracy_score(y_test, final_predictions)
print(f"Final Accuracy with tuned model: {final_accuracy:.2f}")

import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import solve_ivp
from scipy.optimize import minimize
from scipy.signal import butter, filtfilt
from scipy.interpolate import interp1d

# 1. Numerical Integration: Solve a system of ODEs (e.g., predator-prey model)
def predator_prey(t, y):
    x, y = y  # x = prey, y = predator
    dxdt = 0.5 * x - 0.02 * x * y
    dydt = -0.4 * y + 0.01 * x * y
    return [dxdt, dydt]

# Initial conditions: [prey, predator]
initial_conditions = [40, 9]
t_span = [0, 100]
solution = solve_ivp(predator_prey, t_span, initial_conditions, t_eval=np.linspace(0, 100, 1000))

plt.figure(figsize=(10, 6))
plt.plot(solution.t, solution.y[0], label='Prey')
plt.plot(solution.t, solution.y[1], label='Predator')
plt.xlabel('Time')
plt.ylabel('Population')
plt.title('Predator-Prey Model Solution')
plt.legend()
plt.grid(True)
plt.show()

# 2. Optimization: Minimize a function
def objective_function(x):
    return x[0]**2 + x[1]**2 + 10 * np.sin(x[0]) * np.sin(x[1])

# Initial guess
x0 = [1, 1]
result = minimize(objective_function, x0, method='BFGS')

print("Optimization Result:")
print(f"Minimum value: {result.fun}")
print(f"Optimal point: {result.x}")

# Plot the function and minimum
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = X**2 + Y**2 + 10 * np.sin(X) * np.sin(Y)

plt.figure(figsize=(8, 6))
contour = plt.contour(X, Y, Z, levels=50, cmap='viridis')
plt.colorbar(contour)
plt.scatter(result.x[0], result.x[1], color='red', s=100, label='Minimum')
plt.title('Function Minimization with SciPy')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid(True)
plt.show()

# 3. Signal Processing: Filter a noisy sine wave
t = np.linspace(0, 10, 1000)
signal = np.sin(2 * np.pi * t) + 0.5 * np.random.randn(len(t))  # Noisy signal

# Design Butterworth filter
b, a = butter(4, 0.1, btype='low')  # Low-pass filter
filtered_signal = filtfilt(b, a, signal)

plt.figure(figsize=(10, 6))
plt.plot(t, signal, label='Noisy Signal', alpha=0.7)
plt.plot(t, filtered_signal, label='Filtered Signal', linewidth=2)
plt.xlabel('Time')
plt.ylabel('Amplitude')
plt.title('Low-Pass Filtering with SciPy')
plt.legend()
plt.grid(True)
plt.show()

# 4. Interpolation: Fit a smooth curve to scattered data
x_data = np.array([0, 1, 2, 3, 4])
y_data = np.array([0, 1, 0, 1, 0])
f = interp1d(x_data, y_data, kind='cubic')

x_new = np.linspace(0, 4, 100)
y_new = f(x_new)

plt.figure(figsize=(8, 6))
plt.scatter(x_data, y_data, color='red', label='Data Points')
plt.plot(x_new, y_new, label='Interpolated Curve', linewidth=2)
plt.xlabel('x')
plt.ylabel('y')
plt.title('Cubic Interpolation with SciPy')
plt.legend()
plt.grid(True)
plt.show()

x = [1, 2, 3]
y = x
y.append(4)
print(x)

def func(a, b=[]):
    b.append(a)
    return b

print(func(1))
print(func(2))

print(2 ** 3 ** 2)

list1 = [1, 2, 3]
list2 = list1.copy()
list2[0] = 10
print(list1)

a = [1, 2, 3]
b = a[:]
b[0] = 10
print(a)

x = "hello"
y = "world"
print(x + y)