How to Check if a File is Open or Closed in Python

f = open("example.txt", "w")
print(f"Is closed? {f.closed}")  # False

f.close()
print(f"Is closed? {f.closed}")  # True

def safe_read(file_obj) -> str | None:
    """Safely read from a file, checking if it's open first."""
    if file_obj.closed:
        print("Warning: Cannot read from a closed file.")
        return None
    return file_obj.read()


def safe_write(file_obj, content: str) -> bool:
    """Safely write to a file, checking if it's open first."""
    if file_obj.closed:
        print("Warning: Cannot write to a closed file.")
        return False
    file_obj.write(content)
    return True

with open("data.json", "r") as f:
    data = f.read()
    print(f"Inside block - closed: {f.closed}")   # False

print(f"Outside block - closed: {f.closed}")      # True

with (
    open("input.txt", "r") as infile,
    open("output.txt", "w") as outfile
):
    content = infile.read()
    outfile.write(content.upper())

print(f"Input closed: {infile.closed}")   # True
print(f"Output closed: {outfile.closed}") # True

with open("input.txt", "r") as infile:
    with open("output.txt", "w") as outfile:
        content = infile.read()
        outfile.write(content.upper())

f = open("test.txt", "w")
f.close()

try:
    f.write("Hello")
except ValueError as e:
    print(f"Error: {e}")

class SafeFile:
    """Wrapper that prevents operations on closed files."""

    def __init__(self, filepath: str, mode: str = "r"):
        self._file = open(filepath, mode)
        self._filepath = filepath

    def read(self) -> str | None:
        if self._file.closed:
            raise RuntimeError(f"File '{self._filepath}' is already closed")
        return self._file.read()

    def write(self, content: str) -> None:
        if self._file.closed:
            raise RuntimeError(f"File '{self._filepath}' is already closed")
        self._file.write(content)

    def close(self) -> None:
        if not self._file.closed:
            self._file.close()

    @property
    def closed(self) -> bool:
        return self._file.closed

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.close()
        return False

def process_file(file_obj) -> dict:
    """Process a file object, validating its state first."""
    if not hasattr(file_obj, 'read'):
        raise TypeError("Expected a file-like object")

    if file_obj.closed:
        raise ValueError("Cannot process a closed file")

    if not file_obj.readable():
        raise ValueError("File is not readable")

    content = file_obj.read()
    return {
        "length": len(content),
        "lines": content.count("\n") + 1
    }


with open("data.txt", "r") as f:
    result = process_file(f)
    print(result)

with open("example.txt", "w+") as f:
    print(f"Name: {f.name}")           # example.txt
    print(f"Mode: {f.mode}")           # w+
    print(f"Closed: {f.closed}")       # False
    print(f"Readable: {f.readable()}") # True
    print(f"Writable: {f.writable()}") # True
    print(f"Seekable: {f.seekable()}") # True

import atexit
import warnings

_open_files = []


def tracked_open(*args, **kwargs):
    """Open that tracks file objects for debugging."""
    f = open(*args, **kwargs)
    _open_files.append(f)
    return f


def report_unclosed():
    """Report any files that weren't closed."""
    unclosed = [f for f in _open_files if not f.closed]
    if unclosed:
        warnings.warn(f"Unclosed files detected: {[f.name for f in unclosed]}")


atexit.register(report_unclosed)