# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2000 BeOpen.com.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# Copyright (C) 1995-2000 Corporation for National Research Initiatives.
# Copyright (C) 1991-1995, Stichting Mathematisch Centrum Amsterdam, The Netherlands.
# 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: 2000-09-10 23:56+MEZ\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"

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

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

#: Lib/asynchat.py:159
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:163
msgid "predicate for inclusion in the writable for select()"
msgstr ""

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

#: Lib/atexit.py:10
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:22
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:13
msgid "Encode a file."
msgstr ""

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

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

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

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

#: Lib/BaseHTTPServer.py:93 Lib/dos-8x3/basehttp.py:93
msgid "Override server_bind to store the server name."
msgstr ""

#. The Python system version, truncated to its first component.
#. The Python system version, truncated to its first component.
#: Lib/BaseHTTPServer.py:102 Lib/dos-8x3/basehttp.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 Lib/dos-8x3/basehttp.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 Lib/dos-8x3/basehttp.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 Lib/dos-8x3/basehttp.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 Lib/dos-8x3/basehttp.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 Lib/dos-8x3/basehttp.py:318
msgid "Send a MIME header."
msgstr ""

#: Lib/BaseHTTPServer.py:323 Lib/dos-8x3/basehttp.py:323
msgid "Send the blank line ending the MIME headers."
msgstr ""

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

#: Lib/BaseHTTPServer.py:338 Lib/dos-8x3/basehttp.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 Lib/dos-8x3/basehttp.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 Lib/dos-8x3/basehttp.py:374
msgid "Return the server software version string."
msgstr ""

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

#: Lib/BaseHTTPServer.py:388 Lib/dos-8x3/basehttp.py:388
msgid "Return the current time formatted for logging."
msgstr ""

#: Lib/BaseHTTPServer.py:402 Lib/dos-8x3/basehttp.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 Lib/dos-8x3/basehttp.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:35 Lib/dos-8x3/bastion.py:35
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:44 Lib/dos-8x3/bastion.py:44
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:57 Lib/dos-8x3/bastion.py:57
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:67 Lib/dos-8x3/bastion.py:67
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!
#. 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:85 Lib/dos-8x3/bastion.py:85
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:112 :120 Lib/dos-8x3/bastion.py:112 :120
msgid "Internal function for Bastion().  See source comments."
msgstr ""

#: Lib/Bastion.py:129 Lib/dos-8x3/bastion.py:129
msgid "Test the Bastion() function."
msgstr ""

#: Lib/bdb.py:12
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:122
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:127
msgid "This method is called when we stop or break at this line."
msgstr ""

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

#: Lib/bdb.py:135
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:143
msgid "Stop after one line of code."
msgstr ""

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

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

#: Lib/bdb.py:161
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:399
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:479
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:5
msgid "Insert item x in list a, and keep it sorted assuming a is sorted."
msgstr ""

#: Lib/bisect.py:16
msgid "Find the index where to insert item x in list a, assuming a is sorted."
msgstr ""

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

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

#: Lib/calendar.py:56
msgid ""
"Return number of leap years in range [y1, y2).\n"
"       Assume y1 <= y2 and no funny (non-leap century) years."
msgstr ""

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

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

#: Lib/calendar.py:77
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:92
msgid "Center a string in a field."
msgstr ""

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

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

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

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

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

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

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

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

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

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

#. Make rfile unbuffered -- we need to read one line and then pass
#. the rest to a subprocess, so we can't use buffered input.
#. Make rfile unbuffered -- we need to read one line and then pass
#. the rest to a subprocess, so we can't use buffered input.
#: Lib/CGIHTTPServer.py:30 Lib/dos-8x3/cgihttps.py:30
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:43 Lib/dos-8x3/cgihttps.py:43
msgid ""
"Serve a POST request.\n"
"\n"
"        This is only implemented for CGI scripts.\n"
"\n"
"        "
msgstr ""

#: Lib/CGIHTTPServer.py:55 Lib/dos-8x3/cgihttps.py:55
msgid "Version of send_head that support CGI scripts"
msgstr ""

#: Lib/CGIHTTPServer.py:62 Lib/dos-8x3/cgihttps.py:62
msgid ""
"test whether PATH corresponds to a CGI script.\n"
"\n"
"        Return a tuple (dir, rest) if 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:87 Lib/dos-8x3/cgihttps.py:87
msgid "Execute a CGI script."
msgstr ""

#: Lib/CGIHTTPServer.py:186 Lib/dos-8x3/cgihttps.py:186
msgid "Internal routine to get nobody's uid"
msgstr ""

#: Lib/CGIHTTPServer.py:199 Lib/dos-8x3/cgihttps.py:199
msgid "Test for executable file."
msgstr ""

