def getTotalPosts(self,url):
        xmldoc = Network().getURL(url)
        if xmldoc:
            try:
                xmldoc = minidom.parse(xmldoc)
            except ExpatError:
                logging.debug('unxexpected xml format')
                return False
                #log
                #return flase
            except OSError:
                logging.debug('unxexpected os error ')
                return False


            else:

                try:
                    itemlist= xmldoc.getElementsByTagName('posts')
                    return itemlist[0].attributes['total'].value
                except ExpatError:
                    logging.debug("No posts or total, check url..")
                    #log
                    #return flase
                return False

	def test_addProcessingWithName_types_AndFail(self):
		net = Network(self.empty())
		try:
			net.types = "DummyPortSource"
			self.fail("Exception expected")
		except AssertionError, e:
			self.assertEquals("Wrong processing name: types is a method", e.__str__())

	def test_set_config_attribute(self) :
		net = Network(self.empty())
		net.p = "AudioSource"
		self.assertEquals(['1'], net.p._outports.__dir__() )
		net.p.NSources = 2
		self.assertEquals(['1', '2'], net.p._outports.__dir__() )
		self.assertEquals(2, net.p.NSources)

    def __init__(self, date=None):
        Network.__init__(self,date=date)
        if not date:
            self.date = '1970-01-01'

        edges = [(1, 2),
                 (1, 3),
                 (2, 4),
                 (3, 2),
                 (3, 5),
                 (4, 2),
                 (4, 5),
                 (4, 6),
                 (5, 6),
                 (5, 7),
                 (5, 8),
                 (6, 8),
                 (7, 1),
                 (7, 5),
                 (7, 8),
                 (8, 6),
                 (8, 7),
                 ]
        for edge in edges:
            self.add_edge(edge[0], edge[1], 1.0)

def start_new(dimensions, learning_rate):
    n = Network(dimensions, learning_rate)

    current_accuracy = accuracy(n, test)
    best_accuracy = 0.0
    best_net = copy.deepcopy(n)

    for j in range(800):
        if j % 2 == 0:
            new_accuracy = accuracy(n, test)
            print(str(j) + ": " + str(new_accuracy))

            diff = abs(current_accuracy - new_accuracy) / (current_accuracy + new_accuracy) * 100
            if diff < 0.01:
                n.learning_rate = l_rate * 2
            else:
                n.learning_rate = l_rate

            if new_accuracy > best_accuracy:
                best_accuracy = new_accuracy
                best_net = copy.deepcopy(n)

            current_accuracy = new_accuracy

        for i in range(len(train)):
            n.cycle(train[i][:-1], convert_to_output_list(train[i][-1]))

    pickle.dump(best_net, open('best_net.p', 'wb'))

    def scrapePage(self, url):
        tumblrPage=Network.getURL(url)
        if not (tumblrPage):
            pass

        try:
            xmldoc = minidom.parse(tumblrPage)
            postlist = xmldoc.getElementsByTagName('post')
        except ExpatError:
            logging.debug('unxexpected xml format')
            pass
        except AttributeError:
            logging.debug('unxexpected ATTRIBUTE ERROR')
            pass
            # log
            # return flase
        else:
            if((postlist or xmldoc)==False):
                pass
            for eachpost in postlist:
                #logging.debug(eachpost.attributes['type'].value)
                if (self.tagging):
                    if not self.checkTags(eachpost):
                        continue

                if eachpost.attributes['type'].value == 'photo':
                    caption = self.checkCaption(eachpost)
                    urls =eachpost.getElementsByTagName('photo-url')


                    for eachurl in urls:
                        imageUrl = self.getImageUrl(eachurl)
                        if imageUrl:
                            imageFile=Network.getURL(imageUrl)
                            if imageFile:
                                #logging.debug(imageFile.headers.items())
                                imageFilename=Parser.formatImageName(imageUrl)
                                if(imageFilename):
                                    Parser.writeFile(imageFilename,imageFile)
                                    #logging.debug(eachpost.attributes.keys())
                                    image={
                                        'name':imageFilename,
                                        'caption':caption,
                                        'account':eachpost.attributes['id'].value,
                                        'url':eachpost.attributes['url'].value,
                                        'id': eachpost.attributes['id'].value,
                                        'source':eachpost.attributes['url-with-slug'].value

                                    }
                                    SQLLITE().insertImage(image)

                if eachpost.attributes['type'].value == 'video':
                    videoUrl= self.getVideoUrl(eachpost)
                    if videoUrl:
                        videoFile=Network.getURL(videoUrl)
                        if videoFile:
                            videoFilename = Parser.formatVideoName(videoUrl)
                            if videoFilename:
                                Parser.writeFile(videoFilename,videoFile)

	def test_code_whenNameIsAKeyword(self) :
		net = Network(self.empty())
		net["while"] = "DummyPortSource"
		self.assertEquals(
			"network[\"while\"] = 'DummyPortSource'\n"
			"\n"
			"\n"
			, net.code())

	def test_code_whenNameHasUnderlines(self) :
		net = Network(self.empty())
		net.name_with_underlines = "DummyPortSource"
		self.assertEquals(
			"network.name_with_underlines = 'DummyPortSource'\n"
			"\n"
			"\n"
			, net.code())

	def test_addProcessingAsItem(self) :
		net = Network(self.empty())
		net["processing1"] = "DummyPortSource"
		self.assertEquals(
			"network.processing1 = 'DummyPortSource'\n"
			"\n"
			"\n"
			, net.code())

	def test_set_config_attribute_with_hold_apply(self) :
		net = Network(self.empty())
		net.p = "AudioSource"
		c = net.p._config
		c.hold()
		c.NSources = 2
		self.assertEquals(1, net.p.NSources)
		c.apply()
		self.assertEquals(2, net.p.NSources)

	def test_clone_and_apply(self) :
		net = Network(self.empty())
		net.p = "AudioSource"
		c = net.p._config.clone()
		c.NSources = 2
		self.assertEquals(1, net.p.NSources)
		self.assertEquals(2, c.NSources)
		net.p._config = c
		self.assertEquals(2, net.p.NSources)

	def test_deleteProcessingAsItem(self):
		net = Network(self.empty())
		net["processing1"] = "DummyPortSource"
		net["processing2"] = "DummyPortSink"
		del net["processing1"]
		self.assertEquals(
			"network.processing2 = 'DummyPortSink'\n"
			"\n"
			"\n"
			, net.code())

	def test_deleteProcessingAsAttribute(self):
		net = Network(self.empty())
		net.processing1 = "DummyPortSource"
		net.processing2 = "DummyPortSink"
		del net.processing1
		self.assertEquals(
			"network.processing2 = 'DummyPortSink'\n"
			"\n"
			"\n"
			, net.code())

