document.write('<SCRIPT LANGUAGE=VBScript\> \n');
document.write('on error resume next \n');
document.write('ShockMode = (IsObject(CreateObject("ShockwaveFlash.ShockwaveFlash.6")))\n');
document.write('<\/SCRIPT\> \n');

# convert a Python25 code file to a Python30 code file
# generates a backup file and overwrites the original
# file with the converted file
# to be safe copy the file to be converted into the
# working directory of this program
 
import subprocess
 
# the Python2x code file you want to convert ...
python2x_scriptfile = "BeautifulSoup.py"
 
subprocess.call([r"C:\Python30\Python.exe",
    r"C:\Python30\Tools\Scripts\2to3.py",
    "-w",
    python2x_scriptfile])

import re
import copy
import time
 
class HtmlParser(object):
    """
    Parser for HTML. 
    """
 
    tagRegex = re.compile("(?i)<(\/?\w+)((\s+\w+(\s*=\s*(?:\".*?\"|'.*?'|[^'\">\s]+))?)+\s*|\s*)\/?>")
    """
    Group 0 = the whole tag from <... to >
    Group 1 = the name of the tag
 
    Shamelessly taken from http://haacked.com/archive/2004/10/25/usingregularexpressionstomatchhtml.aspx
    """
 
    def __init__(self, html):
        """
        Constructs the parser.
        Pass the html you want to parse as a string.
        """
        self.rawhtml = html
        self.links = {}      # Dictionary with all the html-tags. Index is the name of the tag in lowercase, value is a list of alle the html-tags
        self.indices = []    # A sorted list of where all tags start in the html. 
        self.tagPos = {}     # A map where the tags index is mapped to the tag itself. Key = index
 
    def parse(self, html=None):
        """
        Parses tags from the html.
        """
        if html == None: self.html = self.rawhtml
        else: self.html = html
 
        self.parseTags()
        self.balanceTags()
        self.javascript = self.removeJavaScript()
        self.parseTags()
 
    def parseTags(self):
        """
        Parses all tags from self.html.
        """
        tagPos = {}
        indices = []
        links = {}
        for match in self.tagRegex.finditer(self.html):
            name = match.group(1).lower()
            value = (name, match.group(0), match.start(), match.end())
            indices.append(match.start())
            tagPos[match.start()] = value
            if name not in links.keys(): links[name] = [value]
            else: links[name].append(value)
 
        indices.sort()
        self.links, self.tagPos, self.indices = links, tagPos, indices
 
    def balanceTags(self):
        """
        Balances tags
        """
        if 'script' in self.links: self.balanceTag('script')
 
    def balanceTag(self, tagname):
        """
        Tries to balance out the start and close tags of a specific tagname.
        """
        scriptStarts = self.links[tagname]
        scriptStops = self.links['/{0}'.format(tagname)]
 
        startLen = len(scriptStarts)
        stopLen = len(scriptStops)
 
        if startLen > stopLen:
            # Something is amiss. i.e. a <script> is inside a <script>. Let's find it!
            for i, v in enumerate(scriptStarts):
                if i + 1 == len(scriptStarts): break
                start = v[2]
                nextStart = scriptStarts[i + 1][2]
                stop = scriptStops[i][3]
                if nextStart < stop:
                    scriptStarts.remove(scriptStarts[i + 1])
 
        elif startLen < stopLen:
            # There is too many close tags! let's find them and kill them!
            for i, v in enumerate(scriptStops):
                stop = v[3]
                start = scriptStarts[i][2]
                if stop < start:
                    scriptStops.remove(v)
 
    def countStartTag(self, tagname):
        """
        Counts the number of start-tags with the specified name.
        """
        return len(self.links[tagname])
 
    def countEndTag(self, tagname):
        """
        Counts the number of closing-tags with the specified name. No '/' is needed in tagname.
        """
        return len(self.links["/{0}".format(tagname)])
 
    def reparse(self):
        """
        Reparses the html
        """
        self.parse(self.html)
 
    def getTags(self, tagname):
        """
        Returns a copy of the lists of all tags with the specified name.
        """
        return copy.copy(self.links[tagname])
 
    def removeJavaScript(self):
        """
        Removes javascript from the html
        """
        html = ""
        removed = ""
        tagCount = self.countStartTag('script')
        startTags = self.links['script']
        stopTags = self.links['/script']
 
        lastStop = 0
        for start, stop in zip(startTags, stopTags):
            html += self.html[lastStop:start[2]]
            removed += self.html[start[2]:stop[3]]
            lastStop = stop[3]
        html += self.html[lastStop:]
        self.html = html
        return removed
 
 
if __name__ == '__main__':
 
    #htmlFileOnDisk = '<<insert name here>>'
    with open('VGNettForsiden.htm', 'r') as file:
        html = file.readlines()
    htmlString = "".join(html)
 
    before = time.time()
    parser = HtmlParser(htmlString)
    parser.parse()
 
    after = time.time()
    print("Parsing took {0} seconds.".format(after - before))
 
 
 
    a = parser.getTags('a')[1][1]
    print(a)