#: Lib/cgi.py:45
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:80
msgid "Write a log message to the log file.  See initlog() for docs."
msgstr ""

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

#: Lib/cgi.py:98
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:151
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:177
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"
"\n"
"       Returns a list, as God intended.\n"
"    "
msgstr ""

#: Lib/cgi.py:213
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:304
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:329
msgid "Like FieldStorage, for use when no file uploads are possible."
msgstr ""

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

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

#: Lib/cgi.py:354
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:397
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:510
msgid "Return a printable representation."
msgstr ""

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

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

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

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

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

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

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

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

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

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

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

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

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

#: Lib/cgi.py:690
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:722
msgid ""
"Basic (multiple values per field) form content as dictionary.\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:740
msgid ""
"Strict single-value expecting form content as dictionary.\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:774 :802
msgid "This class is present for backwards compatibility only."
msgstr ""

#: Lib/cgi.py:828
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:882
msgid "Dump the shell environment as HTML."
msgstr ""

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

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

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

#: Lib/cgi.py:975
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"
"\t"
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"
"\t"
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"
"\t"
msgstr ""

#: Lib/codecs.py:47
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:62
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:81
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:113
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:132
msgid ""
" Writes the object's contents encoded to self.stream.\n"
"        "
msgstr ""

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

#: Lib/codecs.py:146
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:160 :286 :352 :455
msgid ""
" Inherit all other methods from the underlying stream.\n"
"        "
msgstr ""

#: Lib/codecs.py:170
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:189
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:231
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:255
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:273
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:294
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:307
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:360
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:381
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:463
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:507
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"
"        data_encoding and file_encoding are added to the wrapped file\n"
"        object as attributes .data_encoding and .file_encoding resp.\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 ""

#. Check for source consisting of only blank lines and comments
#: Lib/codeop.py:8
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/code.py:15
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:24
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:37
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:76
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:95
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:128
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:151
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:161
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:169
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:183
msgid "Reset the input buffer."
msgstr ""

#: Lib/code.py:187
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:231
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:252
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:266
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/commands.py:32
msgid "Return output of \"ls -ld <file>\" in a string."
msgstr ""

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

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

#: Lib/compileall.py:21 Lib/dos-8x3/compilea.py:21
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:74 Lib/dos-8x3/compilea.py:74
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:92 Lib/dos-8x3/compilea.py:92
msgid "Script main program."
msgstr ""

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

#: Lib/ConfigParser.py:172 Lib/dos-8x3/configpa.py:172
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:182 Lib/dos-8x3/configpa.py:182
msgid ""
"Indicate whether the named section is present in the configuration.\n"
"\n"
"        The DEFAULT section is not acknowledged.\n"
"        "
msgstr ""

#: Lib/ConfigParser.py:189 Lib/dos-8x3/configpa.py:189
msgid "Return a list of option names for the given section name."
msgstr ""

#: Lib/ConfigParser.py:198 Lib/dos-8x3/configpa.py:198
msgid "Return whether the given section has the given option."
msgstr ""

#: Lib/ConfigParser.py:206 Lib/dos-8x3/configpa.py:206
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:226 Lib/dos-8x3/configpa.py:226
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:242 Lib/dos-8x3/configpa.py:242
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:305 Lib/dos-8x3/configpa.py:305
msgid "Check for the existence of a given option in a given section."
msgstr ""

#: Lib/ConfigParser.py:314 Lib/dos-8x3/configpa.py:314
msgid "Set an option."
msgstr ""

#: Lib/ConfigParser.py:325 Lib/dos-8x3/configpa.py:325
msgid "Write an .ini-format representation of the configuration state."
msgstr ""

#: Lib/ConfigParser.py:341 Lib/dos-8x3/configpa.py:341
msgid "Remove an option."
msgstr ""

#: Lib/ConfigParser.py:355 Lib/dos-8x3/configpa.py:355
msgid "Remove a file section."
msgstr ""

#: Lib/ConfigParser.py:381 Lib/dos-8x3/configpa.py:381
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:547 Lib/dos-8x3/cookie.py:547
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:557 Lib/dos-8x3/cookie.py:557
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:572 Lib/dos-8x3/cookie.py:572
msgid "Private method for setting a cookie's value"
msgstr ""

#: Lib/Cookie.py:579 Lib/dos-8x3/cookie.py:579
msgid "Dictionary style assignment."
msgstr ""

#: Lib/Cookie.py:585 Lib/dos-8x3/cookie.py:585
msgid "Return a string suitable for HTTP."
msgstr ""

#: Lib/Cookie.py:601 Lib/dos-8x3/cookie.py:601
msgid "Return a string suitable for JavaScript."
msgstr ""

