Python os and pathlib Modules — File Paths, Directory Operations and Real-World Patterns

import os

# --- 1. Current working directory ---
current_dir = os.getcwd()
print(f"Script is running from: {current_dir}")

# --- 2. Build a cross-platform path safely ---
# NEVER hard-code slashes. os.path.join handles the separator for you.
reports_path = os.path.join(current_dir, 'data', 'reports', 'july_sales.csv')
print(f"Target file path: {reports_path}")

# --- 3. Check existence before acting ---
# Trying to open a non-existent file raises FileNotFoundError.
# Always guard against this in production code.
if os.path.exists(reports_path):
    print("File exists — safe to open.")
else:
    print("File not found — creating parent directories now.")
    # exist_ok=True means no error if the folder already exists
    os.makedirs(os.path.dirname(reports_path), exist_ok=True)

# --- 4. Split a path into useful parts ---
file_directory = os.path.dirname(reports_path)   # everything except the filename
file_name      = os.path.basename(reports_path)  # just 'july_sales.csv'
name_only, ext = os.path.splitext(file_name)      # ('july_sales', '.csv')

print(f"Directory : {file_directory}")
print(f"Filename  : {file_name}")
print(f"Name only : {name_only}")
print(f"Extension : {ext}")

# --- 5. List directory contents (non-recursive) ---
script_dir = os.path.dirname(os.path.abspath(__file__))
print(f"\nFiles and folders in script directory:")
for entry in os.listdir(script_dir):
    full_entry_path = os.path.join(script_dir, entry)
    kind = 'DIR ' if os.path.isdir(full_entry_path) else 'FILE'
    print(f"  [{kind}] {entry}")

# --- 6. Read an environment variable with a safe fallback ---
log_level = os.environ.get('LOG_LEVEL', 'INFO')  # returns 'INFO' if not set
print(f"\nLog level from environment: {log_level}")

from pathlib import Path

# --- 1. Create a Path object — the anchor for everything else ---
# Path(__file__) gives us this script's path as an object, not a raw string
script_path   = Path(__file__).resolve()  # resolve() makes it absolute, no '..' segments
project_root  = script_path.parent        # go up one level to the containing folder

print(f"Script   : {script_path}")
print(f"Project  : {project_root}")

# --- 2. Build paths with / operator — readable and safe ---
data_dir      = project_root / 'data'
output_file   = data_dir / 'processed' / 'summary.csv'

print(f"Output file will go to: {output_file}")

# --- 3. Create directories — mkdir with parents + exist_ok ---
# parents=True creates every missing folder in the chain
# exist_ok=True suppresses the error if the folder already exists
output_file.parent.mkdir(parents=True, exist_ok=True)
print(f"Ensured directory exists: {output_file.parent}")

# --- 4. Inspect path properties — no functions, just attributes ---
print(f"\nPath anatomy for: {output_file}")
print(f"  .name     : {output_file.name}")      # 'summary.csv'
print(f"  .stem     : {output_file.stem}")      # 'summary'
print(f"  .suffix   : {output_file.suffix}")    # '.csv'
print(f"  .parent   : {output_file.parent}")    # parent directory
print(f"  .parts    : {output_file.parts}")     # tuple of every segment

# --- 5. Write and read files directly from the Path object ---
output_file.write_text("date,revenue\n2024-07-01,15200\n2024-07-02,18400\n")
content = output_file.read_text()
print(f"\nFile content written and read back:\n{content}")

# --- 6. Glob — find files matching a pattern recursively ---
print("All .csv files anywhere under data/:")
for csv_file in data_dir.rglob('*.csv'):  # rglob = recursive glob
    # relative_to() makes the output cleaner — no giant absolute paths
    print(f"  {csv_file.relative_to(project_root)}")

# --- 7. Check existence and file type ---
print(f"\nDoes output file exist? {output_file.exists()}")
print(f"Is it a file?           {output_file.is_file()}")
print(f"Is it a directory?      {output_file.is_dir()}")

# --- 8. Rename / move a file ---
archive_file = output_file.with_name('summary_archived.csv')  # same dir, new name
output_file.rename(archive_file)
print(f"\nFile renamed to: {archive_file.name}")

import os
from pathlib import Path
from datetime import datetime

# --- Configuration via environment variable with sensible default ---
# In production you'd set INBOX_DIR in your .env or CI environment
inbox_dir   = Path(os.environ.get('INBOX_DIR', './inbox'))
output_dir  = Path(os.environ.get('OUTPUT_DIR', './organised'))
manifest    = []  # we'll log every move here

