# SOME DESCRIPTIVE TITLE.
# Copyright (c) YEAR Python Software Foundation.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# This version of the catalog contains only doc strings, which a
# developer can access interactively during development.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"POT-Creation-Date: 2001-06-10 19:01+0200\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=CHARSET\n"
"Content-Transfer-Encoding: ENCODING\n"

#: Lib/BaseHTTPServer.py:93
msgid "Override server_bind to store the server name."
msgstr ""

#. The Python system version, truncated to its first component.
#: Lib/BaseHTTPServer.py:102
msgid ""
"HTTP request handler base class.\n"
"\n"
"    The following explanation of HTTP serves to guide you through the\n"
"    code as well as to expose any misunderstandings I may have about\n"
"    HTTP (so you don't need to read the code to figure out I'm wrong\n"
"    :-).\n"
"\n"
"    HTTP (HyperText Transfer Protocol) is an extensible protocol on\n"
"    top of a reliable stream transport (e.g. TCP/IP).  The protocol\n"
"    recognizes three parts to a request:\n"
"\n"
"    1. One line identifying the request type and path\n"
"    2. An optional set of RFC-822-style headers\n"
"    3. An optional data part\n"
"\n"
"    The headers and data are separated by a blank line.\n"
"\n"
"    The first line of the request has the form\n"
"\n"
"    <command> <path> <version>\n"
"\n"
"    where <command> is a (case-sensitive) keyword such as GET or POST,\n"
"    <path> is a string containing path information for the request,\n"
"    and <version> should be the string \"HTTP/1.0\".  <path> is encoded\n"
"    using the URL encoding scheme (using %xx to signify the ASCII\n"
"    character with hex code xx).\n"
"\n"
"    The protocol is vague about whether lines are separated by LF\n"
"    characters or by CRLF pairs -- for compatibility with the widest\n"
"    range of clients, both should be accepted.  Similarly, whitespace\n"
"    in the request line should be treated sensibly (allowing multiple\n"
"    spaces between components and allowing trailing whitespace).\n"
"\n"
"    Similarly, for output, lines ought to be separated by CRLF pairs\n"
"    but most clients grok LF characters just fine.\n"
"\n"
"    If the first line of the request has the form\n"
"\n"
"    <command> <path>\n"
"\n"
"    (i.e. <version> is left out) then this is assumed to be an HTTP\n"
"    0.9 request; this form has no optional headers and data part and\n"
"    the reply consists of just the data.\n"
"\n"
"    The reply form of the HTTP 1.0 protocol again has three parts:\n"
"\n"
"    1. One line giving the response code\n"
"    2. An optional set of RFC-822-style headers\n"
"    3. The data\n"
"\n"
"    Again, the headers and data are separated by a blank line.\n"
"\n"
"    The response code line has the form\n"
"\n"
"    <version> <responsecode> <responsestring>\n"
"\n"
"    where <version> is the protocol version (always \"HTTP/1.0\"),\n"
"    <responsecode> is a 3-digit response code indicating success or\n"
"    failure of the request, and <responsestring> is an optional\n"
"    human-readable string explaining what the response code means.\n"
"\n"
"    This server parses the request and the headers, and then calls a\n"
"    function specific to the request type (<command>).  Specifically,\n"
"    a request SPAM will be handled by a method do_SPAM().  If no\n"
"    such method exists the server sends an error response to the\n"
"    client.  If it exists, it is called with no arguments:\n"
"\n"
"    do_SPAM()\n"
"\n"
"    Note that the request name is case sensitive (i.e. SPAM and spam\n"
"    are different requests).\n"
"\n"
"    The various request details are stored in instance variables:\n"
"\n"
"    - client_address is the client IP address in the form (host,\n"
"    port);\n"
"\n"
"    - command, path and version are the broken-down request line;\n"
"\n"
"    - headers is an instance of mimetools.Message (or a derived\n"
"    class) containing the header information;\n"
"\n"
"    - rfile is a file object open for reading positioned at the\n"
"    start of the optional input data part;\n"
"\n"
"    - wfile is a file object open for writing.\n"
"\n"
"    IT IS IMPORTANT TO ADHERE TO THE PROTOCOL FOR WRITING!\n"
"\n"
"    The first thing to be written must be the response line.  Then\n"
"    follow 0 or more header lines, then a blank line, and then the\n"
"    actual data (if any).  The meaning of the header lines depends on\n"
"    the command executed by the server; in most cases, when data is\n"
"    returned, there should be at least one header line of the form\n"
"\n"
"    Content-type: <type>/<subtype>\n"
"\n"
"    where <type> and <subtype> should be registered MIME types,\n"
"    e.g. \"text/html\" or \"text/plain\".\n"
"\n"
"    "
msgstr ""

#: Lib/BaseHTTPServer.py:213
msgid ""
"Parse a request (internal).\n"
"\n"
"        The request should be stored in self.raw_request; the results\n"
"        are in self.command, self.path, self.request_version and\n"
"        self.headers.\n"
"\n"
"        Return value is 1 for success, 0 for failure; on failure, an\n"
"        error is sent back.\n"
"\n"
"        "
msgstr ""

#: Lib/BaseHTTPServer.py:250
msgid ""
"Handle a single HTTP request.\n"
"\n"
"        You normally don't need to override this method; see the class\n"
"        __doc__ string for information on how to handle specific HTTP\n"
"        commands such as GET and POST.\n"
"\n"
"        "
msgstr ""

#: Lib/BaseHTTPServer.py:269
msgid ""
"Send and log an error reply.\n"
"\n"
"        Arguments are the error code, and a detailed message.\n"
"        The detailed message defaults to the short entry matching the\n"
"        response code.\n"
"\n"
"        This sends an error response (so it must be called before any\n"
"        output has been generated), logs the error, and finally sends\n"
"        a piece of HTML explaining the error to the user.\n"
"\n"
"        "
msgstr ""

#: Lib/BaseHTTPServer.py:299
msgid ""
"Send the response header and log the response code.\n"
"\n"
"        Also send two standard headers with the server software\n"
"        version and the current date.\n"
"\n"
"        "
msgstr ""

#: Lib/BaseHTTPServer.py:318
msgid "Send a MIME header."
msgstr ""

#: Lib/BaseHTTPServer.py:323
msgid "Send the blank line ending the MIME headers."
msgstr ""

#: Lib/BaseHTTPServer.py:328
msgid ""
"Log an accepted request.\n"
"\n"
"        This is called by send_reponse().\n"
"\n"
"        "
msgstr ""

#: Lib/BaseHTTPServer.py:338
msgid ""
"Log an error.\n"
"\n"
"        This is called when a request cannot be fulfilled.  By\n"
"        default it passes the message on to log_message().\n"
"\n"
"        Arguments are the same as for log_message().\n"
"\n"
"        XXX This should go to the separate error log.\n"
"\n"
"        "
msgstr ""

#: Lib/BaseHTTPServer.py:352
msgid ""
"Log an arbitrary message.\n"
"\n"
"        This is used by all other logging functions.  Override\n"
"        it if you have specific logging wishes.\n"
"\n"
"        The first argument, FORMAT, is a format string for the\n"
"        message to be logged.  If the format string contains\n"
"        any % escapes requiring parameters, they should be\n"
"        specified as subsequent arguments (it's just like\n"
"        printf!).\n"
"\n"
"        The client host and current date/time are prefixed to\n"
"        every message.\n"
"\n"
"        "
msgstr ""

#: Lib/BaseHTTPServer.py:374
msgid "Return the server software version string."
msgstr ""

#: Lib/BaseHTTPServer.py:378
msgid "Return the current date and time formatted for a message header."
msgstr ""

#: Lib/BaseHTTPServer.py:388
msgid "Return the current time formatted for logging."
msgstr ""

#: Lib/BaseHTTPServer.py:402
msgid ""
"Return the client address formatted for logging.\n"
"\n"
"        This version looks up the full hostname using gethostbyaddr(),\n"
"        and tries to find a name that contains at least one dot.\n"
"\n"
"        "
msgstr ""

#: Lib/BaseHTTPServer.py:462
msgid ""
"Test the HTTP request handler class.\n"
"\n"
"    This runs an HTTP server on port 8000 (or the first command line\n"
"    argument).\n"
"\n"
"    "
msgstr ""

#: Lib/Bastion.py:36
msgid ""
"Helper class used by the Bastion() function.\n"
"\n"
"    You could subclass this and pass the subclass as the bastionclass\n"
"    argument to the Bastion() function, as long as the constructor has\n"
"    the same signature (a get() function and a name for the object).\n"
"\n"
"    "
msgstr ""

#: Lib/Bastion.py:45
msgid ""
"Constructor.\n"
"\n"
"        Arguments:\n"
"\n"
"        get - a function that gets the attribute value (by name)\n"
"        name - a human-readable name for the original object\n"
"               (suggestion: use repr(object))\n"
"\n"
"        "
msgstr ""

#: Lib/Bastion.py:58
msgid ""
"Return a representation string.\n"
"\n"
"        This includes the name passed in to the constructor, so that\n"
"        if you print the bastion during debugging, at least you have\n"
"        some idea of what it is.\n"
"\n"
"        "
msgstr ""

#: Lib/Bastion.py:68
msgid ""
"Get an as-yet undefined attribute value.\n"
"\n"
"        This calls the get() function that was passed to the\n"
"        constructor.  The result is stored as an instance variable so\n"
"        that the next time the same attribute is requested,\n"
"        __getattr__() won't be invoked.\n"
"\n"
"        If the get() function raises an exception, this is simply\n"
"        passed on -- exceptions are not cached.\n"
"\n"
"        "
msgstr ""

#. Note: we define *two* ad-hoc functions here, get1 and get2.
#. Both are intended to be called in the same way: get(name).
#. It is clear that the real work (getting the attribute
#. from the object and calling the filter) is done in get1.
#. Why can't we pass get1 to the bastion?  Because the user
#. would be able to override the filter argument!  With get2,
#. overriding the default argument is no security loophole:
#. all it does is call it.
#. Also notice that we can't place the object and filter as
#. instance variables on the bastion object itself, since
#. the user has full access to all instance variables!
#: Lib/Bastion.py:86
msgid ""
"Create a bastion for an object, using an optional filter.\n"
"\n"
"    See the Bastion module's documentation for background.\n"
"\n"
"    Arguments:\n"
"\n"
"    object - the original object\n"
"    filter - a predicate that decides whether a function name is OK;\n"
"             by default all names are OK that don't start with '_'\n"
"    name - the name of the object; default repr(object)\n"
"    bastionclass - class used to create the bastion; default BastionClass\n"
"\n"
"    "
msgstr ""

#: Lib/Bastion.py:113 :121
msgid "Internal function for Bastion().  See source comments."
msgstr ""

#: Lib/Bastion.py:130
msgid "Test the Bastion() function."
msgstr ""

#. Determine platform specifics
#: Lib/CGIHTTPServer.py:33
msgid ""
"Complete HTTP server with GET, HEAD and POST commands.\n"
"\n"
"    GET and HEAD also support running CGI scripts.\n"
"\n"
"    The POST command is *only* implemented for CGI scripts.\n"
"\n"
"    "
msgstr ""

#: Lib/CGIHTTPServer.py:50
msgid ""
"Serve a POST request.\n"
"\n"
"        This is only implemented for CGI scripts.\n"
"\n"
"        "
msgstr ""

#: Lib/CGIHTTPServer.py:62
msgid "Version of send_head that support CGI scripts"
msgstr ""

#: Lib/CGIHTTPServer.py:69
msgid ""
"Test whether self.path corresponds to a CGI script.\n"
"\n"
"        Return a tuple (dir, rest) if self.path requires running a\n"
"        CGI script, None if not.  Note that rest begins with a\n"
"        slash if it is not empty.\n"
"\n"
"        The default implementation tests whether the path\n"
"        begins with one of the strings in the list\n"
"        self.cgi_directories (and the next character is a '/'\n"
"        or the end of the string).\n"
"\n"
"        "
msgstr ""

#: Lib/CGIHTTPServer.py:94
msgid "Test whether argument path is an executable file."
msgstr ""

#: Lib/CGIHTTPServer.py:98
msgid "Test whether argument path is a Python script."
msgstr ""

#: Lib/CGIHTTPServer.py:103
msgid "Execute a CGI script."
msgstr ""

#: Lib/CGIHTTPServer.py:275
msgid "Internal routine to get nobody's uid"
msgstr ""

#: Lib/CGIHTTPServer.py:291
msgid "Test for executable file."
msgstr ""

#. self.__sections will never have [DEFAULT] in it
#: Lib/ConfigParser.py:187
msgid "Return a list of section names, excluding [DEFAULT]"
msgstr ""

#: Lib/ConfigParser.py:192
msgid ""
"Create a new section in the configuration.\n"
"\n"
"        Raise DuplicateSectionError if a section by the specified name\n"
"        already exists.\n"
"        "
msgstr ""

#: Lib/ConfigParser.py:202
msgid ""
"Indicate whether the named section is present in the configuration.\n"
"\n"
"        The DEFAULT section is not acknowledged.\n"
"        "
msgstr ""

#: Lib/ConfigParser.py:209
msgid "Return a list of option names for the given section name."
msgstr ""

#: Lib/ConfigParser.py:220
msgid "Return whether the given section has the given option."
msgstr ""

#: Lib/ConfigParser.py:224
msgid ""
"Read and parse a filename or a list of filenames.\n"
"\n"
"        Files that cannot be opened are silently ignored; this is\n"
"        designed so that you can specify a list of potential\n"
"        configuration file locations (e.g. current directory, user's\n"
"        home directory, systemwide directory), and all existing\n"
"        configuration files in the list will be read.  A single\n"
"        filename may also be given.\n"
"        "
msgstr ""

#: Lib/ConfigParser.py:244
msgid ""
"Like read() but the argument must be a file-like object.\n"
"\n"
"        The `fp' argument must have a `readline' method.  Optional\n"
"        second argument is the `filename', which if not given, is\n"
"        taken from fp.name.  If fp has no `name' attribute, `<???>' is\n"
"        used.\n"
"\n"
"        "
msgstr ""

#: Lib/ConfigParser.py:260
msgid ""
"Get an option value for a given section.\n"
"\n"
"        All % interpolations are expanded in the return values, based on the\n"
"        defaults passed into the constructor, unless the optional argument\n"
"        `raw' is true.  Additional substitutions may be provided using the\n"
"        `vars' argument, which must be a dictionary whose contents overrides\n"
"        any pre-existing defaults.\n"
"\n"
"        The section DEFAULT is special.\n"
"        "
msgstr ""

#: Lib/ConfigParser.py:327
msgid "Check for the existence of a given option in a given section."
msgstr ""

#: Lib/ConfigParser.py:337
msgid "Set an option."
msgstr ""

#: Lib/ConfigParser.py:349
msgid "Write an .ini-format representation of the configuration state."
msgstr ""

#: Lib/ConfigParser.py:365
msgid "Remove an option."
msgstr ""

#: Lib/ConfigParser.py:380
msgid "Remove a file section."
msgstr ""

#: Lib/ConfigParser.py:406
msgid ""
"Parse a sectioned setup file.\n"
"\n"
"        The sections in setup file contains a title line at the top,\n"
"        indicated by a name in square brackets (`[]'), plus key/value\n"
"        options lines, indicated by `name: value' format lines.\n"
"        Continuation are represented by an embedded newline then\n"
"        leading whitespace.  Blank lines, lines beginning with a '#',\n"
"        and just about everything else is ignored.\n"
"        "
msgstr ""

#: Lib/Cookie.py:549
msgid ""
"real_value, coded_value = value_decode(STRING)\n"
"        Called prior to setting a cookie's value from the network\n"
"        representation.  The VALUE is the value read from HTTP\n"
"        header.\n"
"        Override this function to modify the behavior of cookies.\n"
"        "
msgstr ""

#: Lib/Cookie.py:559
msgid ""
"real_value, coded_value = value_encode(VALUE)\n"
"        Called prior to setting a cookie's value from the dictionary\n"
"        representation.  The VALUE is the value being assigned.\n"
"        Override this function to modify the behavior of cookies.\n"
"        "
msgstr ""

