You can use a combination of ElementTree's fromstring() method and the requests module's requests.get() to accomplish this.

https://docs.python.org/2/library/xml.etree.elementtree.html#parsing-xml

fromstring() parses XML from a string directly into an Element, which is the root element of the parsed tree.

Install the requests module:

pip install requests

Use the requests.get() to get your xml file from the url as a string. Pass that into the fromstring() function.

import xml.etree.cElementTree as ET
import requests
tree = ET.fromstring(requests.get('http://synd.cricbuzz.com/j2me/1.0/livematches.xml').text)
for child in tree:
   print("%s - %s"%(child.get('srs'),child.get('mchDesc')))

Results:

None - None
India tour of Sri Lanka, 2015 - Cricbuzz Cup - SL vs IND
Australia tour of Ireland, 2015 - IRE vs AUS
New Zealand tour of South Africa, 2015 - RSA vs NZ
Royal London One-Day Cup, 2015 - SUR vs KENT
Royal London One-Day Cup, 2015 - ESS vs YORKS

You can use urllib2 to download and parse the file in the same way. For e.g. the first few lines will be changed to:

import xml.etree.cElementTree as ET
import urllib2

for i in range(3):
    tree = ET.ElementTree(file=urllib2.urlopen('http://www.trion%i.com:6060/stat.xml' % i ))


    root = tree.getroot()
    root.tag, root.attrib

    # Rest of your code goes here....

Inside the response element there's a row element, so your for loop should be in root[0] instead of root

Here's an example from your snippet, hope it helps you understand the issue

import xml.etree.ElementTree as ET
tree = ET.parse('rows.xml')
root = tree.getroot()

for _id in root[0].findall('row'):
    rank = _id.find('ethcty').text
    name = _id.find('cnt').text
    print(name, rank)

Also, findall should be the name of the node you want

As for loading directly from the url you should use the urllib as follows:

from urllib.request import urlopen
import xml.etree.ElementTree as ET

with urlopen('https://data.cityofnewyork.us/api/views/25th-nujf/rows.xml') as f:
    tree = ET.parse(f)
    root = tree.getroot()

    for _id in root[0].findall('row'):
        rank = _id.find('ethcty').text
        name = _id.find('cnt').text
        print(name, rank)

I edited the latter code because I forgot about the loading from the URL part of your question, i'm sorry about that

You can parse the text as a string, which creates an Element, and create an ElementTree using that Element.

import xml.etree.ElementTree as ET
tree = ET.ElementTree(ET.fromstring(xmlstring))

I just came across this issue and the documentation, while complete, is not very straightforward on the difference in usage between the parse() and fromstring() methods.

Before I try to answer, a tip. Your exception handler covers up the nature of the problem. Just let the original exception rise up and you'll have more information to share with people who are interested in helping you.

I like to use feedparser to parse Atom feeds. It does indeed give you dict-like objects. I submitted a patch to feedparser 4.1 to parse the GeoRSS elements into GeoJSON style dicts. See https://code.google.com/p/feedparser/issues/detail?id=62 and blog post at http://sgillies.net/blog/566/georss-patch-for-universal-feedparser/. You'd use it like this:

>>> import feedparser
>>> feed = feedparser.parse("http://earthquake.usgs.gov/earthquakes/catalogs/1hour-M1.xml")
>>> feed.entries[0]['where']
{'type': 'Point', 'coordinates': (-122.8282, 38.844700000000003)}

My patched version of 4.1 is in my Dropbox and you can get it using pip.

$ pip install http://dl.dropbox.com/u/10325831/feedparser-4.1-georss.tar.gz

Or just download and install with "python setup.py install".

From ElementTree docs:

We can import this data by reading from a file:

import xml.etree.ElementTree as ET

tree = ET.parse('country_data.xml')
root = tree.getroot()

Or directly from a string:

root = ET.fromstring(country_data_as_string)

and later in the same page, 20.5.1.4. Finding interesting elements:

for neighbor in root.iter('neighbor'):
    print(neighbor.attrib)

Which translate to:

import xml.etree.ElementTree as ET

root = ET.fromstring("""
<root>
<H D="14/11/2017">
<FC>
    <F LV="0">The quick</F>
    <F LV="1">brown</F>
    <F LV="2">fox</F>
</FC>
</H>
<H D="14/11/2017">
<FC>
    <F LV="0">The lazy</F>
    <F LV="1">fox</F>
</FC>
</H>
</root>""")
# root = tree.getroot()
for h in root.iter("H"):
    print (h.attrib["D"])