#: Lib/Cookie.py:609 Lib/dos-8x3/cookie.py:609
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:652 Lib/dos-8x3/cookie.py:652
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:666 Lib/dos-8x3/cookie.py:666
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:687 Lib/dos-8x3/cookie.py:687
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/copy.py:60
msgid ""
"Shallow copy operation on arbitrary Python objects.\n"
"\n"
"\tSee the module's __doc__ string for more info.\n"
"\t"
msgstr ""

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

#: Lib/copy.py:203
msgid ""
"Keeps a reference to the object x in the memo.\n"
"\n"
"\tBecause we remember objects by their id, we have\n"
"\tto assure that possibly temporary objects are kept\n"
"\talive by referencing them.\n"
"\tWe store a reference at the id of the memo, which should\n"
"\tnormally not be used unless someone tries to deepcopy\n"
"\tthe memo itself...\n"
"\t"
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 ""

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

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

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

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

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

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

#: Lib/dis.py:280
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."
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\n"
"       output zip file will be named 'base_dir' + \".zip\".  Uses either the\n"
"       InfoZIP \"zip\" utility (if installed and found on the default search\n"
"       path) or the \"zipfile\" Python module (if available).  If neither\n"
"       tool is available, raises DistutilsExecError.  Returns the name\n"
"       of the output zip file."
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:394
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:413
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:451
msgid ""
"Return true if we need to relink the files listed in 'objects'\n"
"        to recreate 'output_file'.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:476
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:495
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:543
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:576
msgid ""
"Link a bunch of stuff together to create a shared library file.\n"
"        Similar semantics to 'create_static_lib()', with the addition of\n"
"        other libraries to link against and directories to search for them.\n"
"        Also, of course, the type and name of the generated file will\n"
"        almost certainly be different, as will the program used to create\n"
"        it.\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:628
msgid ""
"Link a bunch of stuff together to create a shared object file.\n"
"        Much like 'link_shared_lib()', except the output filename is\n"
"        explicitly supplied as 'output_filename'.  If 'output_dir' is\n"
"        supplied, 'output_filename' is relative to it\n"
"        (i.e. 'output_filename' can provide directory components if\n"
"        needed).\n"
"\n"
"        Raises LinkError on failure.\n"
"        "
msgstr ""

#: Lib/distutils/ccompiler.py:650
msgid ""
"Link a bunch of stuff together to create a binary executable\n"
"        file.  The \"bunch of stuff\" is as for 'link_shared_lib()'.\n"
"        'output_progname' should be the base name of the executable\n"
"        program--e.g. on Unix the same as the output filename, but on\n"
"        DOS/Windows \".exe\" will be appended.\n"
"\n"
"        Raises LinkError on failure.\n"
"        "
msgstr ""

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

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

#: Lib/distutils/ccompiler.py:680
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:686
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 ""

#. 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:832
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:853
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:895
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:946
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 ""

#. -- Creation/initialization methods -------------------------------
#: 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:37
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:113
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:126
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:155
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:169
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:176 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:209
msgid ""
"Ensure that 'option' is a string; if not defined, set it to\n"
"        'default'.\n"
"        "
msgstr ""

#: Lib/distutils/cmd.py:215
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:245
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:266
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:291
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:306
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:331
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:347
msgid ""
"Copy an entire directory tree respecting verbose, dry-run,\n"
"        and force flags.\n"
"        "
msgstr ""

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

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

#: Lib/distutils/cmd.py:382
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:425
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:314
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:460
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:133
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:230
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:443
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:490
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:526
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:548
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.
#: Lib/distutils/command/build_ext.py:560
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:92
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:193
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:250
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:46
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:83
msgid ""
"Check that 'self.compiler' really is a CCompiler object;\n"
"        if not, make it one.\n"
"        "
msgstr ""

#: Lib/distutils/command/config.py:165
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:184
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:213
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:232
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:253
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:281
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:314
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.\n"
"        "
msgstr ""

#: Lib/distutils/command/config.py:326
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_lib.py:110
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."
msgstr ""

#: Lib/distutils/command/install_lib.py:133
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()'."
msgstr ""

#: Lib/distutils/command/install.py:443
msgid ""
"Return the list of subcommands that we need to run.  This is\n"
"        based on the 'subcommands' class attribute: each tuple in that list\n"
"        can name a method that we call to determine if the subcommand needs\n"
"        to be run for the current distribution."
msgstr ""

#: Lib/distutils/command/install.py:493
msgid ""
"Return true if the current distribution has any Python\n"
"        modules to install."
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:152
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:185
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 ""

#. XXX name of setup script and config file should be taken
#. programmatically from the Distribution object (except
#. it doesn't have that capability... yet!)
#: Lib/distutils/command/sdist.py:265
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:322
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:352
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-tree, or it aborted)\n"
"          * any RCS or CVS directories\n"
"        "
msgstr ""