#: Lib/Cookie.py:574
msgid "Private method for setting a cookie's value"
msgstr ""

#: Lib/Cookie.py:581
msgid "Dictionary style assignment."
msgstr ""

#: Lib/Cookie.py:587
msgid "Return a string suitable for HTTP."
msgstr ""

#: Lib/Cookie.py:603
msgid "Return a string suitable for JavaScript."
msgstr ""

#: Lib/Cookie.py:611
msgid ""
"Load cookies from a string (presumably HTTP_COOKIE) or\n"
"        from a dictionary.  Loading cookies from a dictionary 'd'\n"
"        is equivalent to calling:\n"
"            map(Cookie.__setitem__, d.keys(), d.values())\n"
"        "
msgstr ""

#: Lib/Cookie.py:654
msgid ""
"SimpleCookie\n"
"    SimpleCookie supports strings as cookie values.  When setting\n"
"    the value using the dictionary assignment notation, SimpleCookie\n"
"    calls the builtin str() to convert the value to a string.  Values\n"
"    received from HTTP are kept as strings.\n"
"    "
msgstr ""

#: Lib/Cookie.py:668
msgid ""
"SerialCookie\n"
"    SerialCookie supports arbitrary objects as cookie values. All\n"
"    values are serialized (using cPickle) before being sent to the\n"
"    client.  All incoming values are assumed to be valid Pickle\n"
"    representations.  IF AN INCOMING VALUE IS NOT IN A VALID PICKLE\n"
"    FORMAT, THEN AN EXCEPTION WILL BE RAISED.\n"
"\n"
"    Note: Large cookie values add overhead because they must be\n"
"    retransmitted on every HTTP transaction.\n"
"\n"
"    Note: HTTP has a 2k limit on the size of a cookie.  This class\n"
"    does not check for this limit, so be careful!!!\n"
"    "
msgstr ""

#: Lib/Cookie.py:689
msgid ""
"SmartCookie\n"
"    SmartCookie supports arbitrary objects as cookie values.  If the\n"
"    object is a string, then it is quoted.  If the object is not a\n"
"    string, however, then SmartCookie will use cPickle to serialize\n"
"    the object into a string representation.\n"
"\n"
"    Note: Large cookie values add overhead because they must be\n"
"    retransmitted on every HTTP transaction.\n"
"\n"
"    Note: HTTP has a 2k limit on the size of a cookie.  This class\n"
"    does not check for this limit, so be careful!!!\n"
"    "
msgstr ""

#: Lib/MimeWriter.py:16
msgid ""
"Generic MIME writer.\n"
"\n"
"    Methods:\n"
"\n"
"    __init__()\n"
"    addheader()\n"
"    flushheaders()\n"
"    startbody()\n"
"    startmultipartbody()\n"
"    nextpart()\n"
"    lastpart()\n"
"\n"
"    A MIME writer is much more primitive than a MIME parser.  It\n"
"    doesn't seek around on the output file, and it doesn't use large\n"
"    amounts of buffer space, so you have to write the parts in the\n"
"    order they should occur on the output file.  It does buffer the\n"
"    headers you add, allowing you to rearrange their order.\n"
"\n"
"    General usage is:\n"
"\n"
"    f = <open the output file>\n"
"    w = MimeWriter(f)\n"
"    ...call w.addheader(key, value) 0 or more times...\n"
"\n"
"    followed by either:\n"
"\n"
"    f = w.startbody(content_type)\n"
"    ...call f.write(data) for body data...\n"
"\n"
"    or:\n"
"\n"
"    w.startmultipartbody(subtype)\n"
"    for each part:\n"
"        subwriter = w.nextpart()\n"
"        ...use the subwriter's methods to create the subpart...\n"
"    w.lastpart()\n"
"\n"
"    The subwriter is another MimeWriter instance, and should be\n"
"    treated in the same way as the toplevel MimeWriter.  This way,\n"
"    writing recursive body parts is easy.\n"
"\n"
"    Warning: don't forget to call lastpart()!\n"
"\n"
"    XXX There should be more state so calls made in the wrong order\n"
"    are detected.\n"
"\n"
"    Some special cases:\n"
"\n"
"    - startbody() just returns the file passed to the constructor;\n"
"      but don't use this knowledge, as it may be changed.\n"
"\n"
"    - startmultipartbody() actually returns a file as well;\n"
"      this can be used to write the initial 'if you can read this your\n"
"      mailer is not MIME-aware' message.\n"
"\n"
"    - If you call flushheaders(), the headers accumulated so far are\n"
"      written out (and forgotten); this is useful if you don't need a\n"
"      body part at all, e.g. for a subpart of type message/rfc822\n"
"      that's (mis)used to store some header-like information.\n"
"\n"
"    - Passing a keyword argument 'prefix=<flag>' to addheader(),\n"
"      start*body() affects where the header is inserted; 0 means\n"
"      append at the end, 1 means insert at the start; default is\n"
"      append for addheader(), but insert for start*body(), which use\n"
"      it to determine where the Content-Type header goes.\n"
"\n"
"    "
msgstr ""

#: Lib/Queue.py:4
msgid "Exception raised by Queue.get(block=0)/get_nowait()."
msgstr ""

#: Lib/Queue.py:8
msgid "Exception raised by Queue.put(block=0)/put_nowait()."
msgstr ""

#: Lib/Queue.py:13
msgid ""
"Initialize a queue object with a given maximum size.\n"
"\n"
"        If maxsize is <= 0, the queue size is infinite.\n"
"        "
msgstr ""

#: Lib/Queue.py:25
msgid "Return the approximate size of the queue (not reliable!)."
msgstr ""

#: Lib/Queue.py:32
msgid "Return 1 if the queue is empty, 0 otherwise (not reliable!)."
msgstr ""

#: Lib/Queue.py:39
msgid "Return 1 if the queue is full, 0 otherwise (not reliable!)."
msgstr ""

#: Lib/Queue.py:46
msgid ""
"Put an item into the queue.\n"
"\n"
"        If optional arg 'block' is 1 (the default), block if\n"
"        necessary until a free slot is available.  Otherwise (block\n"
"        is 0), put an item on the queue if a free slot is immediately\n"
"        available, else raise the Full exception.\n"
"        "
msgstr ""

#: Lib/Queue.py:67
msgid ""
"Put an item into the queue without blocking.\n"
"\n"
"        Only enqueue the item if a free slot is immediately available.\n"
"        Otherwise raise the Full exception.\n"
"        "
msgstr ""

#: Lib/Queue.py:75
msgid ""
"Remove and return an item from the queue.\n"
"\n"
"        If optional arg 'block' is 1 (the default), block if\n"
"        necessary until an item is available.  Otherwise (block is 0),\n"
"        return an item if one is immediately available, else raise the\n"
"        Empty exception.\n"
"        "
msgstr ""

#: Lib/Queue.py:97
msgid ""
"Remove and return an item from the queue without blocking.\n"
"\n"
"        Only get an item if one is immediately available.  Otherwise\n"
"        raise the Empty exception.\n"
"        "
msgstr ""

#: Lib/SimpleHTTPServer.py:25
msgid ""
"Simple HTTP request handler with GET and HEAD commands.\n"
"\n"
"    This serves files from the current directory and any of its\n"
"    subdirectories.  It assumes that all files are plain text files\n"
"    unless they have the extension \".html\" in which case it assumes\n"
"    they are HTML files.\n"
"\n"
"    The GET and HEAD requests are identical except that the HEAD\n"
"    request omits the actual contents of the file.\n"
"\n"
"    "
msgstr ""

#: Lib/SimpleHTTPServer.py:40
msgid "Serve a GET request."
msgstr ""

#: Lib/SimpleHTTPServer.py:47
msgid "Serve a HEAD request."
msgstr ""

#: Lib/SimpleHTTPServer.py:53
msgid ""
"Common code for GET and HEAD commands.\n"
"\n"
"        This sends the response code and MIME headers.\n"
"\n"
"        Return value is either a file object (which has to be copied\n"
"        to the outputfile by the caller unless the command was HEAD,\n"
"        and must be closed by the caller under all circumstances), or\n"
"        None, in which case the caller has nothing further to do.\n"
"\n"
"        "
msgstr ""

#: Lib/SimpleHTTPServer.py:89
msgid ""
"Helper to produce a directory listing (absent index.html).\n"
"\n"
"        Return value is either a file object, or None (indicating an\n"
"        error).  In either case, the headers are sent, making the\n"
"        interface the same as for send_head().\n"
"\n"
"        "
msgstr ""

#: Lib/SimpleHTTPServer.py:125
msgid ""
"Translate a /-separated PATH to the local filename syntax.\n"
"\n"
"        Components that mean special things to the local file system\n"
"        (e.g. drive or directory names) are ignored.  (XXX They should\n"
"        probably be diagnosed.)\n"
"\n"
"        "
msgstr ""

#: Lib/SimpleHTTPServer.py:144
msgid ""
"Copy all data between two file objects.\n"
"\n"
"        The SOURCE argument is a file object open for reading\n"
"        (or anything with a read() method) and the DESTINATION\n"
"        argument is a file object open for writing (or\n"
"        anything with a write() method).\n"
"\n"
"        The only reason for overriding this would be to change\n"
"        the block size or perhaps to replace newlines by CRLF\n"
"        -- note however that this the default server uses this\n"
"        to copy binary data as well.\n"
"\n"
"        "
msgstr ""

#: Lib/SimpleHTTPServer.py:160
msgid ""
"Guess the type of a file.\n"
"\n"
"        Argument is a PATH (a filename).\n"
"\n"
"        Return value is a string of the form type/subtype,\n"
"        usable for a MIME Content-type header.\n"
"\n"
"        The default implementation looks the file's extension\n"
"        up in the table self.extensions_map, using text/plain\n"
"        as a default; however it would be permissible (if\n"
"        slow) to look inside the data to make a better guess.\n"
"\n"
"        "
msgstr ""

#: Lib/SocketServer.py:140
msgid ""
"Base class for server classes.\n"
"\n"
"    Methods for the caller:\n"
"\n"
"    - __init__(server_address, RequestHandlerClass)\n"
"    - serve_forever()\n"
"    - handle_request()  # if you do not use serve_forever()\n"
"    - fileno() -> int   # for select()\n"
"\n"
"    Methods that may be overridden:\n"
"\n"
"    - server_bind()\n"
"    - server_activate()\n"
"    - get_request() -> request, client_address\n"
"    - verify_request(request, client_address)\n"
"    - server_close()\n"
"    - process_request(request, client_address)\n"
"    - close_request(request)\n"
"    - handle_error()\n"
"\n"
"    Methods for derived classes:\n"
"\n"
"    - finish_request(request, client_address)\n"
"\n"
"    Class variables that may be overridden by derived classes or\n"
"    instances:\n"
"\n"
"    - address_family\n"
"    - socket_type\n"
"    - reuse_address\n"
"\n"
"    Instance variables:\n"
"\n"
"    - RequestHandlerClass\n"
"    - socket\n"
"\n"
"    "
msgstr ""

#: Lib/SocketServer.py:179 :318
msgid "Constructor.  May be extended, do not override."
msgstr ""

#: Lib/SocketServer.py:184 :336
msgid ""
"Called by constructor to activate the server.\n"
"\n"
"        May be overridden.\n"
"\n"
"        "
msgstr ""

#: Lib/SocketServer.py:192
msgid "Handle one request at a time until doomsday."
msgstr ""

#: Lib/SocketServer.py:208
msgid "Handle one request, possibly blocking."
msgstr ""

#: Lib/SocketServer.py:221
msgid ""
"Verify the request.  May be overridden.\n"
"\n"
"        Return true if we should proceed with this request.\n"
"\n"
"        "
msgstr ""

#: Lib/SocketServer.py:229
msgid ""
"Call finish_request.\n"
"\n"
"        Overridden by ForkingMixIn and ThreadingMixIn.\n"
"\n"
"        "
msgstr ""

#: Lib/SocketServer.py:237 :344
msgid ""
"Called to clean-up the server.\n"
"\n"
"        May be overridden.\n"
"\n"
"        "
msgstr ""

#: Lib/SocketServer.py:245
msgid "Finish one request by instantiating RequestHandlerClass."
msgstr ""

#: Lib/SocketServer.py:249 :368
msgid "Called to clean up an individual request."
msgstr ""

#: Lib/SocketServer.py:253
msgid ""
"Handle an error gracefully.  May be overridden.\n"
"\n"
"        The default is to print a traceback and continue.\n"
"\n"
"        "
msgstr ""

#: Lib/SocketServer.py:268
msgid ""
"Base class for various socket-based server classes.\n"
"\n"
"    Defaults to synchronous IP stream (i.e., TCP).\n"
"\n"
"    Methods for the caller:\n"
"\n"
"    - __init__(server_address, RequestHandlerClass)\n"
"    - serve_forever()\n"
"    - handle_request()  # if you don't use serve_forever()\n"
"    - fileno() -> int   # for select()\n"
"\n"
"    Methods that may be overridden:\n"
"\n"
"    - server_bind()\n"
"    - server_activate()\n"
"    - get_request() -> request, client_address\n"
"    - verify_request(request, client_address)\n"
"    - process_request(request, client_address)\n"
"    - close_request(request)\n"
"    - handle_error()\n"
"\n"
"    Methods for derived classes:\n"
"\n"
"    - finish_request(request, client_address)\n"
"\n"
"    Class variables that may be overridden by derived classes or\n"
"    instances:\n"
"\n"
"    - address_family\n"
"    - socket_type\n"
"    - request_queue_size (only for stream sockets)\n"
"    - reuse_address\n"
"\n"
"    Instance variables:\n"
"\n"
"    - server_address\n"
"    - RequestHandlerClass\n"
"    - socket\n"
"\n"
"    "
msgstr ""

#: Lib/SocketServer.py:326
msgid ""
"Called by constructor to bind the socket.\n"
"\n"
"        May be overridden.\n"
"\n"
"        "
msgstr ""

#: Lib/SocketServer.py:352
msgid ""
"Return socket file number.\n"
"\n"
"        Interface required by select().\n"
"\n"
"        "
msgstr ""

#: Lib/SocketServer.py:360
msgid ""
"Get the request and client address from the socket.\n"
"\n"
"        May be overridden.\n"
"\n"
"        "
msgstr ""

#: Lib/SocketServer.py:374
msgid "UDP server class."
msgstr ""

#: Lib/SocketServer.py:396
msgid "Mix-in class to handle each request in a new process."
msgstr ""

#: Lib/SocketServer.py:402
msgid "Internal routine to wait for died children."
msgstr ""

#: Lib/SocketServer.py:418
msgid "Fork a new subprocess to process the request."
msgstr ""

#: Lib/SocketServer.py:443
msgid "Mix-in class to handle each request in a new thread."
msgstr ""

#: Lib/SocketServer.py:446
msgid "Start a new thread to process the request."
msgstr ""

#: Lib/SocketServer.py:473
msgid ""
"Base class for request handler classes.\n"
"\n"
"    This class is instantiated for each request to be handled.  The\n"
"    constructor sets the instance variables request, client_address\n"
"    and server, and then calls the handle() method.  To implement a\n"
"    specific service, all you need to do is to derive a class which\n"
"    defines a handle() method.\n"
"\n"
"    The handle() method can find the request as self.request, the\n"
"    client address as self.client_address, and the server (in case it\n"
"    needs access to per-server information) as self.server.  Since a\n"
"    separate instance is created for each request, the handle() method\n"
"    can define arbitrary other instance variariables.\n"
"\n"
"    "
msgstr ""

#. Default buffer sizes for rfile, wfile.
#. We default rfile to buffered because otherwise it could be
#. really slow for large data (a getc() call per byte); we make
#. wfile unbuffered because (a) often after a write() we want to
#. read and we need to flush the line; (b) big writes to unbuffered
#. files are typically optimized by stdio even when big reads
#. aren't.
#: Lib/SocketServer.py:523
msgid "Define self.rfile and self.wfile for stream sockets."
msgstr ""

#: Lib/SocketServer.py:548
msgid "Define self.rfile and self.wfile for datagram sockets."
msgstr ""