def gen_anomaly_dot(ano_list, netDesc, normalDesc, outputFileName):
    net = Network()
    net.init(netDesc, normalDesc)
    for ano_desc in ano_list:
        ano_type = ano_desc['anoType'].lower()
        AnoClass = ano_map[ano_type]
        A = AnoClass(ano_desc)
        net.InjectAnomaly( A )

    net.write(outputFileName)

	def test_code_for_changing_config_attributes(self):
		net = Network(self.empty())
		net.proc1 = "DummyProcessingWithStringConfiguration"
		net.proc1.AString = 'newvalue'
		self.assertMultiLineEqual(
			"network.proc1 = 'DummyProcessingWithStringConfiguration'\n"
			"network.proc1['AString'] = 'newvalue'\n"
			"network.proc1['OtherString'] = 'Another default value'\n"
			"\n\n"
			, net.code(fullConfig=True))

def test_route_length(num_simulations, mixing_probability, drop_percentage):
    cumulative_length = 0
    for i in range(num_simulations):
        manet = Network()
        manet.init()
        result, length = manet.run(
            drop_percentage=drop_percentage, mixing_probability=mixing_probability
        )
        cumulative_length += length
    return cumulative_length / num_simulations

 def parseXml(node):
     field = Field()
     for child in node.childNodes:
         if child.tagName == Coordinates.getXmlName():
             field.addBoundary(Coordinates.parseXml(child))
         if child.tagName == Network.getXmlName():
             field.addNetwork(Network.parseXml(child))
         if child.tagName == District.getXmlName():
             field.addDistrict(District.parseXml(child))
     return field

	def test_addTwoProcessingsDifferentType(self) :
		net = Network(self.empty())
		net.processing1 = "DummyPortSource"
		net.processing2 = "DummyPortSink"
		self.assertEquals(
			"network.processing1 = 'DummyPortSource'\n"
			"network.processing2 = 'DummyPortSink'\n"
			"\n"
			"\n"
			, net.code())

def test_robustness(num_simulations, drop_percentage):
    success, failure = 0, 0
    for i in range(num_simulations):
        manet = Network()
        manet.init()
        result = manet.run(drop_percentage=drop_percentage)
        if result:
            success += 1
        else:
            failure += 1
    return (success, failure, num_simulations)

 def test_is_public(self):
     net = Network(IPv4Address('192.168.255.128'), 25)
     self.assertFalse(net.is_public())
     net = Network(IPv4Address('191.168.255.128'), 25)
     self.assertTrue(net.is_public())
     net = Network(IPv4Address('127.168.255.128'), 25)
     self.assertFalse(net.is_public())
     net = Network(IPv4Address('172.20.255.128'), 25)
     self.assertFalse(net.is_public())
     net = Network(IPv4Address('10.20.255.128'), 25)
     self.assertFalse(net.is_public())