#: Lib/distutils/command/sdist.py:368
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"
"        "
msgstr ""

#: Lib/distutils/command/sdist.py:380
msgid ""
"Read the manifest file (named by 'self.manifest') and use it to\n"
"        fill in 'self.filelist', the list of files to include in the source\n"
"        distribution.\n"
"        "
msgstr ""

#. Create all the directories under 'base_dir' necessary to
#. put 'files' there.
#: Lib/distutils/command/sdist.py:398
msgid ""
"Create the directory tree that will become the source\n"
"        distribution archive.  All directories implied by the filenames in\n"
"        'files' are created under 'base_dir', and then we hard link or copy\n"
"        (if hard linking is unavailable) those files into place.\n"
"        Essentially, this duplicates the developer's source tree, but in a\n"
"        directory named after the distribution, containing only the files\n"
"        to be distributed.\n"
"        "
msgstr ""

#. Don't warn about missing meta-data here -- should be (and is!)
#. done elsewhere.
#: Lib/distutils/command/sdist.py:434
msgid ""
"Create the source distribution(s).  First, we create the release\n"
"        tree with 'make_release_tree()'; then, we create all required\n"
"        archive files (according to 'self.formats') from the release tree.\n"
"        Finally, we clean up by blowing away the release tree (unless\n"
"        'self.keep_tree' is true).  The list of archive files created is\n"
"        stored so it can be retrieved later by 'get_archive_files()'.\n"
"        "
msgstr ""

#: Lib/distutils/command/sdist.py:458
msgid ""
"Return the list of archive files created when the command\n"
"        was run, or None if the command hasn't run yet.\n"
"        "
msgstr ""

#: Lib/distutils/core.py:51
msgid ""
"The gateway to the Distutils: do everything your setup script needs\n"
"    to do, in a highly flexible and user-driven way.  Briefly: create a\n"
"    Distribution instance; find and parse config files; parse the command\n"
"    line; run each Distutils command found there, customized by the options\n"
"    supplied to 'setup()' (as keyword arguments), in config files, and on\n"
"    the command line.\n"
"\n"
"    The Distribution instance might be an instance of a class supplied via\n"
"    the 'distclass' keyword argument to 'setup'; if no such class is\n"
"    supplied, then the Distribution class (in dist.py) is instantiated.\n"
"    All other arguments to 'setup' (except for 'cmdclass') are used to set\n"
"    attributes of the Distribution instance.\n"
"\n"
"    The 'cmdclass' argument, if supplied, is a dictionary mapping command\n"
"    names to command classes.  Each command encountered on the command line\n"
"    will be turned into a command class, which is in turn instantiated; any\n"
"    class found in 'cmdclass' is used in place of the default, which is\n"
"    (for command 'foo_bar') class 'foo_bar' in module\n"
"    'distutils.command.foo_bar'.  The command class must provide a\n"
"    'user_options' attribute which is a list of option specifiers for\n"
"    'distutils.fancy_getopt'.  Any command-line options between the current\n"
"    and the next command are used to set attributes of the current command\n"
"    object.\n"
"\n"
"    When the entire command-line has been successfully parsed, calls the\n"
"    'run()' method on each command object in turn.  This method will be\n"
"    driven entirely by the Distribution object (which each command object\n"
"    has a reference to, thanks to its constructor), and the\n"
"    command-specific options that became attributes of each command\n"
"    object.\n"
"    "
msgstr ""

#: Lib/distutils/core.py:165
msgid ""
"Run a setup script in a somewhat controlled environment, and\n"
"    return the Distribution instance that drives things.  This is useful\n"
"    if you need to find out the distribution meta-data (passed as\n"
"    keyword args from 'script' to 'setup()', or the contents of the\n"
"    config files or command-line.\n"
"\n"
"    'script_name' is a file that will be run with 'execfile()';\n"
"    'sys.argv[0]' will be replaced with 'script' for the duration of the\n"
"    call.  'script_args' is a list of strings; if supplied,\n"
"    'sys.argv[1:]' will be replaced by 'script_args' for the duration of\n"
"    the call.\n"
"\n"
"    'stop_after' tells 'setup()' when to stop processing; possible\n"
"    values:\n"
"      init\n"
"        stop after the Distribution instance has been created and\n"
"        populated with the keyword arguments to 'setup()'\n"
"      config\n"
"        stop after config files have been parsed (and their data\n"
"        stored in the Distribution instance)\n"
"      commandline\n"
"        stop after the command-line ('sys.argv[1:]' or 'script_args')\n"
"        have been parsed (and the data stored in the Distribution)\n"
"      run [default]\n"
"        stop after all commands have been run (the same as if 'setup()'\n"
"        had been called in the usual way\n"
"\n"
"    Returns the Distribution instance, which provides all information\n"
"    used to drive the Distutils.\n"
"    "
msgstr ""

