def __init__(self):
		ContentHandler.__init__(self)
		self.isItem = False
		self.isTitle = False
		self.isLink = False
		self.tuples = []
		self.ndx = 0

 def __init__(self):
     ContentHandler.__init__(self)
     self.__level = -1
     self.__main_menus = []
     self.__parent_menus = []
     self.__actions_specs = []
     self.__menuItem = None

 def __init__(self):
     ContentHandler.__init__(self)  # can't use super() here !?
     self.modelVariables = []
     self.ruleConstants = []
     self.moleculeConstants = []
     self.rewardConstants = []
     self.switch1 = ""
     self.switch2 = ""

 def __init__(self):
     ContentHandler.__init__(self)
     self.__inItem = False
     self.__inTitle = False
     self.__inIssued = False
     self.title = ""
     self.issued = ""
     self.entries = []

 def __init__(self):
     """
    @param override: erase existing database?
    """
     ContentHandler.__init__(self)
     self.tag = "row"
     self.answer_type = "2"
     self.question_type = "1"
     self.on_post = []

 def __init__(self):
     ContentHandler.__init__(self)
     self.chars = u""
     self.currentTag = None
     self.rootObject = None
     self.objectPath = []
     self.styles = {}
     self.schemas = {}
     self.resources = set()

# This class is used to parse the /mobiledevices list to get all of the ids and usernames
class CasperMobileDeviceListHandler(ContentHandler):
	def __init__(self, grabber, deviceMap, unmanagedDeviceMap):
		ContentHandler.__init__(self)
		self.grabber = grabber
		self.deviceMap = deviceMap
		self.unmanagedDeviceMap = unmanagedDeviceMap
		self.currentID = ""
		self.inID = False

    def __init__(self, handler):
        ContentHandler.__init__(self)

        # get a logger
        self.__logger = logging.getLogger("chattest.common.MessageParser")
        self.__logger.debug("Created a new MessageParser object...")

        # init member variables
        self.__handler = handler
        self.__state = []
        self.__message = ""

 def __init__(self):
     ContentHandler.__init__(self)
     self.current_track = None   # holds data for the current track
     self.parsed = {}      # holds all tracks
     self.content = ""     # accumulator for character data
     self.numeric = re.compile('\d+\.?\d*$')   
     self.float_required = ['file_size', 'duration', 'overall_bit_rate', 'stream_size', 
                            'ID',  'file_size', 'bit_rate', 'width', 'height', 
                            'frame_rate', 'resolution', 'bit_depth', 'delay',]
     # duration is in milliseconds, we want seconds
     self.conversions = { 'duration': lambda x: str(float(x)/1000.) }  

    def __init__(self, parameters_dictionary, parameter_set_name):
        self.parameters_dictionary = parameters_dictionary

#        self.expected_parameters_name = parameters_name
#        self.has_expected_parameters_name = False

        self.expected_parameter_set_name = parameter_set_name
        self.has_expected_parameter_set_name = False
        
#        super(ParamsXMLReader, self).__init__() # doesn't work! Use below instead.
        ContentHandler.__init__(self)

 def __init__(self, env={}):
   ContentHandler.__init__(self)
   # output file
   self.out = StringIO()
   # stack of (action, environment, release tag) for each current context
   self.stack = [('', env, '')]
   # stack of (id, tag) for each tag. Used to match tags on self.stack
   self.tag_stack = []
   # flag when we are in a singleton tag
   # used by self.showStartElement(), self.showEndElement
   self.singleton = False

    def __init__(self, content):
        ContentHandler.__init__(self)

        self.content = False
        self.tree = []
        self.stack = []
        self.stack_usage = []

        self.strong = False
        self.emphasis = False

        saxify(content, self)

 def __init__(self):
     ContentHandler.__init__(self)
     self.rootAttributes = None
     self.__parser = make_parser()
     # Init the parser's handlers
     self.restoreParser()
     # No container at this time
     self.__container = None
     # Reset all the containers, to make sure previous runs don't leave
     # garbage data
     for container in self.container_dispatch.values():
         container.reset()

	def __init__(self):
		ContentHandler.__init__(self)
		
		self.map = Map()
		
		self.dataBuffer = ''
		self.dataEncoding = ''
		
		self.inMap = False
		self.inTileset = False
		self.inLayer = False
		self.inData = False
		self.inProperties = False

 def __init__(self, delegate):
     ContentHandler.__init__(self)
     self.currentTag = ''
     self.currentChannel = ''
     self.event = ''
     self.horizontalUnit = ''
     self.verticalUnit = ''
     self.eventTime = ''
     self.chanData = {}
     self.chanData['CHN1'] = {}
     self.chanData['CHN2'] = {}
     self.chanData['CHN3'] = {}
     self.chanData['CHN4'] = {}
     self.numEvents = 0
     self.delegate = delegate

	def __init__(self, output_file, limit = 0, random_mode = False):
		ContentHandler.__init__(self)
		self.total = 0
		self.processed = 0
		self.skipped = 0
		self.skip_version = 0
		self.error = 0
		self.limit = limit
		self.current_node = None
		self.current_title = None
		self.page_body = []
		self.random_mode = random_mode
		self.version_store = WiktionaryVersionStore('version.txt')
		self.writer = codecs.open(output_file, 'w', 'utf-8')
		logging_stream = codecs.open('wiktionary-error.log', 'w', 'utf-8')
		logging.basicConfig(stream=logging_stream, level=logging.DEBUG)

 def __init__(self, name, value):
     """ Constructor.
     
     name - name of searched attribute
     value - searched value of attribute of given name
     
     """
     # Flag indicating if searched projection has been found
     self.__is_proj = 0
     # Searched parameter name, attribute (epsg|name)
     self.__lookup_name = name
     # Searched parameter value (epsg id or name)
     self.__lookup_value = value
     #Projection definition
     self.__proj_def = ProjectionDef()
     
     ContentHandler.__init__(self)

	def __init__(self):
		ContentHandler.__init__(self)
		BoilerpipeBaseParser.__init__(self)

 def __init__( self, tagName ):
    """Initialize ContentHandler and set tag to search for"""
    
    ContentHandler.__init__( self )
    self.tagName = tagName
    self.depth = 0 # spaces to indent to show structure

	def __init__(self):
		ContentHandler.__init__(self)
		self._fonts = {}