#: Lib/UserString.py:125
msgid ""
"mutable string objects\n"
"\n"
"    Python strings are immutable objects.  This has the advantage, that\n"
"    strings may be used as dictionary keys.  If this property isn't needed\n"
"    and you insist on changing string values in place instead, you may cheat\n"
"    and use MutableString.\n"
"\n"
"    But the purpose of this class is an educational one: to prevent\n"
"    people from inventing their own mutable string class derived\n"
"    from UserString and than forget thereby to remove (override) the\n"
"    __hash__ method inherited from ^UserString.  This would lead to\n"
"    errors that would be very hard to track down.\n"
"\n"
"    A faster and better solution is to rewrite your program using lists."
msgstr ""

#: Lib/__future__.py:49
msgid ""
"Return first release in which this feature was recognized.\n"
"\n"
"        This is a 5-tuple, of the same form as sys.version_info.\n"
"        "
msgstr ""

#: Lib/__future__.py:57
msgid ""
"Return release in which this feature will become mandatory.\n"
"\n"
"        This is a 5-tuple, of the same form as sys.version_info, or, if\n"
"        the feature was dropped, is None.\n"
"        "
msgstr ""

#. these are overridable defaults
#: Lib/asynchat.py:53
msgid ""
"This is an abstract class.  You must derive from this class, and add\n"
"    the two methods collect_incoming_data() and found_terminator()"
msgstr ""

#: Lib/asynchat.py:68
msgid "Set the input delimiter.  Can be a fixed string of any length, an integer, or None"
msgstr ""

#: Lib/asynchat.py:160
msgid "predicate for inclusion in the readable for select()"
msgstr ""

#. return len(self.ac_out_buffer) or len(self.producer_fifo) or (not self.connected)
#. this is about twice as fast, though not as clear.
#: Lib/asynchat.py:164
msgid "predicate for inclusion in the writable for select()"
msgstr ""

#: Lib/asynchat.py:174
msgid "automatically close this channel once the outgoing queue is empty"
msgstr ""

#: Lib/atexit.py:12
msgid ""
"run any registered exit functions\n"
"\n"
"    _exithandlers is traversed in reverse order so functions are executed\n"
"    last in, first out.\n"
"    "
msgstr ""

#: Lib/atexit.py:23
msgid ""
"register a function to be executed upon normal program termination\n"
"\n"
"    func - function to be called at exit\n"
"    targs - optional arguments to pass to func\n"
"    kargs - optional keyword arguments to pass to func\n"
"    "
msgstr ""

#: Lib/base64.py:15
msgid "Encode a file."
msgstr ""

#: Lib/base64.py:27
msgid "Decode a file."
msgstr ""

#: Lib/base64.py:35
msgid "Encode a string."
msgstr ""

#: Lib/base64.py:43
msgid "Decode a string."
msgstr ""

#: Lib/base64.py:51
msgid "Small test program"
msgstr ""

#: Lib/bdb.py:14
msgid ""
"Generic Python debugger base class.\n"
"\n"
"    This class takes care of details of the trace facility;\n"
"    a derived class should implement user interaction.\n"
"    The standard debugger class (pdb.Pdb) is an example.\n"
"    "
msgstr ""

#: Lib/bdb.py:127
msgid ""
"This method is called when there is the remote possibility\n"
"        that we ever need to stop in this function."
msgstr ""

#: Lib/bdb.py:132
msgid "This method is called when we stop or break at this line."
msgstr ""

#: Lib/bdb.py:136
msgid "This method is called when a return trap is set here."
msgstr ""

#: Lib/bdb.py:140
msgid ""
"This method is called if an exception occurs,\n"
"        but only if we are to stop at or just below this level."
msgstr ""

#: Lib/bdb.py:148
msgid "Stop after one line of code."
msgstr ""

#: Lib/bdb.py:154
msgid "Stop on the next line in or below the given frame."
msgstr ""

#: Lib/bdb.py:160
msgid "Stop when returning from the given frame."
msgstr ""

#: Lib/bdb.py:166
msgid "Start debugging from here."
msgstr ""

#. XXX Keeping state in the class is a mistake -- this means
#. you cannot have more than one active Bdb instance.
#: Lib/bdb.py:404
msgid ""
"Breakpoint class\n"
"\n"
"    Implements temporary breakpoints, ignore counts, disabling and\n"
"    (re)-enabling, and conditionals.\n"
"\n"
"    Breakpoints are indexed by number through bpbynumber and by\n"
"    the file,line tuple using bplist.  The former points to a\n"
"    single instance of class Breakpoint.  The latter points to a\n"
"    list of such instances since there may be more than one\n"
"    breakpoint per line.\n"
"\n"
"    "
msgstr ""

#: Lib/bdb.py:484
msgid ""
"Determine which breakpoint for this file:line is to be acted upon.\n"
"\n"
"    Called only if we know there is a bpt at this\n"
"    location.  Returns breakpoint that was triggered and a flag\n"
"    that indicates if it is ok to delete a temporary bp.\n"
"\n"
"    "
msgstr ""

#: Lib/binhex.py:120
msgid "Write data to the coder in 3-byte chunks"
msgstr ""

#: Lib/binhex.py:159
msgid "Write data to the RLE-coder in suitably large chunks"
msgstr ""

#: Lib/binhex.py:258
msgid "(infilename, outfilename) - Create binhex-encoded copy of a file"
msgstr ""

#: Lib/binhex.py:280
msgid "Read data via the decoder in 4-byte chunks"
msgstr ""

#: Lib/binhex.py:287
msgid "Read at least wtd bytes (or until EOF)"
msgstr ""

#: Lib/binhex.py:324
msgid "Read data via the RLE-coder"
msgstr ""

#: Lib/binhex.py:480
msgid "(infilename, outfilename) - Decode binhexed file"
msgstr ""

#: Lib/bisect.py:4
msgid ""
"Insert item x in list a, and keep it sorted assuming a is sorted.\n"
"\n"
"    If x is already in a, insert it to the right of the rightmost x.\n"
"\n"
"    Optional args lo (default 0) and hi (default len(a)) bound the\n"
"    slice of a to be searched.\n"
"    "
msgstr ""

#: Lib/bisect.py:23
msgid ""
"Return the index where to insert item x in list a, assuming a is sorted.\n"
"\n"
"    The return value i is such that all e in a[:i] have e <= x, and all e in\n"
"    a[i:] have e > x.  So if x already appears in the list, i points just\n"
"    beyond the rightmost x already there.\n"
"\n"
"    Optional args lo (default 0) and hi (default len(a)) bound the\n"
"    slice of a to be searched.\n"
"    "
msgstr ""

#: Lib/bisect.py:44
msgid ""
"Insert item x in list a, and keep it sorted assuming a is sorted.\n"
"\n"
"    If x is already in a, insert it to the left of the leftmost x.\n"
"\n"
"    Optional args lo (default 0) and hi (default len(a)) bound the\n"
"    slice of a to be searched.\n"
"    "
msgstr ""

#: Lib/bisect.py:62
msgid ""
"Return the index where to insert item x in list a, assuming a is sorted.\n"
"\n"
"    The return value i is such that all e in a[:i] have e < x, and all e in\n"
"    a[i:] have e >= x.  So if x already appears in the list, i points just\n"
"    before the leftmost x already there.\n"
"\n"
"    Optional args lo (default 0) and hi (default len(a)) bound the\n"
"    slice of a to be searched.\n"
"    "
msgstr ""

#: Lib/calendar.py:48
msgid "Set weekday (Monday=0, Sunday=6) to start each week."
msgstr ""

#: Lib/calendar.py:56
msgid "Return 1 for leap years, 0 for non-leap years."
msgstr ""

#: Lib/calendar.py:60
msgid ""
"Return number of leap years in range [y1, y2).\n"
"       Assume y1 <= y2."
msgstr ""

#: Lib/calendar.py:67
msgid ""
"Return weekday (0-6 ~ Mon-Sun) for year (1970-...), month (1-12),\n"
"       day (1-31)."
msgstr ""

#: Lib/calendar.py:74
msgid ""
"Return weekday (0-6 ~ Mon-Sun) and number of days (28-31) for\n"
"       year, month."
msgstr ""

#: Lib/calendar.py:83
msgid ""
"Return a matrix representing a month's calendar.\n"
"       Each row represents a week; days outside this month are zero."
msgstr ""

#: Lib/calendar.py:98
msgid "Center a string in a field."
msgstr ""

#: Lib/calendar.py:105
msgid "Print a single week (no newline)."
msgstr ""

#: Lib/calendar.py:109
msgid "Returns a single week in a string (no newline)."
msgstr ""

#: Lib/calendar.py:120
msgid "Return a header for a week."
msgstr ""

#: Lib/calendar.py:131
msgid "Print a month's calendar."
msgstr ""

#: Lib/calendar.py:135
msgid "Return a month's calendar string (multi-line)."
msgstr ""

#: Lib/calendar.py:150
msgid "Prints 3-column formatting for year calendars"
msgstr ""

#: Lib/calendar.py:154
msgid "Returns a string formatted from 3 strings, centered within 3 columns."
msgstr ""

#: Lib/calendar.py:159
msgid "Print a year's calendar."
msgstr ""

#: Lib/calendar.py:163
msgid "Returns a year's calendar as a multi-line string."
msgstr ""

#: Lib/calendar.py:196
msgid "Unrelated but handy function to calculate Unix timestamp from GMT."
msgstr ""

#: Lib/cgi.py:59
msgid ""
"Write a log message, if there is a log file.\n"
"\n"
"    Even though this function is called initlog(), you should always\n"
"    use log(); log is a variable that is set either to initlog\n"
"    (initially), to dolog (once the log file has been opened), or to\n"
"    nolog (when logging is disabled).\n"
"\n"
"    The first argument is a format string; the remaining arguments (if\n"
"    any) are arguments to the % operator, so e.g.\n"
"        log(\"%s: %s\", \"a\", \"b\")\n"
"    will write \"a: b\" to the log file, followed by a newline.\n"
"\n"
"    If the global logfp is not None, it should be a file object to\n"
"    which log data is written.\n"
"\n"
"    If the global logfp is None, the global logfile may be a string\n"
"    giving a filename to open, in append mode.  This file should be\n"
"    world writable!!!  If the file can't be opened, logging is\n"
"    silently disabled (since there is no safe place where we could\n"
"    send an error message).\n"
"\n"
"    "
msgstr ""

#: Lib/cgi.py:94
msgid "Write a log message to the log file.  See initlog() for docs."
msgstr ""

#: Lib/cgi.py:98
msgid "Dummy function, assigned to log when logging is disabled."
msgstr ""

#: Lib/cgi.py:112
msgid ""
"Parse a query in the environment or from a file (default stdin)\n"
"\n"
"        Arguments, all optional:\n"
"\n"
"        fp              : file pointer; default: sys.stdin\n"
"\n"
"        environ         : environment dictionary; default: os.environ\n"
"\n"
"        keep_blank_values: flag indicating whether blank values in\n"
"            URL encoded forms should be treated as blank strings.\n"
"            A true value indicates that blanks should be retained as\n"
"            blank strings.  The default false value indicates that\n"
"            blank values are to be ignored and treated as if they were\n"
"            not included.\n"
"\n"
"        strict_parsing: flag indicating what to do with parsing errors.\n"
"            If false (the default), errors are silently ignored.\n"
"            If true, errors raise a ValueError exception.\n"
"    "
msgstr ""

#: Lib/cgi.py:165
msgid ""
"Parse a query given as a string argument.\n"
"\n"
"        Arguments:\n"
"\n"
"        qs: URL-encoded query string to be parsed\n"
"\n"
"        keep_blank_values: flag indicating whether blank values in\n"
"            URL encoded queries should be treated as blank strings.\n"
"            A true value indicates that blanks should be retained as\n"
"            blank strings.  The default false value indicates that\n"
"            blank values are to be ignored and treated as if they were\n"
"            not included.\n"
"\n"
"        strict_parsing: flag indicating what to do with parsing errors.\n"
"            If false (the default), errors are silently ignored.\n"
"            If true, errors raise a ValueError exception.\n"
"    "
msgstr ""

#: Lib/cgi.py:191
msgid ""
"Parse a query given as a string argument.\n"
"\n"
"    Arguments:\n"
"\n"
"    qs: URL-encoded query string to be parsed\n"
"\n"
"    keep_blank_values: flag indicating whether blank values in\n"
"        URL encoded queries should be treated as blank strings.  A\n"
"        true value indicates that blanks should be retained as blank\n"
"        strings.  The default false value indicates that blank values\n"
"        are to be ignored and treated as if they were  not included.\n"
"\n"
"    strict_parsing: flag indicating what to do with parsing errors. If\n"
"        false (the default), errors are silently ignored. If true,\n"
"        errors raise a ValueError exception.\n"
"\n"
"    Returns a list, as G-d intended.\n"
"    "
msgstr ""

#: Lib/cgi.py:226
msgid ""
"Parse multipart input.\n"
"\n"
"    Arguments:\n"
"    fp   : input file\n"
"    pdict: dictionary containing other parameters of conten-type header\n"
"\n"
"    Returns a dictionary just like parse_qs(): keys are the field names, each\n"
"    value is a list of values for that field.  This is easy to use but not\n"
"    much good if you are expecting megabytes to be uploaded -- in that case,\n"
"    use the FieldStorage class instead which is much more flexible.  Note\n"
"    that content-type is the raw, unparsed contents of the content-type\n"
"    header.\n"
"\n"
"    XXX This does not parse nested multipart parts -- use FieldStorage for\n"
"    that.\n"
"\n"
"    XXX This should really be subsumed by FieldStorage altogether -- no\n"
"    point in having two implementations of the same parsing algorithm.\n"
"\n"
"    "
msgstr ""

#: Lib/cgi.py:317
msgid ""
"Parse a Content-type like header.\n"
"\n"
"    Return the main content-type and a dictionary of options.\n"
"\n"
"    "
msgstr ""

#. Dummy attributes
#: Lib/cgi.py:342
msgid "Like FieldStorage, for use when no file uploads are possible."
msgstr ""

#: Lib/cgi.py:355
msgid "Constructor from field name and value."
msgstr ""

#: Lib/cgi.py:361
msgid "Return printable representation."
msgstr ""

#: Lib/cgi.py:367
msgid ""
"Store a sequence of fields, reading multipart/form-data.\n"
"\n"
"    This class provides naming, typing, files stored on disk, and\n"
"    more.  At the top level, it is accessible like a dictionary, whose\n"
"    keys are the field names.  (Note: None can occur as a field name.)\n"
"    The items are either a Python list (if there's multiple values) or\n"
"    another FieldStorage or MiniFieldStorage object.  If it's a single\n"
"    object, it has the following attributes:\n"
"\n"
"    name: the field name, if specified; otherwise None\n"
"\n"
"    filename: the filename, if specified; otherwise None; this is the\n"
"        client side filename, *not* the file name on which it is\n"
"        stored (that's a temporary file you don't deal with)\n"
"\n"
"    value: the value as a *string*; for file uploads, this\n"
"        transparently reads the file every time you request the value\n"
"\n"
"    file: the file(-like) object from which you can read the data;\n"
"        None if the data is stored a simple string\n"
"\n"
"    type: the content-type, or None if not specified\n"
"\n"
"    type_options: dictionary of options specified on the content-type\n"
"        line\n"
"\n"
"    disposition: content-disposition, or None if not specified\n"
"\n"
"    disposition_options: dictionary of corresponding options\n"
"\n"
"    headers: a dictionary(-like) object (sometimes rfc822.Message or a\n"
"        subclass thereof) containing *all* headers\n"
"\n"
"    The class is subclassable, mostly for the purpose of overriding\n"
"    the make_file() method, which is called internally to come up with\n"
"    a file open for reading and writing.  This makes it possible to\n"
"    override the default choice of storing all files in a temporary\n"
"    directory and unlinking them as soon as they have been opened.\n"
"\n"
"    "
msgstr ""