#. XXX since this function also checks sys.version, it's not strictly a
#. "config.h" check -- should probably be renamed...
#: Lib/distutils/cygwinccompiler.py:252
msgid ""
"Check if the current Python installation (specifically, config.h)\n"
"    appears amenable to building extensions with GCC.  Returns a tuple\n"
"    (status, details), where 'status' is one of the following constants:\n"
"      CONFIG_H_OK\n"
"        all is well, go ahead and compile\n"
"      CONFIG_H_NOTOK\n"
"        doesn't look good\n"
"      CONFIG_H_UNCERTAIN\n"
"        not sure -- unable to read config.h\n"
"    'details' is a human-readable string explaining the situation.\n"
"\n"
"    Note there are two ways to conclude \"OK\": either 'sys.version' contains\n"
"    the string \"GCC\" (implying that this Python was built with GCC), or the\n"
"    installed \"config.h\" contains the string \"__GNUC__\".\n"
"    "
msgstr ""

#: Lib/distutils/cygwinccompiler.py:302
msgid ""
" Try to find out the versions of gcc, ld and dllwrap.\n"
"        If not possible it returns None for it.\n"
"    "
msgstr ""

#: Lib/distutils/dep_util.py:16
msgid ""
"Return true if 'source' exists and is more recently modified than\n"
"       'target', or if 'source' exists and 'target' doesn't.  Return\n"
"       false if both exist and 'target' is the same age or younger than\n"
"       'source'.  Raise DistutilsFileError if 'source' does not\n"
"       exist."
msgstr ""

#: Lib/distutils/dep_util.py:37
msgid ""
"Walk two filename lists in parallel, testing if each source is newer\n"
"       than its corresponding target.  Return a pair of lists (sources,\n"
"       targets) where source is newer than target, according to the\n"
"       semantics of 'newer()'."
msgstr ""

#. If the target doesn't even exist, then it's definitely out-of-date.
#: Lib/distutils/dep_util.py:59
msgid ""
"Return true if 'target' is out-of-date with respect to any\n"
"       file listed in 'sources'.  In other words, if 'target' exists and\n"
"       is newer than every file in 'sources', return false; otherwise\n"
"       return true.  'missing' controls what we do when a source file is\n"
"       missing; the default (\"error\") is to blow up with an OSError from\n"
"       inside 'stat()'; if it is \"ignore\", we silently drop any missing\n"
"       source files; if it is \"newer\", any missing source files make us\n"
"       assume that 'target' is out-of-date (this is handy in \"dry-run\"\n"
"       mode: it'll make you pretend to carry out commands that wouldn't\n"
"       work because inputs are missing, but that doesn't matter because\n"
"       you're not actually going to run the commands)."
msgstr ""

#: Lib/distutils/dep_util.py:104
msgid ""
"Makes 'dst' from 'src' (both filenames) by calling 'func' with\n"
"       'args', but only if it needs to: i.e. if 'dst' does not exist or\n"
"       'src' is newer than 'dst'."
msgstr ""

#: Lib/distutils/dir_util.py:22
msgid ""
"Create a directory and any missing ancestor directories.  If the\n"
"       directory already exists (or if 'name' is the empty string, which\n"
"       means the current directory, which of course exists), then do\n"
"       nothing.  Raise DistutilsFileError if unable to create some\n"
"       directory along the way (eg. some sub-path exists, but is a file\n"
"       rather than a directory).  If 'verbose' is true, print a one-line\n"
"       summary of each mkdir to stdout.  Return the list of directories\n"
"       actually created."
msgstr ""

#. First get the list of directories to create
#: Lib/distutils/dir_util.py:89
msgid ""
"Create all the empty directories under 'base_dir' needed to\n"
"       put 'files' there.  'base_dir' is just the a name of a directory\n"
"       which doesn't necessarily exist yet; 'files' is a list of filenames\n"
"       to be interpreted relative to 'base_dir'.  'base_dir' + the\n"
"       directory portion of every file in 'files' will be created if it\n"
"       doesn't already exist.  'mode', 'verbose' and 'dry_run' flags are as\n"
"       for 'mkpath()'."
msgstr ""