for f in root.iter("F"):
    print (f.attrib, f.text)

output:

14/11/2017
14/11/2017
{'LV': '0'} The quick
{'LV': '1'} brown
{'LV': '2'} fox
{'LV': '0'} The lazy
{'LV': '1'} fox

Your problem starts with naming things properly:

xml = requests.Session().get(url.xml)

requests.get() does not return XML. It returns a response.

resp = requests.Session().get(url.xml)

And this response might contain text (i.e. a string):

print(resp.text)

And this string might be XML, which ElementTree can convert into a tree:

tree = ET.fromstring(resp.text)

which we then can use to obtain information:

tree.find('entry')

which returns None, because in this case the XML is in a namespace (xmlns="..."), and that namespace is http://uniprot.org/uniprot. We must mention that when we search for elements:

tree.find('{http://uniprot.org/uniprot}entry')

which is unwieldy to write. So we make an abbreviation:

xml_ns = {
    'up': 'http://uniprot.org/uniprot'
}

and use that instead:

tree.find('up:entry', xml_ns)

which now prints

<Element '{http://uniprot.org/uniprot}entry' at 0x03C0AD80>

Using all this, we get:

import requests
import xml.etree.ElementTree as ET

xml_url = 'https://www.uniprot.org/uniprot/P0AES4.xml'
xml_ns = {
    'up': 'http://uniprot.org/uniprot'
}

resp = requests.get(xml_url)
tree = ET.fromstring(resp.text)

def get_text(node):
    return node.text if node is not None else None

for entry in tree.findall('./up:entry', xml_ns):
    data = {
        'accession': get_text( entry.find('./up:accession', xml_ns) )
        # find and add more items
    }

    print(data)

which prints

{'accession': 'P0AES4'}

You need to give the .find(), findall() and iterfind() methods an explicit namespace dictionary:

namespaces = {'owl': 'http://www.w3.org/2002/07/owl#'} # add more as needed

root.findall('owl:Class', namespaces)

Prefixes are only looked up in the namespaces parameter you pass in. This means you can use any namespace prefix you like; the API splits off the owl: part, looks up the corresponding namespace URL in the namespaces dictionary, then changes the search to look for the XPath expression {http://www.w3.org/2002/07/owl}Class instead. You can use the same syntax yourself too of course:

root.findall('{http://www.w3.org/2002/07/owl#}Class')

Also see the Parsing XML with Namespaces section of the ElementTree documentation.

As of Python 3.8, the ElementTree library also understands the {*} namespace wildcard, so root.findall('{*}Class') would also work (but don't do that if your document can have multiple namespaces that define the Class element).

If you can switch to the lxml library things are better; that library supports the same ElementTree API, but collects namespaces for you in .nsmap attribute on elements and generally has superior namespaces support.

ElementTree can be tricky when namespaces are involved. The element you are looking for are named <gml:lowerCorner> and <gml:upperCorner>. Searching higher in the XML data, gml is defined as an XML namespace: xmlns:gml="http://www.opengis.net/gml". The way to find a subelement of the XML tree is as follows:

from xml.etree import ElementTree as ET
tree = ET.parse('file.xml')
print tree.find('//{http://www.opengis.net/gml}lowerCorner').text
print tree.find('//{http://www.opengis.net/gml}upperCorner').text

Output

137796 483752
138178 484222

Explanation

Using ElementTree's XPath support, // selects all subelements on all levels of the tree. ElementTree uses {url}tag notation for a tag in a specific namespace. gml's URL is http://www.opengis.net/gml. .text retrieves the data in the element.

Note that // is a shortcut to finding a nested node. The full path of upperCorner in ElementTree's syntax is actually:

{http://www.kadaster.nl/schemas/klic/20080722/leveringsinfo}Pngformaat/{http://www.kadaster.nl/schemas/klic/20080722/leveringsinfo}OmsluitendeRechthoek/{http://www.opengis.net/gml}Envelope/{http://www.opengis.net/gml}upperCorner

If you are sure of the encoding, you can use open() to read the file into a string, and then use ElementTree.fromstring() to convert that string into an XML document.

with open("input.xml", encoding="Windows-1252") as fp:
    xml_string = fp.read()
    tree = ElementTree.fromstring(xml_string)

This will ignore the XML declaration, since the file is already decoded, albeit manually. For normal/compliant XML documents, this method is not recommended and you should use ElementTree.parse('filename') instead.