#: Lib/cgi.py:410
msgid ""
"Constructor.  Read multipart/* until last part.\n"
"\n"
"        Arguments, all optional:\n"
"\n"
"        fp              : file pointer; default: sys.stdin\n"
"            (not used when the request method is GET)\n"
"\n"
"        headers         : header dictionary-like object; default:\n"
"            taken from environ as per CGI spec\n"
"\n"
"        outerboundary   : terminating multipart boundary\n"
"            (for internal use only)\n"
"\n"
"        environ         : environment dictionary; default: os.environ\n"
"\n"
"        keep_blank_values: flag indicating whether blank values in\n"
"            URL encoded forms should be treated as blank strings.\n"
"            A true value indicates that blanks should be retained as\n"
"            blank strings.  The default false value indicates that\n"
"            blank values are to be ignored and treated as if they were\n"
"            not included.\n"
"\n"
"        strict_parsing: flag indicating what to do with parsing errors.\n"
"            If false (the default), errors are silently ignored.\n"
"            If true, errors raise a ValueError exception.\n"
"\n"
"        "
msgstr ""

#: Lib/cgi.py:522
msgid "Return a printable representation."
msgstr ""

#: Lib/cgi.py:540
msgid "Dictionary style indexing."
msgstr ""

#: Lib/cgi.py:554
msgid "Dictionary style get() method, including 'value' lookup."
msgstr ""

#: Lib/cgi.py:565
msgid "Dictionary style keys() method."
msgstr ""

#: Lib/cgi.py:574
msgid "Dictionary style has_key() method."
msgstr ""

#: Lib/cgi.py:582
msgid "Dictionary style len(x) support."
msgstr ""

#: Lib/cgi.py:586
msgid "Internal: read data in query string format."
msgstr ""

#: Lib/cgi.py:597
msgid "Internal: read a part that is itself multipart."
msgstr ""

#: Lib/cgi.py:611
msgid "Internal: read an atomic part."
msgstr ""

#: Lib/cgi.py:622
msgid "Internal: read binary data."
msgstr ""

#: Lib/cgi.py:635
msgid "Internal: read lines until EOF or outerboundary."
msgstr ""

#: Lib/cgi.py:643
msgid "Internal: read lines until EOF."
msgstr ""

#: Lib/cgi.py:652
msgid "Internal: read lines until outerboundary."
msgstr ""

#: Lib/cgi.py:680
msgid "Internal: skip lines until outer boundary if defined."
msgstr ""

#: Lib/cgi.py:699
msgid ""
"Overridable: return a readable & writable file.\n"
"\n"
"        The file will be used as follows:\n"
"        - data is written to it\n"
"        - seek(0)\n"
"        - data is read from it\n"
"\n"
"        The 'binary' argument is unused -- the file is always opened\n"
"        in binary mode.\n"
"\n"
"        This version opens a temporary file for reading and writing,\n"
"        and immediately deletes (unlinks) it.  The trick (on Unix!) is\n"
"        that the file can still be used, but it can't be opened by\n"
"        another process, and it will automatically be deleted when it\n"
"        is closed or when the current process terminates.\n"
"\n"
"        If you want a more permanent file, you derive a class which\n"
"        overrides this method.  If you want a visible temporary file\n"
"        that is nevertheless automatically deleted when the script\n"
"        terminates, try defining a __del__ method in a derived class\n"
"        which unlinks the temporary files you have created.\n"
"\n"
"        "
msgstr ""

#: Lib/cgi.py:731
msgid ""
"Form content as dictionary with a list of values per field.\n"
"\n"
"    form = FormContentDict()\n"
"\n"
"    form[key] -> [value, value, ...]\n"
"    form.has_key(key) -> Boolean\n"
"    form.keys() -> [key, key, ...]\n"
"    form.values() -> [[val, val, ...], [val, val, ...], ...]\n"
"    form.items() ->  [(key, [val, val, ...]), (key, [val, val, ...]), ...]\n"
"    form.dict == {key: [val, val, ...], ...}\n"
"\n"
"    "
msgstr ""

#: Lib/cgi.py:749
msgid ""
"Form content as dictionary expecting a single value per field.\n"
"\n"
"    If you only expect a single value for each field, then form[key]\n"
"    will return that single value.  It will raise an IndexError if\n"
"    that expectation is not true.  If you expect a field to have\n"
"    possible multiple values, than you can use form.getlist(key) to\n"
"    get all of the values.  values() and items() are a compromise:\n"
"    they return single strings where there is a single value, and\n"
"    lists of strings otherwise.\n"
"\n"
"    "
msgstr ""

#: Lib/cgi.py:783 :811
msgid "This class is present for backwards compatibility only."
msgstr ""

#: Lib/cgi.py:837
msgid ""
"Robust test CGI script, usable as main program.\n"
"\n"
"    Write minimal HTTP headers and dump all information provided to\n"
"    the script in HTML form.\n"
"\n"
"    "
msgstr ""

#: Lib/cgi.py:891
msgid "Dump the shell environment as HTML."
msgstr ""

#: Lib/cgi.py:903
msgid "Dump the contents of a form as HTML."
msgstr ""

#: Lib/cgi.py:920
msgid "Dump the current directory as HTML."
msgstr ""

#: Lib/cgi.py:939
msgid "Dump a list of environment variables used by CGI as HTML."
msgstr ""

#: Lib/cgi.py:986
msgid "Replace special characters '&', '<' and '>' by SGML entities."
msgstr ""

#: Lib/chunk.py:79
msgid "Return the name (ID) of the current chunk."
msgstr ""

#: Lib/chunk.py:83
msgid "Return the size of the current chunk."
msgstr ""

#: Lib/chunk.py:97
msgid ""
"Seek to specified position into the chunk.\n"
"        Default position is 0 (start of chunk).\n"
"        If the file is not seekable, this will result in an error.\n"
"        "
msgstr ""

#: Lib/chunk.py:121
msgid ""
"Read at most size bytes from the chunk.\n"
"        If size is omitted or negative, read until the end\n"
"        of the chunk.\n"
"        "
msgstr ""

#: Lib/chunk.py:144
msgid ""
"Skip the rest of the chunk.\n"
"        If you are not interested in the contents of the chunk,\n"
"        this method should be called so that the file points to\n"
"        the start of the next chunk.\n"
"        "
msgstr ""

#: Lib/code.py:28
msgid ""
"Base class for InteractiveConsole.\n"
"\n"
"    This class deals with parsing and interpreter state (the user's\n"
"    namespace); it doesn't deal with input buffering or prompting or\n"
"    input file naming (the filename is always passed in explicitly).\n"
"\n"
"    "
msgstr ""

#: Lib/code.py:37
msgid ""
"Constructor.\n"
"\n"
"        The optional 'locals' argument specifies the dictionary in\n"
"        which code will be executed; it defaults to a newly created\n"
"        dictionary with key \"__name__\" set to \"__console__\" and key\n"
"        \"__doc__\" set to None.\n"
"\n"
"        "
msgstr ""

#: Lib/code.py:50
msgid ""
"Compile and run some source in the interpreter.\n"
"\n"
"        Arguments are as for compile_command().\n"
"\n"
"        One several things can happen:\n"
"\n"
"        1) The input is incorrect; compile_command() raised an\n"
"        exception (SyntaxError or OverflowError).  A syntax traceback\n"
"        will be printed by calling the showsyntaxerror() method.\n"
"\n"
"        2) The input is incomplete, and more input is required;\n"
"        compile_command() returned None.  Nothing happens.\n"
"\n"
"        3) The input is complete; compile_command() returned a code\n"
"        object.  The code is executed by calling self.runcode() (which\n"
"        also handles run-time exceptions, except for SystemExit).\n"
"\n"
"        The return value is 1 in case 2, 0 in the other cases (unless\n"
"        an exception is raised).  The return value can be used to\n"
"        decide whether to use sys.ps1 or sys.ps2 to prompt the next\n"
"        line.\n"
"\n"
"        "
msgstr ""

#: Lib/code.py:89
msgid ""
"Execute a code object.\n"
"\n"
"        When an exception occurs, self.showtraceback() is called to\n"
"        display a traceback.  All exceptions are caught except\n"
"        SystemExit, which is reraised.\n"
"\n"
"        A note about KeyboardInterrupt: this exception may occur\n"
"        elsewhere in this code, and may not always be caught.  The\n"
"        caller should be prepared to deal with it.\n"
"\n"
"        "
msgstr ""

#: Lib/code.py:111
msgid ""
"Display the syntax error that just occurred.\n"
"\n"
"        This doesn't display a stack trace because there isn't one.\n"
"\n"
"        If a filename is given, it is stuffed in the exception instead\n"
"        of what was there before (because Python's parser always uses\n"
"        \"<string>\" when reading from a string).\n"
"\n"
"        The output is written by self.write(), below.\n"
"\n"
"        "
msgstr ""

#: Lib/code.py:144
msgid ""
"Display the exception that just occurred.\n"
"\n"
"        We remove the first stack item because it is our own code.\n"
"\n"
"        The output is written by self.write(), below.\n"
"\n"
"        "
msgstr ""

#: Lib/code.py:167
msgid ""
"Write a string.\n"
"\n"
"        The base implementation writes to sys.stderr; a subclass may\n"
"        replace this with a different implementation.\n"
"\n"
"        "
msgstr ""

#: Lib/code.py:177
msgid ""
"Closely emulate the behavior of the interactive Python interpreter.\n"
"\n"
"    This class builds on InteractiveInterpreter and adds prompting\n"
"    using the familiar sys.ps1 and sys.ps2, and input buffering.\n"
"\n"
"    "
msgstr ""

#: Lib/code.py:185
msgid ""
"Constructor.\n"
"\n"
"        The optional locals argument will be passed to the\n"
"        InteractiveInterpreter base class.\n"
"\n"
"        The optional filename argument should specify the (file)name\n"
"        of the input stream; it will show up in tracebacks.\n"
"\n"
"        "
msgstr ""

#: Lib/code.py:199
msgid "Reset the input buffer."
msgstr ""

#: Lib/code.py:203
msgid ""
"Closely emulate the interactive Python console.\n"
"\n"
"        The optional banner argument specify the banner to print\n"
"        before the first interaction; by default it prints a banner\n"
"        similar to the one printed by the real Python interpreter,\n"
"        followed by the current class name in parentheses (so as not\n"
"        to confuse this with the real interpreter -- since it's so\n"
"        close!).\n"
"\n"
"        "
msgstr ""

#: Lib/code.py:248
msgid ""
"Push a line to the interpreter.\n"
"\n"
"        The line should not have a trailing newline; it may have\n"
"        internal newlines.  The line is appended to a buffer and the\n"
"        interpreter's runsource() method is called with the\n"
"        concatenated contents of the buffer as source.  If this\n"
"        indicates that the command was executed or invalid, the buffer\n"
"        is reset; otherwise, the command is incomplete, and the buffer\n"
"        is left as it was after the line was appended.  The return\n"
"        value is 1 if more input is required, 0 if the line was dealt\n"
"        with in some way (this is the same as runsource()).\n"
"\n"
"        "
msgstr ""

#: Lib/code.py:269
msgid ""
"Write a prompt and read a line.\n"
"\n"
"        The returned line does not include the trailing newline.\n"
"        When the user enters the EOF key sequence, EOFError is raised.\n"
"\n"
"        The base implementation uses the built-in function\n"
"        raw_input(); a subclass may replace this with a different\n"
"        implementation.\n"
"\n"
"        "
msgstr ""

#: Lib/code.py:283
msgid ""
"Closely emulate the interactive Python interpreter.\n"
"\n"
"    This is a backwards compatible interface to the InteractiveConsole\n"
"    class.  When readfunc is not specified, it attempts to import the\n"
"    readline module to enable GNU readline if it is available.\n"
"\n"
"    Arguments (all optional, all default to None):\n"
"\n"
"    banner -- passed to InteractiveConsole.interact()\n"
"    readfunc -- if not None, replaces InteractiveConsole.raw_input()\n"
"    local -- passed to InteractiveInterpreter.__init__()\n"
"\n"
"    "
msgstr ""

#: Lib/codecs.py:50
msgid ""
" Defines the interface for stateless encoders/decoders.\n"
"\n"
"        The .encode()/.decode() methods may implement different error\n"
"        handling schemes by providing the errors argument. These\n"
"        string values are defined:\n"
"\n"
"         'strict' - raise a ValueError error (or a subclass)\n"
"         'ignore' - ignore the character and continue with the next\n"
"         'replace' - replace with a suitable replacement character;\n"
"                    Python will use the official U+FFFD REPLACEMENT\n"
"                    CHARACTER for the builtin Unicode codecs.\n"
"\n"
"    "
msgstr ""

#: Lib/codecs.py:65
msgid ""
" Encodes the object input and returns a tuple (output\n"
"            object, length consumed).\n"
"\n"
"            errors defines the error handling to apply. It defaults to\n"
"            'strict' handling.\n"
"\n"
"            The method may not store state in the Codec instance. Use\n"
"            StreamCodec for codecs which have to keep state in order to\n"
"            make encoding/decoding efficient.\n"
"\n"
"            The encoder must be able to handle zero length input and\n"
"            return an empty object of the output object type in this\n"
"            situation.\n"
"\n"
"        "
msgstr ""

#: Lib/codecs.py:84
msgid ""
" Decodes the object input and returns a tuple (output\n"
"            object, length consumed).\n"
"\n"
"            input must be an object which provides the bf_getreadbuf\n"
"            buffer slot. Python strings, buffer objects and memory\n"
"            mapped files are examples of objects providing this slot.\n"
"\n"
"            errors defines the error handling to apply. It defaults to\n"
"            'strict' handling.\n"
"\n"
"            The method may not store state in the Codec instance. Use\n"
"            StreamCodec for codecs which have to keep state in order to\n"
"            make encoding/decoding efficient.\n"
"\n"
"            The decoder must be able to handle zero length input and\n"
"            return an empty object of the output object type in this\n"
"            situation.\n"
"\n"
"        "
msgstr ""

#: Lib/codecs.py:116
msgid ""
" Creates a StreamWriter instance.\n"
"\n"
"            stream must be a file-like object open for writing\n"
"            (binary) data.\n"
"\n"
"            The StreamWriter may implement different error handling\n"
"            schemes by providing the errors keyword argument. These\n"
"            parameters are defined:\n"
"\n"
"             'strict' - raise a ValueError (or a subclass)\n"
"             'ignore' - ignore the character and continue with the next\n"
"             'replace'- replace with a suitable replacement character\n"
"\n"
"        "
msgstr ""

#: Lib/codecs.py:135
msgid ""
" Writes the object's contents encoded to self.stream.\n"
"        "
msgstr ""

#: Lib/codecs.py:142
msgid ""
" Writes the concatenated list of strings to the stream\n"
"            using .write().\n"
"        "
msgstr ""

#: Lib/codecs.py:149
msgid ""
" Flushes and resets the codec buffers used for keeping state.\n"
"\n"
"            Calling this method should ensure that the data on the\n"
"            output is put into a clean state, that allows appending\n"
"            of new fresh data without having to rescan the whole\n"
"            stream to recover state.\n"
"\n"
"        "
msgstr ""

#: Lib/codecs.py:163 :289 :355 :458
msgid ""
" Inherit all other methods from the underlying stream.\n"
"        "
msgstr ""

#: Lib/codecs.py:173
msgid ""
" Creates a StreamReader instance.\n"
"\n"
"            stream must be a file-like object open for reading\n"
"            (binary) data.\n"
"\n"
"            The StreamReader may implement different error handling\n"
"            schemes by providing the errors keyword argument. These\n"
"            parameters are defined:\n"
"\n"
"             'strict' - raise a ValueError (or a subclass)\n"
"             'ignore' - ignore the character and continue with the next\n"
"             'replace'- replace with a suitable replacement character;\n"
"\n"
"        "
msgstr ""

#. Unsliced reading:
#: Lib/codecs.py:192
msgid ""
" Decodes data from the stream self.stream and returns the\n"
"            resulting object.\n"
"\n"
"            size indicates the approximate maximum number of bytes to\n"
"            read from the stream for decoding purposes. The decoder\n"
"            can modify this setting as appropriate. The default value\n"
"            -1 indicates to read and decode as much as possible.  size\n"
"            is intended to prevent having to decode huge files in one\n"
"            step.\n"
"\n"
"            The method should use a greedy read strategy meaning that\n"
"            it should read as much data as is allowed within the\n"
"            definition of the encoding and the given size, e.g.  if\n"
"            optional encoding endings or state markers are available\n"
"            on the stream, these should be read too.\n"
"\n"
"        "
msgstr ""

