out_file.write(b' \nend\n')
-def decode(in_file, out_file=None, mode=None, quiet=0):
+def decode(in_file, out_file=None, mode=None, quiet=False):
"""Decode uuencoded file"""
#
# Open the input file, if needed.
return s
def filterwarnings(action, message="", category=Warning, module="", lineno=0,
- append=0):
+ append=False):
"""Insert an entry into the list of warnings filters (at the front).
Use assertions to check that all arguments have the right type."""
else:
filters.insert(0, item)
-def simplefilter(action, category=Warning, lineno=0, append=0):
+def simplefilter(action, category=Warning, lineno=0, append=False):
"""Insert a simple entry into the list of warnings filters (at the front).
A simple filter matches all modules and messages.
url += quote(environ.get('SCRIPT_NAME') or '/')
return url
-def request_uri(environ, include_query=1):
+def request_uri(environ, include_query=True):
"""Return the full request URI, optionally including the query string"""
url = application_uri(environ)
from urllib.parse import quote
return 0
return 1
-def getDOMImplementation(name = None, features = ()):
+def getDOMImplementation(name=None, features=()):
"""getDOMImplementation(name = None, features = ()) -> DOM implementation.
Return a suitable DOM implementation. The name is either
def __bool__(self):
return True
- def toxml(self, encoding = None):
+ def toxml(self, encoding=None):
return self.toprettyxml("", "", encoding)
def toprettyxml(self, indent="\t", newl="\n", encoding=None):
# --- Utility functions
-def prepare_input_source(source, base = ""):
+def prepare_input_source(source, base=""):
"""This function takes an InputSource and an optional base URL and
returns a fully resolved InputSource object ready for reading."""
# by the way, if you don't understand what's going on in here,
# that's perfectly ok.
- def __init__(self, encoding=None, allow_none=0):
+ def __init__(self, encoding=None, allow_none=False):
self.memo = {}
self.data = None
self.encoding = encoding
# and again, if you don't understand what's going on in here,
# that's perfectly ok.
- def __init__(self, use_datetime=0):
+ def __init__(self, use_datetime=False):
self._type = None
self._stack = []
self._marks = []
#
# return A (parser, unmarshaller) tuple.
-def getparser(use_datetime=0):
+def getparser(use_datetime=False):
"""getparser() -> parser, unmarshaller
Create an instance of the fastest available parser, and attach it
# @return A string containing marshalled data.
def dumps(params, methodname=None, methodresponse=None, encoding=None,
- allow_none=0):
+ allow_none=False):
"""data [,options] -> marshalled data
Convert an argument tuple or a Fault instance to an XML-RPC
# (None if not present).
# @see Fault
-def loads(data, use_datetime=0):
+def loads(data, use_datetime=False):
"""data -> unmarshalled data, method name
Convert an XML-RPC packet to unmarshalled data plus a method
# that they can decode such a request
encode_threshold = None #None = don't encode
- def __init__(self, use_datetime=0):
+ def __init__(self, use_datetime=False):
self._use_datetime = use_datetime
self._connection = (None, None)
self._extra_headers = []
# @param verbose Debugging flag.
# @return Parsed response.
- def request(self, host, handler, request_body, verbose=0):
+ def request(self, host, handler, request_body, verbose=False):
#retry request once if cached connection has gone cold
for i in (0, 1):
try:
if i:
raise
- def single_request(self, host, handler, request_body, verbose=0):
+ def single_request(self, host, handler, request_body, verbose=False):
# issue XML-RPC request
try:
http_conn = self.send_request(host, handler, request_body, verbose)
the given encoding.
"""
- def __init__(self, uri, transport=None, encoding=None, verbose=0,
- allow_none=0, use_datetime=0):
+ def __init__(self, uri, transport=None, encoding=None, verbose=False,
+ allow_none=False, use_datetime=False):
# establish a "logical" server connection
# get the url
self.instance = instance
self.allow_dotted_names = allow_dotted_names
- def register_function(self, function, name = None):
+ def register_function(self, function, name=None):
"""Registers a function to respond to XML-RPC requests.
The optional name argument can be used to set a Unicode name
sys.stdout.buffer.write(response)
sys.stdout.buffer.flush()
- def handle_request(self, request_text = None):
+ def handle_request(self, request_text=None):
"""Handle a single XML-RPC request passed through a CGI post method.
If no XML data is given then it is read from stdin. The resulting
"""
def __init__(self, addr, requestHandler=DocXMLRPCRequestHandler,
- logRequests=1, allow_none=False, encoding=None,
+ logRequests=True, allow_none=False, encoding=None,
bind_and_activate=True):
SimpleXMLRPCServer.__init__(self, addr, requestHandler, logRequests,
allow_none, encoding, bind_and_activate)
class PyZipFile(ZipFile):
"""Class to create ZIP archives with Python library files and packages."""
- def writepy(self, pathname, basename = ""):
+ def writepy(self, pathname, basename=""):
"""Add all files from "pathname" to the ZIP archive.
If pathname is a package directory, search the directory and
projects / python / commitdiff