#: Lib/distutils/dir_util.py:119
msgid ""
"Copy an entire directory tree 'src' to a new location 'dst'.  Both\n"
"       'src' and 'dst' must be directory names.  If 'src' is not a\n"
"       directory, raise DistutilsFileError.  If 'dst' does not exist, it is\n"
"       created with 'mkpath()'.  The end result of the copy is that every\n"
"       file in 'src' is copied to 'dst', and directories under 'src' are\n"
"       recursively copied to 'dst'.  Return the list of files that were\n"
"       copied or might have been copied, using their output name.  The\n"
"       return value is unaffected by 'update' or 'dry_run': it is simply\n"
"       the list of all files under 'src', with the names changed to be\n"
"       under 'dst'.\n"
"\n"
"       'preserve_mode' and 'preserve_times' are the same as for\n"
"       'copy_file'; note that they only apply to regular files, not to\n"
"       directories.  If 'preserve_symlinks' is true, symlinks will be\n"
"       copied as symlinks (on platforms that support them!); otherwise\n"
"       (the default), the destination of the symlink will be copied.\n"
"       'update' and 'verbose' are the same as for 'copy_file'."
msgstr ""

#: Lib/distutils/dir_util.py:195
msgid ""
"Recursively remove an entire directory tree.  Any errors are ignored\n"
"    (apart from being reported to stdout if 'verbose' is true).\n"
"    "
msgstr ""

#. 'global_options' describes the command-line options that may be
#. supplied to the setup script prior to any actual commands.
#. Eg. "./setup.py -n" or "./setup.py --quiet" both take advantage of
#. these global options.  This list should be kept to a bare minimum,
#. since every global option is also valid as a command option -- and we
#. don't want to pollute the commands with too many options that they
#. have minimal control over.
#: Lib/distutils/dist.py:29
msgid ""
"The core of the Distutils.  Most of the work hiding behind 'setup'\n"
"    is really done within a Distribution instance, which farms the work out\n"
"    to the Distutils commands specified on the command line.\n"
"\n"
"    Setup scripts will almost never instantiate Distribution directly,\n"
"    unless the 'setup()' function is totally inadequate to their needs.\n"
"    However, it is conceivable that a setup script might wish to subclass\n"
"    Distribution for some specialized purpose, and then pass the subclass\n"
"    to 'setup()' as the 'distclass' keyword argument.  If so, it is\n"
"    necessary to respect the expectations that 'setup' has of Distribution.\n"
"    See the code for 'setup()', in core.py, for details.\n"
"    "
msgstr ""

#. Default values for our command-line options
#: Lib/distutils/dist.py:99
msgid ""
"Construct a new Distribution instance: initialize all the\n"
"        attributes of a Distribution, and then use 'attrs' (a dictionary\n"
"        mapping attribute names to values) to assign some of those\n"
"        attributes their \"real\" values.  (Any attributes not mentioned in\n"
"        'attrs' will be assigned to some null value: 0, None, an empty list\n"
"        or dictionary, etc.)  Most importantly, initialize the\n"
"        'command_obj' attribute to the empty dictionary; this will be\n"
"        filled in with real command objects by 'parse_command_line()'.\n"
"        "
msgstr ""

#: Lib/distutils/dist.py:213
msgid ""
"Get the option dictionary for a given command.  If that\n"
"        command's option dictionary hasn't been created yet, then create it\n"
"        and return the new dictionary; otherwise, return the existing\n"
"        option dictionary.\n"
"        "
msgstr ""

#: Lib/distutils/dist.py:257
msgid ""
"Find as many configuration files as should be processed for this\n"
"        platform, and return a list of filenames in the order in which they\n"
"        should be parsed.  The filenames returned are guaranteed to exist\n"
"        (modulo nasty race conditions).\n"
"\n"
"        On Unix, there are three possible config files: pydistutils.cfg in\n"
"        the Distutils installation directory (ie. where the top-level\n"
"        Distutils __inst__.py file lives), .pydistutils.cfg in the user's\n"
"        home directory, and setup.cfg in the current directory.\n"
"\n"
"        On Windows and Mac OS, there are two possible config files:\n"
"        pydistutils.cfg in the Python installation directory (sys.prefix)\n"
"        and setup.cfg in the current directory.\n"
"        "
msgstr ""

#. We have to parse the command line a bit at a time -- global
#. options, then the first command, then its options, and so on --
#. because each command will be handled by a different class, and
#. the options that are valid for a particular class aren't known
#. until we have loaded the command class, which doesn't happen
#. until we know what the command is.
#: Lib/distutils/dist.py:336
msgid ""
"Parse the setup script's command line, taken from the\n"
"        'script_args' instance attribute (which defaults to 'sys.argv[1:]'\n"
"        -- see 'setup()' in core.py).  This list is first processed for\n"
"        \"global options\" -- options that set attributes of the Distribution\n"
"        instance.  Then, it is alternately scanned for Distutils commands\n"
"        and options for that command.  Each new command terminates the\n"
"        options for the previous command.  The allowed options for a\n"
"        command are determined by the 'user_options' attribute of the\n"
"        command class -- thus, we have to be able to load command classes\n"
"        in order to parse the command line.  Any error in that 'options'\n"
"        attribute raises DistutilsGetoptError; any error on the\n"
"        command-line raises DistutilsArgError.  If no Distutils commands\n"
"        were found on the command line, raises DistutilsArgError.  Return\n"
"        true if command-line were successfully parsed and we should carry\n"
"        on with executing commands; false if no errors but we shouldn't\n"
"        execute commands (currently, this only happens if user asks for\n"
"        help).\n"
"        "
msgstr ""

