Add create mode to open()

Lib/_pyio.py

 """
 Python implementation of the io module.
 """
 
 import os
 import abc
 import codecs
 import warnings
 # Import _thread instead of threading to reduce startup cost
 try:
@@ skipping 30 matching lines @@
     r"""Open file and return a stream.  Raise IOError upon failure.
 
     file is either a text or byte string giving the name (and the path
     if the file isn't in the current working directory) of the file to
     be opened or an integer file descriptor of the file to be
     wrapped. (If a file descriptor is given, it is closed when the
     returned I/O object is closed, unless closefd is set to False.)
 
     mode is an optional string that specifies the mode in which the file
     is opened. It defaults to 'r' which means open for reading in text
-    mode.  Other common values are 'w' for writing (truncating the file if
+    mode.  Other common values are 'x' for creating and writing to a new
+    file, 'w' for writing (truncating the file if
     it already exists), and 'a' for appending (which on some Unix systems,
     means that all writes append to the end of the file regardless of the
     current seek position). In text mode, if encoding is not specified the
     encoding used is platform dependent. (For reading and writing raw
     bytes use binary mode and leave encoding unspecified.) The available
     modes are:
 
     ========= ===============================================================
     Character Meaning
     --------- ---------------------------------------------------------------
     'r'       open for reading (default)
+    'x'       create a new file and open it for writing
     'w'       open for writing, truncating the file first
     'a'       open for writing, appending to the end of the file if it exists
     'b'       binary mode
     't'       text mode (default)
     '+'       open a disk file for updating (reading and writing)
     'U'       universal newline mode (for backwards compatibility; unneeded
               for new code)
     ========= ===============================================================
 
     The default mode is 'rt' (open for reading text). For binary random
     access, the mode 'w+b' opens and truncates the file to 0 bytes, while
-    'r+b' opens the file without truncation.
+    'r+b' opens the file without truncation. The 'x' mode implies 'w' and
+    raises an `IOError` if the file already exists.

[Benjamin Peterson, 2012/01/08 16:16:10]

:exc:`OSError` again.

 
     Python distinguishes between files opened in binary and text modes,
     even when the underlying operating system doesn't. Files opened in
     binary mode (appending 'b' to the mode argument) return contents as
     bytes objects without any decoding. In text mode (the default, or when
     't' is appended to the mode argument), the contents of the file are
     returned as strings, the bytes having been first decoded using a
     platform-dependent encoding or using the specified encoding if given.
 
     buffering is an optional integer used to set the buffering policy.
@@ skipping 64 matching lines @@
         raise TypeError("invalid file: %r" % file)
     if not isinstance(mode, str):
         raise TypeError("invalid mode: %r" % mode)
     if not isinstance(buffering, int):
         raise TypeError("invalid buffering: %r" % buffering)
     if encoding is not None and not isinstance(encoding, str):
         raise TypeError("invalid encoding: %r" % encoding)
     if errors is not None and not isinstance(errors, str):
         raise TypeError("invalid errors: %r" % errors)
     modes = set(mode)
-    if modes - set("arwb+tU") or len(mode) > len(modes):
+    if modes - set("axrwb+tU") or len(mode) > len(modes):
         raise ValueError("invalid mode: %r" % mode)
+    creating = "x" in modes
     reading = "r" in modes
     writing = "w" in modes
     appending = "a" in modes
     updating = "+" in modes
     text = "t" in modes
     binary = "b" in modes
     if "U" in modes:
-        if writing or appending:
+        if creating or writing or appending:
             raise ValueError("can't use U and writing mode at once")
         reading = True
     if text and binary:
         raise ValueError("can't have text and binary mode at once")
-    if reading + writing + appending > 1:
+    if creating + reading + writing + appending > 1:
         raise ValueError("can't have read/write/append mode at once")
-    if not (reading or writing or appending):
+    if not (creating + reading or writing or appending):
         raise ValueError("must have exactly one of read/write/append mode")
     if binary and encoding is not None:
         raise ValueError("binary mode doesn't take an encoding argument")
     if binary and errors is not None:
         raise ValueError("binary mode doesn't take an errors argument")
     if binary and newline is not None:
         raise ValueError("binary mode doesn't take a newline argument")
     raw = FileIO(file,
+                 (creating and "x" or "") +
                  (reading and "r" or "") +
                  (writing and "w" or "") +
                  (appending and "a" or "") +
                  (updating and "+" or ""),
                  closefd)
     line_buffering = False
     if buffering == 1 or buffering < 0 and raw.isatty():
         buffering = -1
         line_buffering = True
     if buffering < 0:
         buffering = DEFAULT_BUFFER_SIZE
         try:
             bs = os.fstat(raw.fileno()).st_blksize
         except (os.error, AttributeError):
             pass
         else:
             if bs > 1:
                 buffering = bs
     if buffering < 0:
         raise ValueError("invalid buffering size")
     if buffering == 0:
         if binary:
             return raw
         raise ValueError("can't have unbuffered text I/O")
     if updating:
         buffer = BufferedRandom(raw, buffering)
-    elif writing or appending:
+    elif creating or writing or appending:
         buffer = BufferedWriter(raw, buffering)
     elif reading:
         buffer = BufferedReader(raw, buffering)
     else:
         raise ValueError("unknown mode: %r" % mode)
     if binary:
         return buffer
     text = TextIOWrapper(buffer, encoding, errors, newline, line_buffering)
     text.mode = mode
     return text
@@ skipping 1852 matching lines @@
     def errors(self):
         return None
 
     @property
     def encoding(self):
         return None
 
     def detach(self):
         # This doesn't make sense on StringIO.
         self._unsupported("detach")