#: Lib/codecs.py:234
msgid ""
" Read one line from the input stream and return the\n"
"            decoded data.\n"
"\n"
"            Note: Unlike the .readlines() method, this method inherits\n"
"            the line breaking knowledge from the underlying stream's\n"
"            .readline() method -- there is currently no support for\n"
"            line breaking using the codec decoder due to lack of line\n"
"            buffering. Sublcasses should however, if possible, try to\n"
"            implement this method using their own knowledge of line\n"
"            breaking.\n"
"\n"
"            size, if given, is passed as size argument to the stream's\n"
"            .readline() method.\n"
"\n"
"        "
msgstr ""

#: Lib/codecs.py:258
msgid ""
" Read all lines available on the input stream\n"
"            and return them as list of lines.\n"
"\n"
"            Line breaks are implemented using the codec's decoder\n"
"            method and are included in the list entries.\n"
"\n"
"            sizehint, if given, is passed as size argument to the\n"
"            stream's .read() method.\n"
"\n"
"        "
msgstr ""

#: Lib/codecs.py:276
msgid ""
" Resets the codec buffers used for keeping state.\n"
"\n"
"            Note that no stream repositioning should take place.\n"
"            This method is primarily intended to be able to recover\n"
"            from decoding errors.\n"
"\n"
"        "
msgstr ""

#. Optional attributes set by the file wrappers below
#: Lib/codecs.py:297
msgid ""
" StreamReaderWriter instances allow wrapping streams which\n"
"        work in both read and write modes.\n"
"\n"
"        The design is such that one can use the factory functions\n"
"        returned by the codec.lookup() function to construct the\n"
"        instance.\n"
"\n"
"    "
msgstr ""

#: Lib/codecs.py:310
msgid ""
" Creates a StreamReaderWriter instance.\n"
"\n"
"            stream must be a Stream-like object.\n"
"\n"
"            Reader, Writer must be factory functions or classes\n"
"            providing the StreamReader, StreamWriter interface resp.\n"
"\n"
"            Error handling is done in the same way as defined for the\n"
"            StreamWriter/Readers.\n"
"\n"
"        "
msgstr ""

#. Optional attributes set by the file wrappers below
#: Lib/codecs.py:363
msgid ""
" StreamRecoder instances provide a frontend - backend\n"
"        view of encoding data.\n"
"\n"
"        They use the complete set of APIs returned by the\n"
"        codecs.lookup() function to implement their task.\n"
"\n"
"        Data written to the stream is first decoded into an\n"
"        intermediate format (which is dependent on the given codec\n"
"        combination) and then written to the stream using an instance\n"
"        of the provided Writer class.\n"
"\n"
"        In the other direction, data is read from the stream using a\n"
"        Reader instance and then return encoded data to the caller.\n"
"\n"
"    "
msgstr ""

#: Lib/codecs.py:384
msgid ""
" Creates a StreamRecoder instance which implements a two-way\n"
"            conversion: encode and decode work on the frontend (the\n"
"            input to .read() and output of .write()) while\n"
"            Reader and Writer work on the backend (reading and\n"
"            writing to the stream).\n"
"\n"
"            You can use these objects to do transparent direct\n"
"            recodings from e.g. latin-1 to utf-8 and back.\n"
"\n"
"            stream must be a file-like object.\n"
"\n"
"            encode, decode must adhere to the Codec interface, Reader,\n"
"            Writer must be factory functions or classes providing the\n"
"            StreamReader, StreamWriter interface resp.\n"
"\n"
"            encode and decode are needed for the frontend translation,\n"
"            Reader and Writer for the backend translation. Unicode is\n"
"            used as intermediate encoding.\n"
"\n"
"            Error handling is done in the same way as defined for the\n"
"            StreamWriter/Readers.\n"
"\n"
"        "
msgstr ""

#: Lib/codecs.py:466
msgid ""
" Open an encoded file using the given mode and return\n"
"        a wrapped version providing transparent encoding/decoding.\n"
"\n"
"        Note: The wrapped version will only accept the object format\n"
"        defined by the codecs, i.e. Unicode objects for most builtin\n"
"        codecs. Output is also codec dependent and will usually by\n"
"        Unicode as well.\n"
"\n"
"        Files are always opened in binary mode, even if no binary mode\n"
"        was specified. Thisis done to avoid data loss due to encodings\n"
"        using 8-bit values. The default file mode is 'rb' meaning to\n"
"        open the file in binary read mode.\n"
"\n"
"        encoding specifies the encoding which is to be used for the\n"
"        the file.\n"
"\n"
"        errors may be given to define the error handling. It defaults\n"
"        to 'strict' which causes ValueErrors to be raised in case an\n"
"        encoding error occurs.\n"
"\n"
"        buffering has the same meaning as for the builtin open() API.\n"
"        It defaults to line buffered.\n"
"\n"
"        The returned wrapped file object provides an extra attribute\n"
"        .encoding which allows querying the used encoding. This\n"
"        attribute is only available if an encoding was specified as\n"
"        parameter.\n"
"\n"
"    "
msgstr ""

#: Lib/codecs.py:510
msgid ""
" Return a wrapped version of file which provides transparent\n"
"        encoding translation.\n"
"\n"
"        Strings written to the wrapped file are interpreted according\n"
"        to the given data_encoding and then written to the original\n"
"        file as string using file_encoding. The intermediate encoding\n"
"        will usually be Unicode but depends on the specified codecs.\n"
"\n"
"        Strings are read from the file using file_encoding and then\n"
"        passed back to the caller as string using data_encoding.\n"
"\n"
"        If file_encoding is not given, it defaults to data_encoding.\n"
"\n"
"        errors may be given to define the error handling. It defaults\n"
"        to 'strict' which causes ValueErrors to be raised in case an\n"
"        encoding error occurs.\n"
"\n"
"        The returned wrapped file object provides two extra attributes\n"
"        .data_encoding and .file_encoding which reflect the given\n"
"        parameters of the same name. The attributes can be used for\n"
"        introspection by Python programs.\n"
"\n"
"    "
msgstr ""

#: Lib/codecs.py:549
msgid ""
" make_identity_dict(rng) -> dict\n"
"\n"
"        Return a dictionary where elements of the rng sequence are\n"
"        mapped to themselves.\n"
"\n"
"    "
msgstr ""

#. Check for source consisting of only blank lines and comments
#: Lib/codeop.py:6
msgid ""
"Compile a command and determine whether it is incomplete.\n"
"\n"
"    Arguments:\n"
"\n"
"    source -- the source string; may contain \\n characters\n"
"    filename -- optional filename from which source was read; default \"<input>\"\n"
"    symbol -- optional grammar start symbol; \"single\" (default) or \"eval\"\n"
"\n"
"    Return value / exceptions raised:\n"
"\n"
"    - Return a code object if the command is complete and valid\n"
"    - Return None if the command is incomplete\n"
"    - Raise SyntaxError or OverflowError if the command is a syntax error\n"
"      (OverflowError if the error is in a numeric constant)\n"
"\n"
"    Approach:\n"
"\n"
"    First, check if the source consists entirely of blank lines and\n"
"    comments; if so, replace it with 'pass', because the built-in\n"
"    parser doesn't always do the right thing for these.\n"
"\n"
"    Compile three times: as is, with \\n, and with \\n\\n appended.  If\n"
"    it compiles as is, it's complete.  If it compiles with one \\n\n"
"    appended, we expect more.  If it doesn't compile either way, we\n"
"    compare the error we get when compiling with \\n or \\n\\n appended.\n"
"    If the errors are the same, the code is broken.  But if the errors\n"
"    are different, we expect more.  Not intuitive; not even guaranteed\n"
"    to hold in future releases; but this matches the compiler's\n"
"    behavior from Python 1.4 through 1.5.2, at least.\n"
"\n"
"    Caveat:\n"
"\n"
"    It is possible (but not likely) that the parser stops parsing\n"
"    with a successful outcome before reaching the end of the source;\n"
"    in this case, trailing symbols may be ignored instead of causing an\n"
"    error.  For example, a backslash followed by two newlines may be\n"
"    followed by arbitrary garbage.  This will be fixed once the API\n"
"    for the parser is better.\n"
"\n"
"    "
msgstr ""

#: Lib/commands.py:34
msgid "Return output of \"ls -ld <file>\" in a string."
msgstr ""

#: Lib/commands.py:43
msgid "Return output (stdout or stderr) of executing cmd in a shell."
msgstr ""

#: Lib/commands.py:51
msgid "Return (status, output) of executing cmd in a shell."
msgstr ""

#: Lib/compileall.py:23
msgid ""
"Byte-compile all modules in the given directory tree.\n"
"\n"
"    Arguments (only dir is required):\n"
"\n"
"    dir:       the directory to byte-compile\n"
"    maxlevels: maximum recursion level (default 10)\n"
"    ddir:      if given, purported directory name (this is the\n"
"               directory name that will show up in error messages)\n"
"    force:     if 1, force compilation, even if timestamps are up-to-date\n"
"\n"
"    "
msgstr ""

#: Lib/compileall.py:76
msgid ""
"Byte-compile all module on sys.path.\n"
"\n"
"    Arguments (all optional):\n"
"\n"
"    skip_curdir: if true, skip current directory (default true)\n"
"    maxlevels:   max recursion level (default 0)\n"
"    force: as for compile_dir() (default 0)\n"
"\n"
"    "
msgstr ""

#: Lib/compileall.py:94
msgid "Script main program."
msgstr ""

#: Lib/copy.py:67
msgid ""
"Shallow copy operation on arbitrary Python objects.\n"
"\n"
"    See the module's __doc__ string for more info.\n"
"    "
msgstr ""

#: Lib/copy.py:140
msgid ""
"Deep copy operation on arbitrary Python objects.\n"
"\n"
"    See the module's __doc__ string for more info.\n"
"    "
msgstr ""

#: Lib/copy.py:216 Lib/pickle.py:510
msgid ""
"Keeps a reference to the object x in the memo.\n"
"\n"
"    Because we remember objects by their id, we have\n"
"    to assure that possibly temporary objects are kept\n"
"    alive by referencing them.\n"
"    We store a reference at the id of the memo, which should\n"
"    normally not be used unless someone tries to deepcopy\n"
"    the memo itself...\n"
"    "
msgstr ""

#: Lib/curses/textpad.py:6
msgid "Draw a rectangle."
msgstr ""

#: Lib/curses/textpad.py:17
msgid ""
"Editing widget using the interior of a window object.\n"
"     Supports the following Emacs-like key bindings:\n"
"\n"
"    Ctrl-A      Go to left edge of window.\n"
"    Ctrl-B      Cursor left, wrapping to previous line if appropriate.\n"
"    Ctrl-D      Delete character under cursor.\n"
"    Ctrl-E      Go to right edge (stripspaces off) or end of line (stripspaces on).\n"
"    Ctrl-F      Cursor right, wrapping to next line when appropriate.\n"
"    Ctrl-G      Terminate, returning the window contents.\n"
"    Ctrl-H      Delete character backward.\n"
"    Ctrl-J      Terminate if the window is 1 line, otherwise insert newline.\n"
"    Ctrl-K      If line is blank, delete it, otherwise clear to end of line.\n"
"    Ctrl-L      Refresh screen.\n"
"    Ctrl-N      Cursor down; move down one line.\n"
"    Ctrl-O      Insert a blank line at cursor location.\n"
"    Ctrl-P      Cursor up; move up one line.\n"
"\n"
"    Move operations do nothing if the cursor is at an edge where the movement\n"
"    is not possible.  The following synonyms are supported where possible:\n"
"\n"
"    KEY_LEFT = Ctrl-B, KEY_RIGHT = Ctrl-F, KEY_UP = Ctrl-P, KEY_DOWN = Ctrl-N\n"
"    KEY_BACKSPACE = Ctrl-h\n"
"    "
msgstr ""

#: Lib/curses/textpad.py:50
msgid "Go to the location of the first blank on the given line."
msgstr ""

#: Lib/curses/textpad.py:62
msgid "Process a single editing command."
msgstr ""

#: Lib/curses/textpad.py:130
msgid "Collect and return the contents of the window."
msgstr ""

#: Lib/curses/textpad.py:147
msgid "Edit in the widget window and collect the results."
msgstr ""

#: Lib/curses/wrapper.py:13
msgid ""
"Wrapper function that initializes curses and calls another function,\n"
"    restoring normal keyboard/screen behavior on error.\n"
"    The callable object 'func' is then passed the main window 'stdscr'\n"
"    as its first argument, followed by any other arguments passed to\n"
"    wrapper().\n"
"    "
msgstr ""

#. Members:
#. a
#.      first sequence
#. b
#.      second sequence; differences are computed as "what do
#.      we need to do to 'a' to change it into 'b'?"
#. b2j
#.      for x in b, b2j[x] is a list of the indices (into b)
#.      at which x appears; junk elements do not appear
#. b2jhas
#.      b2j.has_key
#. fullbcount
#.      for x in b, fullbcount[x] == the number of times x
#.      appears in b; only materialized if really needed (used
#.      only for computing quick_ratio())
#. matching_blocks
#.      a list of (i, j, k) triples, where a[i:i+k] == b[j:j+k];
#.      ascending & non-overlapping in i and in j; terminated by
#.      a dummy (len(a), len(b), 0) sentinel
#. opcodes
#.      a list of (tag, i1, i2, j1, j2) tuples, where tag is
#.      one of
#.          'replace'   a[i1:i2] should be replaced by b[j1:j2]
#.          'delete'    a[i1:i2] should be deleted
#.          'insert'    b[j1:j2] should be inserted
#.          'equal'     a[i1:i2] == b[j1:j2]
#. isjunk
#.      a user-supplied function taking a sequence element and
#.      returning true iff the element is "junk" -- this has
#.      subtle but helpful effects on the algorithm, which I'll
#.      get around to writing up someday <0.9 wink>.
#.      DON'T USE!  Only __chain_b uses this.  Use isbjunk.
#. isbjunk
#.      for x in b, isbjunk(x) == isjunk(x) but much faster;
#.      it's really the has_key method of a hidden dict.
#.      DOES NOT WORK for x in a!
#: Lib/difflib.py:287
msgid ""
"Construct a SequenceMatcher.\n"
"\n"
"        Optional arg isjunk is None (the default), or a one-argument\n"
"        function that takes a sequence element and returns true iff the\n"
"        element is junk. None is equivalent to passing \"lambda x: 0\", i.e.\n"
"        no elements are considered to be junk.  For example, pass\n"
"            lambda x: x in \" \\t\"\n"
"        if you're comparing lines as sequences of characters, and don't\n"
"        want to synch up on blanks or hard tabs.\n"
"\n"
"        Optional arg a is the first of two sequences to be compared.  By\n"
"        default, an empty string.  The elements of a must be hashable.  See\n"
"        also .set_seqs() and .set_seq1().\n"
"\n"
"        Optional arg b is the second of two sequences to be compared.  By\n"
"        default, an empty string.  The elements of b must be hashable. See\n"
"        also .set_seqs() and .set_seq2().\n"
"        "
msgstr ""

#: Lib/difflib.py:348
msgid ""
"Set the two sequences to be compared.\n"
"\n"
"        >>> s = SequenceMatcher()\n"
"        >>> s.set_seqs(\"abcd\", \"bcde\")\n"
"        >>> s.ratio()\n"
"        0.75\n"
"        "
msgstr ""

#: Lib/difflib.py:360
msgid ""
"Set the first sequence to be compared.\n"
"\n"
"        The second sequence to be compared is not changed.\n"
"\n"
"        >>> s = SequenceMatcher(None, \"abcd\", \"bcde\")\n"
"        >>> s.ratio()\n"
"        0.75\n"
"        >>> s.set_seq1(\"bcde\")\n"
"        >>> s.ratio()\n"
"        1.0\n"
"        >>>\n"
"\n"
"        SequenceMatcher computes and caches detailed information about the\n"
"        second sequence, so if you want to compare one sequence S against\n"
"        many sequences, use .set_seq2(S) once and call .set_seq1(x)\n"
"        repeatedly for each of the other sequences.\n"
"\n"
"        See also set_seqs() and set_seq2().\n"
"        "
msgstr ""