# Map file extensions to human-friendly category folder names
EXTENSION_MAP = {
    '.jpg':  'images',
    '.jpeg': 'images',
    '.png':  'images',
    '.gif':  'images',
    '.mp4':  'videos',
    '.mov':  'videos',
    '.pdf':  'documents',
    '.docx': 'documents',
    '.txt':  'documents',
    '.csv':  'data',
    '.json': 'data',
    '.xlsx': 'data',
}

def organise_inbox(source_dir: Path, dest_dir: Path) -> list[dict]:
    """
    Move every file in source_dir into a category subfolder under dest_dir.
    Returns a list of move records for logging or auditing.
    """
    move_log = []

    if not source_dir.exists():
        print(f"Inbox directory not found: {source_dir}")
        return move_log

    # iterdir() yields every item in the directory as a Path object
    for item in source_dir.iterdir():
        if item.is_dir():
            # Skip subdirectories — only handle flat files in this version
            continue

        # .suffix returns the extension including the dot, e.g. '.pdf'
        # .lower() handles cases like '.JPG' vs '.jpg'
        extension    = item.suffix.lower()
        category     = EXTENSION_MAP.get(extension, 'misc')  # unknown types go to 'misc'
        category_dir = dest_dir / category

        # Create the category folder if it doesn't exist yet
        category_dir.mkdir(parents=True, exist_ok=True)

        destination = category_dir / item.name

        # Handle name collisions — append a timestamp rather than silently overwriting
        if destination.exists():
            timestamp   = datetime.now().strftime('%Y%m%d_%H%M%S')
            new_name    = f"{item.stem}_{timestamp}{item.suffix}"
            destination = category_dir / new_name
            print(f"  Collision detected — renaming to: {new_name}")

        # .rename() moves the file; on some OS/filesystem combos use .replace() instead
        item.rename(destination)

        move_log.append({
            'original' : str(item),
            'moved_to' : str(destination),
            'category' : category,
        })
        print(f"  Moved [{category:10s}] {item.name} -> {destination.relative_to(dest_dir)}")

    return move_log


def write_manifest(move_log: list[dict], dest_dir: Path) -> None:
    """Write a human-readable manifest of all file moves."""
    manifest_path = dest_dir / 'manifest.txt'
    lines = [f"File Organisation Manifest — {datetime.now().isoformat()}\n"]
    lines += [f"{r['category']:10s} | {r['original']} -> {r['moved_to']}" for r in move_log]
    manifest_path.write_text('\n'.join(lines))
    print(f"\nManifest written to: {manifest_path}")


# --- Entry point ---
if __name__ == '__main__':
    # For demo purposes, create some fake files in the inbox
    inbox_dir.mkdir(parents=True, exist_ok=True)
    for fake_file in ['photo.jpg', 'report.pdf', 'data_export.csv', 'notes.txt', 'video.mp4']:
        (inbox_dir / fake_file).write_text(f"Demo content for {fake_file}")

    print(f"Organising files from: {inbox_dir}")
    print(f"Destination root    : {output_dir}\n")

    results = organise_inbox(inbox_dir, output_dir)
    write_manifest(results, output_dir)

    print(f"\nDone. {len(results)} file(s) organised.")

import os
from pathlib import Path

project_root = Path('./sample_project')

# --- Set up a sample directory tree for demonstration ---
for folder in ['src', 'src/utils', 'tests', 'docs', '.git', 'node_modules']:
    (project_root / folder).mkdir(parents=True, exist_ok=True)
for filepath in ['src/main.py', 'src/utils/helpers.py', 'tests/test_main.py',
                 'docs/readme.md', '.git/config', 'node_modules/package.json']:
    (project_root / filepath).write_text(f"# {filepath}")

print("=" * 55)
print("METHOD 1: pathlib rglob — simple pattern matching")
print("=" * 55)

# rglob('*.py') matches any .py file in any subdirectory
for python_file in sorted(project_root.rglob('*.py')):
    print(f"  {python_file.relative_to(project_root)}")
# OUTPUT INCLUDES node_modules and .git if they had .py files — no pruning

print()
print("=" * 55)
print("METHOD 2: os.walk — pruning hidden/vendor directories")
print("=" * 55)

# Directories we never want to descend into
SKIP_DIRS = {'.git', 'node_modules', '__pycache__', '.venv'}

for dirpath, subdirs, filenames in os.walk(project_root):
    # Modify subdirs IN-PLACE — this tells os.walk not to visit pruned folders
    # This is the KEY advantage of os.walk over rglob
    subdirs[:] = [
        directory for directory in subdirs
        if directory not in SKIP_DIRS
    ]

    for filename in filenames:
        if filename.endswith('.py'):
            full_path     = os.path.join(dirpath, filename)
            relative_path = os.path.relpath(full_path, project_root)
            print(f"  {relative_path}")

print()
print("Notice: .git and node_modules were skipped entirely by os.walk,")
print("but rglob would have descended into them if they contained .py files.")