python
diff --git a/‎Doc/lib/emailgenerator.tex‎
Lines changed: 1 addition & 1 deletion b/‎Doc/lib/emailgenerator.tex‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎Doc/lib/libcollections.tex‎
Lines changed: 12 additions & 8 deletions b/‎Doc/lib/libcollections.tex‎
Lines changed: 12 additions & 8 deletions
diff --git a/‎Doc/lib/libfunctools.tex‎
Lines changed: 11 additions & 6 deletions b/‎Doc/lib/libfunctools.tex‎
Lines changed: 11 additions & 6 deletions
diff --git a/‎Doc/lib/libheapq.tex‎
Lines changed: 13 additions & 2 deletions b/‎Doc/lib/libheapq.tex‎
Lines changed: 13 additions & 2 deletions
diff --git a/‎Doc/lib/libitertools.tex‎
Lines changed: 27 additions & 0 deletions b/‎Doc/lib/libitertools.tex‎
Lines changed: 27 additions & 0 deletions
diff --git a/‎Doc/lib/liblocale.tex‎
Lines changed: 1 addition & 1 deletion b/‎Doc/lib/liblocale.tex‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎Doc/lib/libos.tex‎
Lines changed: 27 additions & 0 deletions b/‎Doc/lib/libos.tex‎
Lines changed: 27 additions & 0 deletions
diff --git a/‎Doc/lib/libshutil.tex‎
Lines changed: 2 additions & 2 deletions b/‎Doc/lib/libshutil.tex‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎Doc/lib/libstdtypes.tex‎
Lines changed: 1 addition & 1 deletion b/‎Doc/lib/libstdtypes.tex‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎Doc/lib/libstruct.tex‎
Lines changed: 59 additions & 0 deletions b/‎Doc/lib/libstruct.tex‎
Lines changed: 59 additions & 0 deletions
@@ -33,7 +33,7 @@
 line.  This is the only guaranteed portable way to avoid having such
 lines be mistaken for a \UNIX{} mailbox format envelope header separator (see
 \ulink{WHY THE CONTENT-LENGTH FORMAT IS BAD}
-{http://home.netscape.com/eng/mozilla/2.0/relnotes/demo/content-length.html}
+{http://www.jwz.org/doc/content-length.html}
 for details).  \var{mangle_from_} defaults to \code{True}, but you
 might want to set this to \code{False} if you are not writing \UNIX{}
 mailbox format files.
 
@@ -311,16 +311,20 @@ \subsubsection{\class{defaultdict} Examples \label{defaultdict-examples}}
 When a letter is first encountered, it is missing from the mapping, so the
 \member{default_factory} function calls \function{int()} to supply a default
 count of zero.  The increment operation then builds up the count for each
-letter. This technique makes counting simpler and faster than an equivalent
-technique using \method{dict.get()}:
+letter.
 
-\begin{verbatim}
->>> d = {}
->>> for k in s:
-	d[k] = d.get(k, 0) + 1
+The function \function{int()} which always returns zero is just a special
+case of constant functions.  A faster and more flexible way to create
+constant functions is to use \function{itertools.repeat()} which can supply
+any constant value (not just zero):
 
->>> d.items()
-[('i', 4), ('p', 2), ('s', 4), ('m', 1)]
+\begin{verbatim}
+>>> def constant_factory(value):
+...     return itertools.repeat(value).next
+>>> d = defaultdict(constant_factory('<missing>'))
+>>> d.update(name='John', action='ran')
+>>> '%(name)s %(action)s to %(object)s' % d
+'John ran to <missing>'
 \end{verbatim}
 
 Setting the \member{default_factory} to \class{set} makes the
 
@@ -66,15 +66,16 @@ \section{\module{functools} ---
 
 \begin{funcdesc}{update_wrapper}
 {wrapper, wrapped\optional{, assigned}\optional{, updated}}
-Update a wrapper function to look like the wrapped function. The optional
-arguments are tuples to specify which attributes of the original
+Update a \var{wrapper} function to look like the \var{wrapped} function.
+The optional arguments are tuples to specify which attributes of the original
 function are assigned directly to the matching attributes on the wrapper
 function and which attributes of the wrapper function are updated with
 the corresponding attributes from the original function. The default
 values for these arguments are the module level constants
-\var{WRAPPER_ASSIGNMENTS} (which assigns to the wrapper function's name,
-module and documentation string) and \var{WRAPPER_UPDATES} (which
-updates the wrapper function's instance dictionary).
+\var{WRAPPER_ASSIGNMENTS} (which assigns to the wrapper function's
+\var{__name__}, \var{__module__} and \var{__doc__}, the documentation string)
+and \var{WRAPPER_UPDATES} (which updates the wrapper function's \var{__dict__},
+i.e. the instance dictionary).
 
 The main intended use for this function is in decorator functions
 which wrap the decorated function and return the wrapper. If the
@@ -98,16 +99,20 @@ \section{\module{functools} ---
         ...
         >>> @my_decorator
         ... def example():
+	...     """Docstring"""
         ...     print 'Called example function'
         ...
         >>> example()
         Calling decorated function
         Called example function
         >>> example.__name__
         'example'
+	>>> example.__doc__
+	'Docstring'
   \end{verbatim}
 Without the use of this decorator factory, the name of the example
-function would have been \code{'wrapper'}.
+function would have been \code{'wrapper'}, and the docstring of the
+original \function{example()} would have been lost.
 \end{funcdesc}
 
 
 
@@ -88,7 +88,18 @@ \section{\module{heapq} ---
 >>>
 \end{verbatim}
 
-The module also offers two general purpose functions based on heaps.
+The module also offers three general purpose functions based on heaps.
+
+\begin{funcdesc}{merge}{*iterables}
+Merge multiple sorted inputs into a single sorted output (for example, merge
+timestamped entries from multiple log files).  Returns an iterator over
+over the sorted values.
+
+Similar to \code{sorted(itertools.chain(*iterables))} but returns an iterable,
+does not pull the data into memory all at once, and assumes that each of the
+input streams is already sorted (smallest to largest).            
+\versionadded{2.6}
+\end{funcdesc}
 
 \begin{funcdesc}{nlargest}{n, iterable\optional{, key}}
 Return a list with the \var{n} largest elements from the dataset defined
@@ -110,7 +121,7 @@ \section{\module{heapq} ---
 \versionchanged[Added the optional \var{key} argument]{2.5}
 \end{funcdesc}
 
-Both functions perform best for smaller values of \var{n}.  For larger
+The latter two functions perform best for smaller values of \var{n}.  For larger
 values, it is more efficient to use the \function{sorted()} function.  Also,
 when \code{n==1}, it is more efficient to use the builtin \function{min()}
 and \function{max()} functions.
 
@@ -302,6 +302,33 @@ \subsection{Itertool functions \label{itertools-functions}}
   don't care about trailing, unmatched values from the longer iterables.
 \end{funcdesc}
 
+\begin{funcdesc}{izip_longest}{*iterables\optional{, fillvalue}}
+  Make an iterator that aggregates elements from each of the iterables.
+  If the iterables are of uneven length, missing values are filled-in
+  with \var{fillvalue}.  Iteration continues until the longest iterable
+  is exhausted.  Equivalent to:
+
+  \begin{verbatim}
+    def izip_longest(*args, **kwds):
+        fillvalue = kwds.get('fillvalue')
+        def sentinel(counter = ([fillvalue]*(len(args)-1)).pop):
+            yield counter()         # yields the fillvalue, or raises IndexError
+        fillers = repeat(fillvalue)
+        iters = [chain(it, sentinel(), fillers) for it in args]
+        try:
+            for tup in izip(*iters):
+                yield tup
+        except IndexError:
+            pass
+  \end{verbatim}
+
+  If one of the iterables is potentially infinite, then the
+  \function{izip_longest()} function should be wrapped with something
+  that limits the number of calls (for example \function{islice()} or
+  \function{take()}).
+  \versionadded{2.6}
+\end{funcdesc}
+
 \begin{funcdesc}{repeat}{object\optional{, times}}
   Make an iterator that returns \var{object} over and over again.
   Runs indefinitely unless the \var{times} argument is specified.
 
@@ -481,7 +481,7 @@ \subsection{Background, details, hints, tips and caveats}
 locale settings.  When a call to the \function{setlocale()} function
 changes the \constant{LC_CTYPE} settings, the variables
 \code{string.lowercase}, \code{string.uppercase} and
-\code{string.letters} are recalculated.  Note that this code that uses
+\code{string.letters} are recalculated.  Note that code that uses
 these variable through `\keyword{from} ... \keyword{import} ...',
 e.g.\ \code{from string import letters}, is not affected by subsequent
 \function{setlocale()} calls.
 
@@ -758,6 +758,26 @@ \subsection{Files and Directories \label{os-file-dir}}
 \versionadded{2.3}
 \end{funcdesc}
 
+\begin{funcdesc}{chflags}{path, flags}
+Set the flags of \var{path} to the numeric \var{flags}.
+\var{flags} may take a combination (bitwise OR) of the following values
+(as defined in the \module{stat} module):
+\begin{itemize}
+  \item \code{UF_NODUMP}
+  \item \code{UF_IMMUTABLE}
+  \item \code{UF_APPEND}
+  \item \code{UF_OPAQUE}
+  \item \code{UF_NOUNLINK}
+  \item \code{SF_ARCHIVED}
+  \item \code{SF_IMMUTABLE}
+  \item \code{SF_APPEND}
+  \item \code{SF_NOUNLINK}
+  \item \code{SF_SNAPSHOT}
+\end{itemize}
+Availability: Macintosh, \UNIX.
+\versionadded{2.6}
+\end{funcdesc}
+
 \begin{funcdesc}{chroot}{path}
 Change the root directory of the current process to \var{path}.
 Availability: Macintosh, \UNIX.
@@ -804,6 +824,13 @@ \subsection{Files and Directories \label{os-file-dir}}
 Availability: Macintosh, \UNIX.
 \end{funcdesc}
 
+\begin{funcdesc}{lchflags}{path, flags}
+Set the flags of \var{path} to the numeric \var{flags}, like
+\function{chflags()}, but do not follow symbolic links.
+Availability: \UNIX.
+\versionadded{2.6}
+\end{funcdesc}
+
 \begin{funcdesc}{lchown}{path, uid, gid}
 Change the owner and group id of \var{path} to the numeric \var{uid}
 and gid. This function will not follow symbolic links.
 
@@ -44,8 +44,8 @@ \section{\module{shutil} ---
 \end{funcdesc}
 
 \begin{funcdesc}{copystat}{src, dst}
-  Copy the permission bits, last access time, and last modification
-  time from \var{src} to \var{dst}.  The file contents, owner, and
+  Copy the permission bits, last access time, last modification time,
+  and flags from \var{src} to \var{dst}.  The file contents, owner, and
   group are unaffected.  \var{src} and \var{dst} are path names given
   as strings.
 \end{funcdesc}
 
@@ -1212,7 +1212,7 @@ \section{Set Types ---
 	    \label{types-set}}
 \obindex{set}
 
-A \dfn{set} object is an unordered collection of immutable values.
+A \dfn{set} object is an unordered collection of distinct hashable objects.
 Common uses include membership testing, removing duplicates from a sequence,
 and computing mathematical operations such as intersection, union, difference,
 and symmetric difference.
 
@@ -29,6 +29,15 @@ \section{\module{struct} ---
   exactly.
 \end{funcdesc}
 
+\begin{funcdesc}{pack_into}{fmt, buffer, offset, v1, v2, \moreargs}
+  Pack the values \code{\var{v1}, \var{v2}, \textrm{\ldots}} according to the given
+  format, write the packed bytes into the writable \var{buffer} starting at
+  \var{offset}.
+  Note that the offset is not an optional argument.
+
+  \versionadded{2.5}
+\end{funcdesc}
+
 \begin{funcdesc}{unpack}{fmt, string}
   Unpack the string (presumably packed by \code{pack(\var{fmt},
   \textrm{\ldots})}) according to the given format.  The result is a
@@ -37,6 +46,16 @@ \section{\module{struct} ---
   (\code{len(\var{string})} must equal \code{calcsize(\var{fmt})}).
 \end{funcdesc}
 
+\begin{funcdesc}{unpack_from}{fmt, buffer\optional{,offset \code{= 0}}}
+  Unpack the \var{buffer} according to tthe given format.
+  The result is a tuple even if it contains exactly one item. The
+  \var{buffer} must contain at least the amount of data required by the
+  format (\code{len(buffer[offset:])} must be at least
+  \code{calcsize(\var{fmt})}).
+
+  \versionadded{2.5}
+\end{funcdesc}
+
 \begin{funcdesc}{calcsize}{fmt}
   Return the size of the struct (and hence of the string)
   corresponding to the given format.
@@ -208,3 +227,43 @@ \section{\module{struct} ---
   \seemodule{array}{Packed binary storage of homogeneous data.}
   \seemodule{xdrlib}{Packing and unpacking of XDR data.}
 \end{seealso}
+
+\subsection{Struct Objects \label{struct-objects}}
+
+The \module{struct} module also defines the following type:
+
+\begin{classdesc}{Struct}{format}
+  Return a new Struct object which writes and reads binary data according to
+  the format string \var{format}.  Creating a Struct object once and calling
+  its methods is more efficient than calling the \module{struct} functions
+  with the same format since the format string only needs to be compiled once.
+
+ \versionadded{2.5}
+\end{classdesc}
+
+Compiled Struct objects support the following methods and attributes:
+
+\begin{methoddesc}[Struct]{pack}{v1, v2, \moreargs}
+  Identical to the \function{pack()} function, using the compiled format.
+  (\code{len(result)} will equal \member{self.size}.)
+\end{methoddesc}
+
+\begin{methoddesc}[Struct]{pack_into}{buffer, offset, v1, v2, \moreargs}
+  Identical to the \function{pack_into()} function, using the compiled format.
+\end{methoddesc}
+
+\begin{methoddesc}[Struct]{unpack}{string}
+  Identical to the \function{unpack()} function, using the compiled format.
+  (\code{len(string)} must equal \member{self.size}).
+\end{methoddesc}
+
+\begin{methoddesc}[Struct]{unpack_from}{buffer\optional{,offset
+                                              \code{= 0}}}
+  Identical to the \function{unpack_from()} function, using the compiled format.
+  (\code{len(buffer[offset:])} must be at least \member{self.size}).
+\end{methoddesc}
+
+\begin{memberdesc}[Struct]{format}
+  The format string used to construct this Struct object.
+\end{memberdesc}
+