#: Lib/difflib.py:386
msgid ""
"Set the second sequence to be compared.\n"
"\n"
"        The first sequence to be compared is not changed.\n"
"\n"
"        >>> s = SequenceMatcher(None, \"abcd\", \"bcde\")\n"
"        >>> s.ratio()\n"
"        0.75\n"
"        >>> s.set_seq2(\"abcd\")\n"
"        >>> s.ratio()\n"
"        1.0\n"
"        >>>\n"
"\n"
"        SequenceMatcher computes and caches detailed information about the\n"
"        second sequence, so if you want to compare one sequence S against\n"
"        many sequences, use .set_seq2(S) once and call .set_seq1(x)\n"
"        repeatedly for each of the other sequences.\n"
"\n"
"        See also set_seqs() and set_seq1().\n"
"        "
msgstr ""

#. CAUTION:  stripping common prefix or suffix would be incorrect.
#. E.g.,
#.    ab
#.    acab
#. Longest matching block is "ab", but if common prefix is
#. stripped, it's "a" (tied with "b").  UNIX(tm) diff does so
#. strip, so ends up claiming that ab is changed to acab by
#. inserting "ca" in the middle.  That's minimal but unintuitive:
#. "it's obvious" that someone inserted "ac" at the front.
#. Windiff ends up at the same place as diff, but by pairing up
#. the unique 'b's and then matching the first two 'a's.
#: Lib/difflib.py:464
msgid ""
"Find longest matching block in a[alo:ahi] and b[blo:bhi].\n"
"\n"
"        If isjunk is not defined:\n"
"\n"
"        Return (i,j,k) such that a[i:i+k] is equal to b[j:j+k], where\n"
"            alo <= i <= i+k <= ahi\n"
"            blo <= j <= j+k <= bhi\n"
"        and for all (i',j',k') meeting those conditions,\n"
"            k >= k'\n"
"            i <= i'\n"
"            and if i == i', j <= j'\n"
"\n"
"        In other words, of all maximal matching blocks, return one that\n"
"        starts earliest in a, and of all those maximal matching blocks that\n"
"        start earliest in a, return the one that starts earliest in b.\n"
"\n"
"        >>> s = SequenceMatcher(None, \" abcd\", \"abcd abcd\")\n"
"        >>> s.find_longest_match(0, 5, 0, 9)\n"
"        (0, 4, 5)\n"
"\n"
"        If isjunk is defined, first the longest matching block is\n"
"        determined as above, but with the additional restriction that no\n"
"        junk element appears in the block.  Then that block is extended as\n"
"        far as possible by matching (only) junk elements on both sides.  So\n"
"        the resulting block never matches on junk except as identical junk\n"
"        happens to be adjacent to an \"interesting\" match.\n"
"\n"
"        Here's the same example as before, but considering blanks to be\n"
"        junk.  That prevents \" abcd\" from matching the \" abcd\" at the tail\n"
"        end of the second sequence directly.  Instead only the \"abcd\" can\n"
"        match, and matches the leftmost \"abcd\" in the second sequence:\n"
"\n"
"        >>> s = SequenceMatcher(lambda x: x==\" \", \" abcd\", \"abcd abcd\")\n"
"        >>> s.find_longest_match(0, 5, 0, 9)\n"
"        (1, 0, 4)\n"
"\n"
"        If no blocks match, return (alo, blo, 0).\n"
"\n"
"        >>> s = SequenceMatcher(None, \"ab\", \"c\")\n"
"        >>> s.find_longest_match(0, 2, 0, 1)\n"
"        (0, 0, 0)\n"
"        "
msgstr ""

#: Lib/difflib.py:564
msgid ""
"Return list of triples describing matching subsequences.\n"
"\n"
"        Each triple is of the form (i, j, n), and means that\n"
"        a[i:i+n] == b[j:j+n].  The triples are monotonically increasing in\n"
"        i and in j.\n"
"\n"
"        The last triple is a dummy, (len(a), len(b), 0), and is the only\n"
"        triple with n==0.\n"
"\n"
"        >>> s = SequenceMatcher(None, \"abxcd\", \"abcd\")\n"
"        >>> s.get_matching_blocks()\n"
"        [(0, 0, 2), (3, 2, 2), (5, 4, 0)]\n"
"        "
msgstr ""

#: Lib/difflib.py:604
msgid ""
"Return list of 5-tuples describing how to turn a into b.\n"
"\n"
"        Each tuple is of the form (tag, i1, i2, j1, j2).  The first tuple\n"
"        has i1 == j1 == 0, and remaining tuples have i1 == the i2 from the\n"
"        tuple preceding it, and likewise for j1 == the previous j2.\n"
"\n"
"        The tags are strings, with these meanings:\n"
"\n"
"        'replace':  a[i1:i2] should be replaced by b[j1:j2]\n"
"        'delete':   a[i1:i2] should be deleted.\n"
"                    Note that j1==j2 in this case.\n"
"        'insert':   b[j1:j2] should be inserted at a[i1:i1].\n"
"                    Note that i1==i2 in this case.\n"
"        'equal':    a[i1:i2] == b[j1:j2]\n"
"\n"
"        >>> a = \"qabxcd\"\n"
"        >>> b = \"abycdf\"\n"
"        >>> s = SequenceMatcher(None, a, b)\n"
"        >>> for tag, i1, i2, j1, j2 in s.get_opcodes():\n"
"        ...    print (\"%7s a[%d:%d] (%s) b[%d:%d] (%s)\" %\n"
"        ...           (tag, i1, i2, a[i1:i2], j1, j2, b[j1:j2]))\n"
"         delete a[0:1] (q) b[0:0] ()\n"
"          equal a[1:3] (ab) b[0:2] (ab)\n"
"        replace a[3:4] (x) b[2:3] (y)\n"
"          equal a[4:6] (cd) b[3:5] (cd)\n"
"         insert a[6:6] () b[5:6] (f)\n"
"        "
msgstr ""

#: Lib/difflib.py:659
msgid ""
"Return a measure of the sequences' similarity (float in [0,1]).\n"
"\n"
"        Where T is the total number of elements in both sequences, and\n"
"        M is the number of matches, this is 2,0*M / T.\n"
"        Note that this is 1 if the sequences are identical, and 0 if\n"
"        they have nothing in common.\n"
"\n"
"        .ratio() is expensive to compute if you haven't already computed\n"
"        .get_matching_blocks() or .get_opcodes(), in which case you may\n"
"        want to try .quick_ratio() or .real_quick_ratio() first to get an\n"
"        upper bound.\n"
"\n"
"        >>> s = SequenceMatcher(None, \"abcd\", \"bcde\")\n"
"        >>> s.ratio()\n"
"        0.75\n"
"        >>> s.quick_ratio()\n"
"        0.75\n"
"        >>> s.real_quick_ratio()\n"
"        1.0\n"
"        "
msgstr ""

#. viewing a and b as multisets, set matches to the cardinality
#. of their intersection; this counts the number of matches
#. without regard to order, so is clearly an upper bound
#: Lib/difflib.py:685
msgid ""
"Return an upper bound on ratio() relatively quickly.\n"
"\n"
"        This isn't defined beyond that it is an upper bound on .ratio(), and\n"
"        is faster to compute.\n"
"        "
msgstr ""

#: Lib/difflib.py:714
msgid ""
"Return an upper bound on ratio() very quickly.\n"
"\n"
"        This isn't defined beyond that it is an upper bound on .ratio(), and\n"
"        is faster to compute than either .ratio() or .quick_ratio().\n"
"        "
msgstr ""

#: Lib/difflib.py:726
msgid ""
"Use SequenceMatcher to return list of the best \"good enough\" matches.\n"
"\n"
"    word is a sequence for which close matches are desired (typically a\n"
"    string).\n"
"\n"
"    possibilities is a list of sequences against which to match word\n"
"    (typically a list of strings).\n"
"\n"
"    Optional arg n (default 3) is the maximum number of close matches to\n"
"    return.  n must be > 0.\n"
"\n"
"    Optional arg cutoff (default 0.6) is a float in [0, 1].  Possibilities\n"
"    that don't score at least that similar to word are ignored.\n"
"\n"
"    The best (no more than n) matches among the possibilities are returned\n"
"    in a list, sorted by similarity score, most similar first.\n"
"\n"
"    >>> get_close_matches(\"appel\", [\"ape\", \"apple\", \"peach\", \"puppy\"])\n"
"    ['apple', 'ape']\n"
"    >>> import keyword\n"
"    >>> get_close_matches(\"wheel\", keyword.kwlist)\n"
"    ['while']\n"
"    >>> get_close_matches(\"apple\", keyword.kwlist)\n"
"    []\n"
"    >>> get_close_matches(\"accept\", keyword.kwlist)\n"
"    ['except']\n"
"    "
msgstr ""

#: Lib/dircache.py:14
msgid "Reset the cache completely."
msgstr ""

#: Lib/dircache.py:19
msgid "List directory contents, using cache."
msgstr ""

#: Lib/dircache.py:41
msgid "Add '/' suffixes to directories."
msgstr ""

#: Lib/dis.py:11
msgid ""
"Disassemble classes, methods, functions, or code.\n"
"\n"
"    With no argument, disassemble the last traceback.\n"
"\n"
"    "
msgstr ""

#: Lib/dis.py:46
msgid "Disassemble a traceback (default: last traceback)."
msgstr ""

#: Lib/dis.py:56
msgid "Disassemble a code object."
msgstr ""

#: Lib/dis.py:100
msgid ""
"Detect all offsets in a byte code which are jump targets.\n"
"\n"
"    Return the list of offsets.\n"
"\n"
"    "
msgstr ""

#: Lib/dis.py:297
msgid "Simple test program to disassemble a file."
msgstr ""

#. XXX GNU tar 1.13 has a nifty option to add a prefix directory.
#. It's pretty new, though, so we certainly can't require it --
#. but it would be nice to take advantage of it to skip the
#. "create a tree of hardlinks" step!  (Would also be nice to
#. detect GNU tar to use its 'z' option and save a step.)
#: Lib/distutils/archive_util.py:17
msgid ""
"Create a (possibly compressed) tar file from all the files under\n"
"    'base_dir'.  'compress' must be \"gzip\" (the default), \"compress\",\n"
"    \"bzip2\", or None.  Both \"tar\" and the compression utility named by\n"
"    'compress' must be on the default program search path, so this is\n"
"    probably Unix-specific.  The output tar file will be named 'base_dir' +\n"
"    \".tar\", possibly plus the appropriate compression extension (\".gz\",\n"
"    \".bz2\" or \".Z\").  Return the output filename.\n"
"    "
msgstr ""

#. This initially assumed the Unix 'zip' utility -- but
#. apparently InfoZIP's zip.exe works the same under Windows, so
#. no changes needed!
#: Lib/distutils/archive_util.py:60
msgid ""
"Create a zip file from all the files under 'base_dir'.  The output\n"
"    zip file will be named 'base_dir' + \".zip\".  Uses either the InfoZIP\n"
"    \"zip\" utility (if installed and found on the default search path) or\n"
"    the \"zipfile\" Python module (if available).  If neither tool is\n"
"    available, raises DistutilsExecError.  Returns the name of the output\n"
"    zip file.\n"
"    "
msgstr ""

#: Lib/distutils/archive_util.py:132
msgid ""
"Create an archive file (eg. zip or tar).  'base_name' is the name\n"
"    of the file to create, minus any format-specific extension; 'format'\n"
"    is the archive format: one of \"zip\", \"tar\", \"ztar\", or \"gztar\".\n"
"    'root_dir' is a directory that will be the root directory of the\n"
"    archive; ie. we typically chdir into 'root_dir' before creating the\n"
"    archive.  'base_dir' is the directory where we start archiving from;\n"
"    ie. 'base_dir' will be the common prefix of all files and\n"
"    directories in the archive.  'root_dir' and 'base_dir' both default\n"
"    to the current directory.  Returns the name of the archive file.\n"
"    "
msgstr ""

#: Lib/distutils/bcppcompiler.py:27
msgid ""
"Concrete class that implements an interface to the Borland C/C++\n"
"    compiler, as defined by the CCompiler abstract class.\n"
"    "
msgstr ""

#. 'compiler_type' is a class attribute that identifies this class.  It
#. keeps code that wants to know what kind of compiler it's dealing with
#. from having to import all possible compiler classes just to do an
#. 'isinstance'.  In concrete CCompiler subclasses, 'compiler_type'
#. should really, really be one of the keys of the 'compiler_class'
#. dictionary (see below -- used by the 'new_compiler()' factory
#. function) -- authors of new compiler interface classes are
#. responsible for updating 'compiler_class'!
#: Lib/distutils/ccompiler.py:22
msgid ""
"Abstract base class to define the interface that must be implemented\n"
"    by real compiler classes.  Also has some utility methods used by\n"
"    several compiler classes.\n"
"\n"
"    The basic idea behind a compiler abstraction class is that each\n"
"    instance can be used for all the compile/link steps in building a\n"
"    single project.  Thus, attributes common to all of those compile and\n"
"    link steps -- include directories, macros to define, libraries to link\n"
"    against, etc. -- are attributes of the compiler instance.  To allow for\n"
"    variability in how individual files are treated, most of those\n"
"    attributes may be varied on a per-compilation or per-link basis.\n"
"    "
msgstr ""

#. Note that some CCompiler implementation classes will define class
#. attributes 'cpp', 'cc', etc. with hard-coded executable names;
#. this is appropriate when a compiler class is for exactly one
#. compiler/OS combination (eg. MSVCCompiler).  Other compiler
#. classes (UnixCCompiler, in particular) are driven by information
#. discovered at run-time, since there are many different ways to do
#. basically the same things with Unix C compilers.
#: Lib/distutils/ccompiler.py:123
msgid ""
"Define the executables (and options for them) that will be run\n"
"        to perform the various stages of compilation.  The exact set of\n"
"        executables that may be specified here depends on the compiler\n"
"        class (via the 'executables' class attribute), but most will have:\n"
"          compiler      the C/C++ compiler\n"
"          linker_so     linker used to create shared objects and libraries\n"
"          linker_exe    linker used to create binary executables\n"
"          archiver      static library creator\n"
"\n"
"        On platforms with a command-line (Unix, DOS/Windows), each of these\n"
"        is a string that will be split into executable name and (optional)\n"
"        list of arguments.  (Splitting the string is done similarly to how\n"
"        Unix shells operate: words are delimited by spaces, but quotes and\n"
"        backslashes can override this.  See\n"
"        'distutils.util.split_quoted()'.)\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:176
msgid ""
"Ensures that every element of 'definitions' is a valid macro\n"
"        definition, ie. either (name,value) 2-tuple or a (name,) tuple.  Do\n"
"        nothing if all definitions are OK, raise TypeError otherwise.\n"
"        "
msgstr ""

#. Delete from the list of macro definitions/undefinitions if
#. already there (so that this one will take precedence).
#: Lib/distutils/ccompiler.py:195
msgid ""
"Define a preprocessor macro for all compilations driven by this\n"
"        compiler object.  The optional parameter 'value' should be a\n"
"        string; if it is not supplied, then the macro will be defined\n"
"        without an explicit value and the exact outcome depends on the\n"
"        compiler used (XXX true? does ANSI say anything about this?)\n"
"        "
msgstr ""