#. late import because of mutual dependence between these modules
#: Lib/distutils/dist.py:399
msgid ""
"Parse the command-line options for a single command.\n"
"        'parser' must be a FancyGetopt instance; 'args' must be the list\n"
"        of arguments, starting with the current command (whose options\n"
"        we are about to parse).  Returns a new version of 'args' with\n"
"        the next command at the front of the list; will be the empty\n"
"        list if there are no more commands on the command line.  Returns\n"
"        None if the user asked for help on this command.\n"
"        "
msgstr ""

#. late import because of mutual dependence between these modules
#: Lib/distutils/dist.py:502
msgid ""
"Show help for the setup script command-line in the form of\n"
"        several lists of command-line options.  'parser' should be a\n"
"        FancyGetopt instance; do not expect it to be returned in the\n"
"        same state, as its option table will be reset to make it\n"
"        generate the correct help text.\n"
"\n"
"        If 'global_options' is true, lists the global options:\n"
"        --verbose, --dry-run, etc.  If 'display_options' is true, lists\n"
"        the \"display-only\" options: --name, --version, etc.  Finally,\n"
"        lists per-command help for every command name or command class\n"
"        in 'commands'.\n"
"        "
msgstr ""

#: Lib/distutils/dist.py:551
msgid ""
"If there were any non-global \"display-only\" options\n"
"        (--help-commands or the metadata display options) on the command\n"
"        line, display the requested info and return true; else return\n"
"        false.\n"
"        "
msgstr ""

#: Lib/distutils/dist.py:586
msgid ""
"Print a subset of the list of all commands -- used by\n"
"        'print_commands()'.\n"
"        "
msgstr ""

#: Lib/distutils/dist.py:607
msgid ""
"Print out a help message listing all available commands with a\n"
"        description of each.  The list is divided into \"standard commands\"\n"
"        (listed in distutils.command.__all__) and \"extra commands\"\n"
"        (mentioned in self.cmdclass, but not a standard command).  The\n"
"        descriptions come from the command class attribute\n"
"        'description'.\n"
"        "
msgstr ""

#: Lib/distutils/dist.py:646
msgid ""
"Return the class that implements the Distutils command named by\n"
"        'command'.  First we check the 'cmdclass' dictionary; if the\n"
"        command is mentioned there, we fetch the class object from the\n"
"        dictionary and return it.  Otherwise we load the command module\n"
"        (\"distutils.command.\" + command) and fetch the command class from\n"
"        the module.  The loaded class is also stored in 'cmdclass'\n"
"        to speed future calls to 'get_command_class()'.\n"
"\n"
"        Raises DistutilsModuleError if the expected module could not be\n"
"        found, or if that module does not define the expected class.\n"
"        "
msgstr ""

#: Lib/distutils/dist.py:685
msgid ""
"Return the command object for 'command'.  Normally this object\n"
"        is cached on a previous call to 'get_command_obj()'; if no command\n"
"        object for 'command' is in the cache, then we either create and\n"
"        return it (if 'create' is true) or return None.\n"
"        "
msgstr ""

#: Lib/distutils/dist.py:713
msgid ""
"Set the options for 'command_obj' from 'option_dict'.  Basically\n"
"        this means copying elements of a dictionary ('option_dict') to\n"
"        attributes of an instance ('command').\n"
"\n"
"        'command_obj' must be a Commnd instance.  If 'option_dict' is not\n"
"        supplied, uses the standard option dictionary for this command\n"
"        (from 'self.command_options').\n"
"        "
msgstr ""

#: Lib/distutils/dist.py:737
msgid ""
"Reinitializes a command to the state it was in when first\n"
"        returned by 'get_command_obj()': ie., initialized but not yet\n"
"        finalized.  This provides the opportunity to sneak option\n"
"        values in programmatically, overriding or supplementing\n"
"        user-supplied values from the config files and command line.\n"
"        You'll have to re-finalize the command object (by calling\n"
"        'finalize_options()' or 'ensure_finalized()') before using it for\n"
"        real.  \n"
"\n"
"        'command' should be a command name (string) or command object.\n"
"        Returns the reinitialized command object.\n"
"        "
msgstr ""