#. Delete from the list of macro definitions/undefinitions if
#. already there (so that this one will take precedence).
#: Lib/distutils/ccompiler.py:212
msgid ""
"Undefine a preprocessor macro for all compilations driven by\n"
"        this compiler object.  If the same macro is defined by\n"
"        'define_macro()' and undefined by 'undefine_macro()' the last call\n"
"        takes precedence (including multiple redefinitions or\n"
"        undefinitions).  If the macro is redefined/undefined on a\n"
"        per-compilation basis (ie. in the call to 'compile()'), then that\n"
"        takes precedence.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:231
msgid ""
"Add 'dir' to the list of directories that will be searched for\n"
"        header files.  The compiler is instructed to search directories in\n"
"        the order in which they are supplied by successive calls to\n"
"        'add_include_dir()'.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:239
msgid ""
"Set the list of directories that will be searched to 'dirs' (a\n"
"        list of strings).  Overrides any preceding calls to\n"
"        'add_include_dir()'; subsequence calls to 'add_include_dir()' add\n"
"        to the list passed to 'set_include_dirs()'.  This does not affect\n"
"        any list of standard include directories that the compiler may\n"
"        search by default.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:250
msgid ""
"Add 'libname' to the list of libraries that will be included in\n"
"        all links driven by this compiler object.  Note that 'libname'\n"
"        should *not* be the name of a file containing a library, but the\n"
"        name of the library itself: the actual filename will be inferred by\n"
"        the linker, the compiler, or the compiler class (depending on the\n"
"        platform).\n"
"\n"
"        The linker will be instructed to link against libraries in the\n"
"        order they were supplied to 'add_library()' and/or\n"
"        'set_libraries()'.  It is perfectly valid to duplicate library\n"
"        names; the linker will be instructed to link against libraries as\n"
"        many times as they are mentioned.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:266
msgid ""
"Set the list of libraries to be included in all links driven by\n"
"        this compiler object to 'libnames' (a list of strings).  This does\n"
"        not affect any standard system libraries that the linker may\n"
"        include by default.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:275
msgid ""
"Add 'dir' to the list of directories that will be searched for\n"
"        libraries specified to 'add_library()' and 'set_libraries()'.  The\n"
"        linker will be instructed to search for libraries in the order they\n"
"        are supplied to 'add_library_dir()' and/or 'set_library_dirs()'.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:283
msgid ""
"Set the list of library search directories to 'dirs' (a list of\n"
"        strings).  This does not affect any standard library search path\n"
"        that the linker may search by default.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:291
msgid ""
"Add 'dir' to the list of directories that will be searched for\n"
"        shared libraries at runtime.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:297
msgid ""
"Set the list of directories to search for shared libraries at\n"
"        runtime to 'dirs' (a list of strings).  This does not affect any\n"
"        standard search path that the runtime linker may search by\n"
"        default.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:306
msgid ""
"Add 'object' to the list of object files (or analogues, such as\n"
"        explicitly named library files or the output of \"resource\n"
"        compilers\") to be included in every link driven by this compiler\n"
"        object.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:314
msgid ""
"Set the list of object files (or analogues) to be included in\n"
"        every link to 'objects'.  This does not affect any standard object\n"
"        files that the linker may include by default (such as system\n"
"        libraries).\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:326
msgid ""
"Typecheck and fix-up some of the arguments to the 'compile()'\n"
"        method, and return fixed-up values.  Specifically: if 'output_dir'\n"
"        is None, replaces it with 'self.output_dir'; ensures that 'macros'\n"
"        is a list, and augments it with 'self.macros'; ensures that\n"
"        'include_dirs' is a list, and augments it with 'self.include_dirs'.\n"
"        Guarantees that the returned values are of the correct type,\n"
"        i.e. for 'output_dir' either string or None, and for 'macros' and\n"
"        'include_dirs' either list or None.\n"
"        "
msgstr ""

#. Get the list of expected output (object) files
#: Lib/distutils/ccompiler.py:362
msgid ""
"Determine the list of object files corresponding to 'sources',\n"
"        and figure out which ones really need to be recompiled.  Return a\n"
"        list of all object files and a dictionary telling which source\n"
"        files can be skipped.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:395
msgid ""
"Typecheck and fix up some arguments supplied to various methods.\n"
"        Specifically: ensure that 'objects' is a list; if output_dir is\n"
"        None, replace with self.output_dir.  Return fixed versions of\n"
"        'objects' and 'output_dir'.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:414
msgid ""
"Typecheck and fix up some of the arguments supplied to the\n"
"        'link_*' methods.  Specifically: ensure that all arguments are\n"
"        lists, and augment them with their permanent versions\n"
"        (eg. 'self.libraries' augments 'libraries').  Return a tuple with\n"
"        fixed versions of all arguments.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:452
msgid ""
"Return true if we need to relink the files listed in 'objects'\n"
"        to recreate 'output_file'.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:477
msgid ""
"Preprocess a single C/C++ source file, named in 'source'.\n"
"        Output will be written to file named 'output_file', or stdout if\n"
"        'output_file' not supplied.  'macros' is a list of macro\n"
"        definitions as for 'compile()', which will augment the macros set\n"
"        with 'define_macro()' and 'undefine_macro()'.  'include_dirs' is a\n"
"        list of directory names that will be added to the default list.\n"
"\n"
"        Raises PreprocessError on failure.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:496
msgid ""
"Compile one or more source files.  'sources' must be a list of\n"
"        filenames, most likely C/C++ files, but in reality anything that\n"
"        can be handled by a particular compiler and compiler class\n"
"        (eg. MSVCCompiler can handle resource files in 'sources').  Return\n"
"        a list of object filenames, one per source filename in 'sources'.\n"
"        Depending on the implementation, not all source files will\n"
"        necessarily be compiled, but all corresponding object filenames\n"
"        will be returned.\n"
"\n"
"        If 'output_dir' is given, object files will be put under it, while\n"
"        retaining their original path component.  That is, \"foo/bar.c\"\n"
"        normally compiles to \"foo/bar.o\" (for a Unix implementation); if\n"
"        'output_dir' is \"build\", then it would compile to\n"
"        \"build/foo/bar.o\".\n"
"\n"
"        'macros', if given, must be a list of macro definitions.  A macro\n"
"        definition is either a (name, value) 2-tuple or a (name,) 1-tuple.\n"
"        The former defines a macro; if the value is None, the macro is\n"
"        defined without an explicit value.  The 1-tuple case undefines a\n"
"        macro.  Later definitions/redefinitions/ undefinitions take\n"
"        precedence.\n"
"\n"
"        'include_dirs', if given, must be a list of strings, the\n"
"        directories to add to the default include file search path for this\n"
"        compilation only.\n"
"\n"
"        'debug' is a boolean; if true, the compiler will be instructed to\n"
"        output debug symbols in (or alongside) the object file(s).\n"
"\n"
"        'extra_preargs' and 'extra_postargs' are implementation- dependent.\n"
"        On platforms that have the notion of a command-line (e.g. Unix,\n"
"        DOS/Windows), they are most likely lists of strings: extra\n"
"        command-line arguments to prepand/append to the compiler command\n"
"        line.  On other platforms, consult the implementation class\n"
"        documentation.  In any event, they are intended as an escape hatch\n"
"        for those occasions when the abstract compiler framework doesn't\n"
"        cut the mustard.\n"
"\n"
"        Raises CompileError on failure.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:544
msgid ""
"Link a bunch of stuff together to create a static library file.\n"
"        The \"bunch of stuff\" consists of the list of object files supplied\n"
"        as 'objects', the extra object files supplied to\n"
"        'add_link_object()' and/or 'set_link_objects()', the libraries\n"
"        supplied to 'add_library()' and/or 'set_libraries()', and the\n"
"        libraries supplied as 'libraries' (if any).\n"
"\n"
"        'output_libname' should be a library name, not a filename; the\n"
"        filename will be inferred from the library name.  'output_dir' is\n"
"        the directory where the library file will be put.\n"
"\n"
"        'debug' is a boolean; if true, debugging information will be\n"
"        included in the library (note that on most platforms, it is the\n"
"        compile step where this matters: the 'debug' flag is included here\n"
"        just for consistency).\n"
"\n"
"        Raises LibError on failure.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:583
msgid ""
"Link a bunch of stuff together to create an executable or\n"
"        shared library file.\n"
"\n"
"        The \"bunch of stuff\" consists of the list of object files supplied\n"
"        as 'objects'.  'output_filename' should be a filename.  If\n"
"        'output_dir' is supplied, 'output_filename' is relative to it\n"
"        (i.e. 'output_filename' can provide directory components if\n"
"        needed).\n"
"\n"
"        'libraries' is a list of libraries to link against.  These are\n"
"        library names, not filenames, since they're translated into\n"
"        filenames in a platform-specific way (eg. \"foo\" becomes \"libfoo.a\"\n"
"        on Unix and \"foo.lib\" on DOS/Windows).  However, they can include a\n"
"        directory component, which means the linker will look in that\n"
"        specific directory rather than searching all the normal locations.\n"
"\n"
"        'library_dirs', if supplied, should be a list of directories to\n"
"        search for libraries that were specified as bare library names\n"
"        (ie. no directory component).  These are on top of the system\n"
"        default and those supplied to 'add_library_dir()' and/or\n"
"        'set_library_dirs()'.  'runtime_library_dirs' is a list of\n"
"        directories that will be embedded into the shared library and used\n"
"        to search for other shared libraries that *it* depends on at\n"
"        run-time.  (This may only be relevant on Unix.)\n"
"\n"
"        'export_symbols' is a list of symbols that the shared library will\n"
"        export.  (This appears to be relevant only on Windows.)\n"
"\n"
"        'debug' is as for 'compile()' and 'create_static_lib()', with the\n"
"        slight distinction that it actually matters on most platforms (as\n"
"        opposed to 'create_static_lib()', which includes a 'debug' flag\n"
"        mostly for form's sake).\n"
"\n"
"        'extra_preargs' and 'extra_postargs' are as for 'compile()' (except\n"
"        of course that they supply command-line arguments for the\n"
"        particular linker being used).\n"
"\n"
"        Raises LinkError on failure.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:688
msgid ""
"Return the compiler option to add 'dir' to the list of\n"
"        directories searched for libraries.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:694
msgid ""
"Return the compiler option to add 'dir' to the list of\n"
"        directories searched for runtime libraries.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:700
msgid ""
"Return the compiler option to add 'dir' to the list of libraries\n"
"        linked into the shared library or executable.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:706
msgid ""
"Search the specified list of directories for a static or shared\n"
"        library file 'lib' and return the full path to that file.  If\n"
"        'debug' true, look for a debugging version (if that makes sense on\n"
"        the current platform).  Return None if 'lib' wasn't found in any of\n"
"        the specified directories.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:859
msgid ""
" Determine the default compiler to use for the given platform.\n"
"\n"
"        osname should be one of the standard Python OS names (i.e. the\n"
"        ones returned by os.name) and platform the common value\n"
"        returned by sys.platform for the platform in question.\n"
"\n"
"        The default values are os.name and sys.platform in case the\n"
"        parameters are not given.\n"
"\n"
"    "
msgstr ""

#. XXX this "knows" that the compiler option it's describing is
#. "--compiler", which just happens to be the case for the three
#. commands that use it.
#: Lib/distutils/ccompiler.py:898
msgid ""
"Print list of available compilers (used by the \"--help-compiler\"\n"
"    options to \"build\", \"build_ext\", \"build_clib\").\n"
"    "
msgstr ""

#: Lib/distutils/ccompiler.py:919
msgid ""
"Generate an instance of some CCompiler subclass for the supplied\n"
"    platform/compiler combination.  'plat' defaults to 'os.name'\n"
"    (eg. 'posix', 'nt'), and 'compiler' defaults to the default compiler\n"
"    for that platform.  Currently only 'posix' and 'nt' are supported, and\n"
"    the default compilers are \"traditional Unix interface\" (UnixCCompiler\n"
"    class) and Visual C++ (MSVCCompiler class).  Note that it's perfectly\n"
"    possible to ask for a Unix compiler object under Windows, and a\n"
"    Microsoft compiler object under Unix -- if you supply a value for\n"
"    'compiler', 'plat' is ignored.\n"
"    "
msgstr ""

#. XXX it would be nice (mainly aesthetic, and so we don't generate
#. stupid-looking command lines) to go over 'macros' and eliminate
#. redundant definitions/undefinitions (ie. ensure that only the
#. latest mention of a particular macro winds up on the command
#. line).  I don't think it's essential, though, since most (all?)
#. Unix C compilers only pay attention to the latest -D or -U
#. mention of a macro on their command line.  Similar situation for
#. 'include_dirs'.  I'm punting on both for now.  Anyways, weeding out
#. redundancies like this should probably be the province of
#. CCompiler, since the data structures used are inherited from it
#. and therefore common to all CCompiler classes.
#: Lib/distutils/ccompiler.py:961
msgid ""
"Generate C pre-processor options (-D, -U, -I) as used by at least\n"
"    two types of compilers: the typical Unix compiler and Visual C++.\n"
"    'macros' is the usual thing, a list of 1- or 2-tuples, where (name,)\n"
"    means undefine (-U) macro 'name', and (name,value) means define (-D)\n"
"    macro 'name' to 'value'.  'include_dirs' is just a list of directory\n"
"    names to be added to the header file search path (-I).  Returns a list\n"
"    of command-line options suitable for either Unix compilers or Visual\n"
"    C++.\n"
"    "
msgstr ""

#: Lib/distutils/ccompiler.py:1012
msgid ""
"Generate linker options for searching library directories and\n"
"    linking with specific libraries.  'libraries' and 'library_dirs' are,\n"
"    respectively, lists of library names (not filenames!) and search\n"
"    directories.  Returns a list of command-line options suitable for use\n"
"    with some compiler (depending on the two format strings passed in).\n"
"    "
msgstr ""

#. 'sub_commands' formalizes the notion of a "family" of commands,
#. eg. "install" as the parent with sub-commands "install_lib",
#. "install_headers", etc.  The parent of a family of commands
#. defines 'sub_commands' as a class attribute; it's a list of
#.    (command_name : string, predicate : unbound_method | string | None)
#. tuples, where 'predicate' is a method of the parent command that
#. determines whether the corresponding command is applicable in the
#. current situation.  (Eg. we "install_headers" is only applicable if
#. we have any C header files to install.)  If 'predicate' is None,
#. that command is always applicable.
#.
#. 'sub_commands' is usually defined at the *end* of a class, because
#. predicates can be unbound methods, so they must already have been
#. defined.  The canonical example is the "install" command.
#: Lib/distutils/cmd.py:19
msgid ""
"Abstract base class for defining command classes, the \"worker bees\"\n"
"    of the Distutils.  A useful analogy for command classes is to think of\n"
"    them as subroutines with local variables called \"options\".  The options\n"
"    are \"declared\" in 'initialize_options()' and \"defined\" (given their\n"
"    final values, aka \"finalized\") in 'finalize_options()', both of which\n"
"    must be defined by every command class.  The distinction between the\n"
"    two is necessary because option values might come from the outside\n"
"    world (command line, config file, ...), and any options dependent on\n"
"    other options must be computed *after* these outside influences have\n"
"    been processed -- hence 'finalize_options()'.  The \"body\" of the\n"
"    subroutine, where it does all its work based on the values of its\n"
"    options, is the 'run()' method, which must also be implemented by every\n"
"    command class.\n"
"    "
msgstr ""

#. late import because of mutual dependence between these classes
#: Lib/distutils/cmd.py:54
msgid ""
"Create and initialize a new Command object.  Most importantly,\n"
"        invokes the 'initialize_options()' method, which is the real\n"
"        initializer and depends on the actual command being\n"
"        instantiated.\n"
"        "
msgstr ""

#: Lib/distutils/cmd.py:130
msgid ""
"Set default values for all the options that this command\n"
"        supports.  Note that these defaults may be overridden by other\n"
"        commands, by the setup script, by config files, or by the\n"
"        command-line.  Thus, this is not the place to code dependencies\n"
"        between options; generally, 'initialize_options()' implementations\n"
"        are just a bunch of \"self.foo = None\" assignments.\n"
"           \n"
"        This method must be implemented by all command classes.\n"
"        "
msgstr ""

#: Lib/distutils/cmd.py:143
msgid ""
"Set final values for all the options that this command supports.\n"
"        This is always called as late as possible, ie.  after any option\n"
"        assignments from the command-line or from other commands have been\n"
"        done.  Thus, this is the place to to code option dependencies: if\n"
"        'foo' depends on 'bar', then it is safe to set 'foo' from 'bar' as\n"
"        long as 'foo' still has the same value it was assigned in\n"
"        'initialize_options()'.\n"
"\n"
"        This method must be implemented by all command classes.\n"
"        "
msgstr ""