#: Lib/distutils/dist.py:768
msgid ""
"Print 'msg' if 'level' is greater than or equal to the verbosity\n"
"        level recorded in the 'verbose' attribute (which, currently, can be\n"
"        only 0 or 1).\n"
"        "
msgstr ""

#: Lib/distutils/dist.py:777
msgid ""
"Run each command that was seen on the setup script command line.\n"
"        Uses the list of commands found and cache of command objects\n"
"        created by 'get_command_obj()'."
msgstr ""

#. Already been here, done that? then return silently.
#: Lib/distutils/dist.py:788
msgid ""
"Do whatever it takes to run a command (including nothing at all,\n"
"        if the command has already been run).  Specifically: if we have\n"
"        already created and run the command named by 'command', return\n"
"        silently without doing anything.  If the command named by 'command'\n"
"        doesn't even have a command object yet, create one.  Then invoke\n"
"        'run()' on that command object (or an existing one).\n"
"        "
msgstr ""

#: Lib/distutils/dist.py:846
msgid ""
"Dummy class to hold the distribution meta-data: name, version,\n"
"    author, and so forth."
msgstr ""

#: Lib/distutils/dist.py:910
msgid ""
"Convert a 4-tuple 'help_options' list as found in various command\n"
"    classes to the 3-tuple form required by FancyGetopt.\n"
"    "
msgstr ""

#: Lib/distutils/errors.py:16
msgid "The root of all Distutils evil."
msgstr ""

#: Lib/distutils/errors.py:20
msgid ""
"Unable to load an expected module, or to find an expected class\n"
"    within some module (in particular, command modules and classes)."
msgstr ""

#: Lib/distutils/errors.py:25
msgid ""
"Some command class (or possibly distribution class, if anyone\n"
"    feels a need to subclass Distribution) is found not to be holding\n"
"    up its end of the bargain, ie. implementing some part of the\n"
"    \"command \"interface."
msgstr ""

#: Lib/distutils/errors.py:32
msgid "The option table provided to 'fancy_getopt()' is bogus."
msgstr ""

#: Lib/distutils/errors.py:36
msgid ""
"Raised by fancy_getopt in response to getopt.error -- ie. an\n"
"    error in the command line usage."
msgstr ""

#: Lib/distutils/errors.py:41
msgid ""
"Any problems in the filesystem: expected file not found, etc.\n"
"    Typically this is for problems that we detect before IOError or\n"
"    OSError could be raised."
msgstr ""

#: Lib/distutils/errors.py:47
msgid ""
"Syntactic/semantic errors in command options, such as use of\n"
"    mutually conflicting options, or inconsistent options,\n"
"    badly-spelled values, etc.  No distinction is made between option\n"
"    values originating in the setup script, the command line, config\n"
"    files, or what-have-you -- but if we *know* something originated in\n"
"    the setup script, we'll raise DistutilsSetupError instead."
msgstr ""

#: Lib/distutils/errors.py:56
msgid ""
"For errors that can be definitely blamed on the setup script,\n"
"    such as invalid keyword arguments to 'setup()'."
msgstr ""

#: Lib/distutils/errors.py:61
msgid ""
"We don't know how to do something on the current platform (but\n"
"    we do know how to do it on some platform) -- eg. trying to compile\n"
"    C files on a platform not supported by a CCompiler subclass."
msgstr ""

#: Lib/distutils/errors.py:67
msgid ""
"Any problems executing an external program (such as the C\n"
"    compiler, when compiling C files)."
msgstr ""

#: Lib/distutils/errors.py:72
msgid ""
"Internal inconsistencies or impossibilities (obviously, this\n"
"    should never be seen if the code is working!)."
msgstr ""

#. Exception classes used by the CCompiler implementation classes
#: Lib/distutils/errors.py:77
msgid "Syntax error in a file list template."
msgstr ""

#: Lib/distutils/errors.py:82
msgid "Some compile/link operation failed."
msgstr ""

#: Lib/distutils/errors.py:85
msgid "Failure to preprocess one or more C/C++ files."
msgstr ""

#: Lib/distutils/errors.py:88
msgid "Failure to compile one or more C/C++ source files."
msgstr ""

#: Lib/distutils/errors.py:91
msgid ""
"Failure to create a static library from one or more C/C++ object\n"
"    files."
msgstr ""

#: Lib/distutils/errors.py:95
msgid ""
"Failure to link one or more C/C++ object files into an executable\n"
"    or shared library file."
msgstr ""

#: Lib/distutils/errors.py:99
msgid "Attempt to process an unknown file type."
msgstr ""

#: Lib/distutils/extension.py:24
msgid ""
"Just a collection of attributes that describes an extension\n"
"    module and everything needed to build it (hopefully in a portable\n"
"    way, but there are hooks that let you be as unportable as you need).\n"
"\n"
"    Instance attributes:\n"
"      name : string\n