#: Lib/distutils/cmd.py:172
msgid ""
"A command's raison d'etre: carry out the action it exists to\n"
"        perform, controlled by the options initialized in\n"
"        'initialize_options()', customized by other commands, the setup\n"
"        script, the command-line, and config files, and finalized in\n"
"        'finalize_options()'.  All terminal output and filesystem\n"
"        interaction should be done by 'run()'.\n"
"\n"
"        This method must be implemented by all command classes.\n"
"        "
msgstr ""

#: Lib/distutils/cmd.py:186
msgid ""
"If the current verbosity level is of greater than or equal to\n"
"        'level' print 'msg' to stdout.\n"
"        "
msgstr ""

#: Lib/distutils/cmd.py:193 Lib/distutils/filelist.py:61
msgid ""
"Print 'msg' to stdout if the global DEBUG (taken from the\n"
"        DISTUTILS_DEBUG environment variable) flag is true.\n"
"        "
msgstr ""

#: Lib/distutils/cmd.py:226
msgid ""
"Ensure that 'option' is a string; if not defined, set it to\n"
"        'default'.\n"
"        "
msgstr ""

#: Lib/distutils/cmd.py:232
msgid ""
"Ensure that 'option' is a list of strings.  If 'option' is\n"
"        currently a string, we split it either on /,s*/ or /s+/, so\n"
"        \"foo bar baz\", \"foo,bar,baz\", and \"foo,   bar baz\" all become\n"
"        [\"foo\", \"bar\", \"baz\"].\n"
"        "
msgstr ""

#: Lib/distutils/cmd.py:262
msgid "Ensure that 'option' is the name of an existing file."
msgstr ""

#. Option_pairs: list of (src_option, dst_option) tuples
#: Lib/distutils/cmd.py:283
msgid ""
"Set the values of any \"undefined\" options from corresponding\n"
"        option values in some other command object.  \"Undefined\" here means\n"
"        \"is None\", which is the convention used to indicate that an option\n"
"        has not been changed between 'initialize_options()' and\n"
"        'finalize_options()'.  Usually called from 'finalize_options()' for\n"
"        options that depend on some other command rather than another\n"
"        option of the same command.  'src_cmd' is the other command from\n"
"        which option values will be taken (a command object will be created\n"
"        for it if necessary); the remaining arguments are\n"
"        '(src_option,dst_option)' tuples which mean \"take the value of\n"
"        'src_option' in the 'src_cmd' command object, and copy it to\n"
"        'dst_option' in the current command object\".\n"
"        "
msgstr ""

#: Lib/distutils/cmd.py:308
msgid ""
"Wrapper around Distribution's 'get_command_obj()' method: find\n"
"        (create if necessary and 'create' is true) the command object for\n"
"        'command', call its 'ensure_finalized()' method, and return the\n"
"        finalized command object.\n"
"        "
msgstr ""

#: Lib/distutils/cmd.py:324
msgid ""
"Run some other command: uses the 'run_command()' method of\n"
"        Distribution, which creates and finalizes the command object if\n"
"        necessary and then invokes its 'run()' method.\n"
"        "
msgstr ""

#: Lib/distutils/cmd.py:332
msgid ""
"Determine the sub-commands that are relevant in the current\n"
"        distribution (ie., that need to be run).  This is based on the\n"
"        'sub_commands' class attribute: each tuple in that list may include\n"
"        a method that we call to determine if the subcommand needs to be\n"
"        run for the current distribution.  Return a list of command names.\n"
"        "
msgstr ""

#: Lib/distutils/cmd.py:363
msgid ""
"Copy a file respecting verbose, dry-run and force flags.  (The\n"
"        former two default to whatever is in the Distribution object, and\n"
"        the latter defaults to false for commands that don't define it.)"
msgstr ""

#: Lib/distutils/cmd.py:379
msgid ""
"Copy an entire directory tree respecting verbose, dry-run,\n"
"        and force flags.\n"
"        "
msgstr ""

#: Lib/distutils/cmd.py:391
msgid "Move a file respecting verbose and dry-run flags."
msgstr ""

#: Lib/distutils/cmd.py:398
msgid "Spawn an external command respecting verbose and dry-run flags."
msgstr ""

#: Lib/distutils/cmd.py:414
msgid ""
"Special case of 'execute()' for operations that process one or\n"
"        more input files and generate one output file.  Works just like\n"
"        'execute()', except the operation is skipped and a different\n"
"        message printed if 'outfile' already exists and is newer than all\n"
"        files listed in 'infiles'.  If the command defined 'self.force',\n"
"        and it is true, then the command is unconditionally run -- does no\n"
"        timestamp checks.\n"
"        "
msgstr ""

#: Lib/distutils/cmd.py:457
msgid ""
"Common base class for installing some files in a subdirectory.\n"
"    Currently used by install_data and install_scripts.\n"
"    "
msgstr ""

#: Lib/distutils/command/bdist.py:18
msgid ""
"Print list of available formats (arguments to \"--format\" option).\n"
"    "
msgstr ""

#. definitions and headers
#: Lib/distutils/command/bdist_rpm.py:317
msgid ""
"Generate the text of an RPM spec file and return it as a\n"
"        list of strings (one per line).\n"
"        "
msgstr ""

#: Lib/distutils/command/bdist_rpm.py:463
msgid ""
"Format the changelog correctly and convert it to a list of strings\n"
"        "
msgstr ""

#. Yechh, blecch, ackk: this is ripped straight out of build_ext.py,
#. with only names changed to protect the innocent!
#: Lib/distutils/command/build_clib.py:135
msgid ""
"Ensure that the list of libraries (presumably provided as a\n"
"           command option 'libraries') is valid, i.e. it is a list of\n"
"           2-tuples, where the tuples are (library_name, build_info_dict).\n"
"           Raise DistutilsSetupError if the structure is invalid anywhere;\n"
"           just returns otherwise."
msgstr ""

#: Lib/distutils/command/build_ext.py:262
msgid ""
"Ensure that the list of extensions (presumably provided as a\n"
"        command option 'extensions') is valid, i.e. it is a list of\n"
"        Extension objects.  We also support the old-style list of 2-tuples,\n"
"        where the tuples are (ext_name, build_info), which are converted to\n"
"        Extension instances here.\n"
"\n"
"        Raise DistutilsSetupError if the structure is invalid anywhere;\n"
"        just returns otherwise.\n"
"        "
msgstr ""

#: Lib/distutils/command/build_ext.py:480
msgid ""
"Walk the list of source files in 'sources', looking for SWIG\n"
"        interface (.i) files.  Run SWIG on all that are found, and\n"
"        return a modified 'sources' list with SWIG source files replaced\n"
"        by the generated C (or C++) files.\n"
"        "
msgstr ""

#: Lib/distutils/command/build_ext.py:527
msgid ""
"Return the name of the SWIG executable.  On Unix, this is\n"
"        just \"swig\" -- it should be in the PATH.  Tries a bit harder on\n"
"        Windows.\n"
"        "
msgstr ""

#: Lib/distutils/command/build_ext.py:563
msgid ""
"Convert the name of an extension (eg. \"foo.bar\") into the name\n"
"        of the file from which it will be loaded (eg. \"foo/bar.so\", or\n"
"        \"foo\\bar.pyd\").\n"
"        "
msgstr ""

#: Lib/distutils/command/build_ext.py:577
msgid ""
"Return the list of symbols that a shared extension has to\n"
"        export.  This either uses 'ext.export_symbols' or, if it's not\n"
"        provided, \"init\" + module_name.  Only relevant on Windows, where\n"
"        the .pyd file (DLL) must export the module \"init\" function.\n"
"        "
msgstr ""

#. The python library is always needed on Windows.  For MSVC, this
#. is redundant, since the library is mentioned in a pragma in
#. config.h that MSVC groks.  The other Windows compilers all seem
#. to need it mentioned explicitly, though, so that's what we do.
#. Append '_d' to the python import library on debug builds.
#: Lib/distutils/command/build_ext.py:589
msgid ""
"Return the list of libraries to link against when building a\n"
"        shared extension.  On most platforms, this is just 'ext.libraries';\n"
"        on Windows, we add the Python library (eg. python20.dll).\n"
"        "
msgstr ""

#: Lib/distutils/command/build_py.py:112
msgid ""
"Return the directory, relative to the top of the source\n"
"           distribution, where package 'package' should be found\n"
"           (at least according to the 'package_dir' option, if any)."
msgstr ""

#. Map package names to tuples of useful info about the package:
#.    (package_dir, checked)
#. package_dir - the directory where we'll find source files for
#.   this package
#. checked - true if we have checked that the package directory
#.   is valid (exists, contains __init__.py, ... ?)
#: Lib/distutils/command/build_py.py:213
msgid ""
"Finds individually-specified Python modules, ie. those listed by\n"
"        module name in 'self.py_modules'.  Returns a list of tuples (package,\n"
"        module_base, filename): 'package' is a tuple of the path through\n"
"        package-space to the module; 'module_base' is the bare (no\n"
"        packages, no dots) module name, and 'filename' is the path to the\n"
"        \".py\" file (relative to the distribution root) that implements the\n"
"        module.\n"
"        "
msgstr ""

#: Lib/distutils/command/build_py.py:270
msgid ""
"Compute the list of all modules that will be built, whether\n"
"        they are specified one-module-at-a-time ('self.py_modules') or\n"
"        by whole packages ('self.packages').  Return a list of tuples\n"
"        (package, module, module_file), just like 'find_modules()' and\n"
"        'find_package_modules()' do."
msgstr ""

#: Lib/distutils/command/build_scripts.py:50
msgid ""
"Copy each script listed in 'self.scripts'; if it's marked as a\n"
"        Python script in the Unix way (first line matches 'first_line_re',\n"
"        ie. starts with \"#!\" and contains \"python\"), then adjust the first\n"
"        line to refer to the current Python interpreter as we copy.\n"
"        "
msgstr ""

#. We do this late, and only on-demand, because this is an expensive
#. import.
#: Lib/distutils/command/config.py:98
msgid ""
"Check that 'self.compiler' really is a CCompiler object;\n"
"        if not, make it one.\n"
"        "
msgstr ""

#: Lib/distutils/command/config.py:180
msgid ""
"Construct a source file from 'body' (a string containing lines\n"
"        of C/C++ code) and 'headers' (a list of header files to include)\n"
"        and run it through the preprocessor.  Return true if the\n"
"        preprocessor succeeded, false if there were any errors.\n"
"        ('body' probably isn't of much use, but what the heck.)\n"
"        "
msgstr ""

#: Lib/distutils/command/config.py:199
msgid ""
"Construct a source file (just like 'try_cpp()'), run it through\n"
"        the preprocessor, and return true if any line of the output matches\n"
"        'pattern'.  'pattern' should either be a compiled regex object or a\n"
"        string containing a regex.  If both 'body' and 'headers' are None,\n"
"        preprocesses an empty file -- which can be useful to determine the\n"
"        symbols the preprocessor and compiler set by default.\n"
"        "
msgstr ""

#: Lib/distutils/command/config.py:228
msgid ""
"Try to compile a source file built from 'body' and 'headers'.\n"
"        Return true on success, false otherwise.\n"
"        "
msgstr ""

#: Lib/distutils/command/config.py:247
msgid ""
"Try to compile and link a source file, built from 'body' and\n"
"        'headers', to executable form.  Return true on success, false\n"
"        otherwise.\n"
"        "
msgstr ""

#: Lib/distutils/command/config.py:268
msgid ""
"Try to compile, link to an executable, and run a program\n"
"        built from 'body' and 'headers'.  Return true on success, false\n"
"        otherwise.\n"
"        "
msgstr ""

#: Lib/distutils/command/config.py:296
msgid ""
"Determine if function 'func' is available by constructing a\n"
"        source file that refers to 'func', and compiles and links it.\n"
"        If everything succeeds, returns true; otherwise returns false.\n"
"\n"
"        The constructed source file starts out by including the header\n"
"        files listed in 'headers'.  If 'decl' is true, it then declares\n"
"        'func' (as \"int func()\"); you probably shouldn't supply 'headers'\n"
"        and set 'decl' true in the same call, or you might get errors about\n"
"        a conflicting declarations for 'func'.  Finally, the constructed\n"
"        'main()' function either references 'func' or (if 'call' is true)\n"
"        calls it.  'libraries' and 'library_dirs' are used when\n"
"        linking.\n"
"        "
msgstr ""

#: Lib/distutils/command/config.py:329
msgid ""
"Determine if 'library' is available to be linked against,\n"
"        without actually checking that any particular symbols are provided\n"
"        by it.  'headers' will be used in constructing the source file to\n"
"        be compiled, but the only effect of this is to check if all the\n"
"        header files listed are available.  Any libraries listed in\n"
"        'other_libraries' will be included in the link, in case 'library'\n"
"        has symbols that depend on other libraries.\n"
"        "
msgstr ""

#: Lib/distutils/command/config.py:344
msgid ""
"Determine if the system header file named by 'header_file'\n"
"        exists and can be found by the preprocessor; return true if so,\n"
"        false otherwise.\n"
"        "
msgstr ""

#: Lib/distutils/command/install.py:554
msgid ""
"Return true if the current distribution has any Python\n"
"        modules to install."
msgstr ""

#: Lib/distutils/command/install_lib.py:173
msgid ""
"Return the list of files that would be installed if this command\n"
"        were actually run.  Not affected by the \"dry-run\" flag or whether\n"
"        modules have actually been built yet.\n"
"        "
msgstr ""

#: Lib/distutils/command/install_lib.py:196
msgid ""
"Get the list of files that are input to this command, ie. the\n"
"        files that get installed as they are named in the build tree.\n"
"        The files in this list correspond one-to-one to the output\n"
"        filenames returned by 'get_outputs()'.\n"
"        "
msgstr ""

#: Lib/distutils/command/sdist.py:20
msgid ""
"Print all possible values for the 'formats' option (used by\n"
"    the \"--help-formats\" command-line option).\n"
"    "
msgstr ""

#: Lib/distutils/command/sdist.py:154
msgid ""
"Ensure that all required elements of meta-data (name, version,\n"
"        URL, (author and author_email) or (maintainer and\n"
"        maintainer_email)) are supplied by the Distribution object; warn if\n"
"        any are missing.\n"
"        "
msgstr ""

#. If we have a manifest template, see if it's newer than the
#. manifest; if so, we'll regenerate the manifest.
#: Lib/distutils/command/sdist.py:187
msgid ""
"Figure out the list of files to include in the source\n"
"        distribution, and put it in 'self.filelist'.  This might involve\n"
"        reading the manifest template (and writing the manifest), or just\n"
"        reading the manifest, or just using the default file set -- it all\n"
"        depends on the user's options and the state of the filesystem.\n"
"        "
msgstr ""

#: Lib/distutils/command/sdist.py:271
msgid ""
"Add all the default files to self.filelist:\n"
"          - README or README.txt\n"
"          - setup.py\n"
"          - test/test*.py\n"
"          - all pure Python modules mentioned in setup script\n"
"          - all C sources listed as part of extensions or C libraries\n"
"            in the setup script (doesn't catch C headers!)\n"
"        Warns if (README or README.txt) or setup.py are missing; everything\n"
"        else is optional.\n"
"        "
msgstr ""

#: Lib/distutils/command/sdist.py:325
msgid ""
"Read and parse the manifest template file named by\n"
"        'self.template' (usually \"MANIFEST.in\").  The parsing and\n"
"        processing is done by 'self.filelist', which updates itself\n"
"        accordingly.\n"
"        "
msgstr ""

#: Lib/distutils/command/sdist.py:355
msgid ""
"Prune off branches that might slip into the file list as created\n"
"        by 'read_template()', but really don't belong there:\n"
"          * the build tree (typically \"build\")\n"
"          * the release tree itself (only an issue if we ran \"sdist\"\n"
"            previously with --keep-temp, or it aborted)\n"
"          * any RCS or CVS directories\n"
"        "
msgstr ""

#: Lib/distutils/command/sdist.py:371
msgid ""
"Write the file list in 'self.filelist' (presumably as filled in\n"
"        by 'add_defaults()' and 'read_template()') to the manifest file\n"
"        named by 'self.manifest'.\n"
"        "
msgst