Call pywikibot.handle_args before jogobot.status

To prevent pywikibot outputting a warning because of creating site
objects before handling args

.gitignore

@@ -62,3 +62,5 @@ target/
 
 # Test
 test.py
+
+disabled

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "jogobot"]
+	path = jogobot
+	url = ../jogobot

charts.py

@@ -3,7 +3,15 @@
 #
 #  charts.py
 #
-#  Copyright 2015 GOLDERWEB – Jonathan Golder <jonathan@golderweb.de>
+#  original version by:
+#
+#  (C) Pywikibot team, 2006-2014 as basic.py
+#
+#  Distributed under the terms of the MIT license.
+#
+#  modified by:
+#
+#  Copyright 2016 GOLDERWEB – Jonathan Golder <jonathan@golderweb.de>
 #
 #  This program is free software; you can redistribute it and/or modify
 #  it under the terms of the GNU General Public License as published by
@@ -32,15 +40,19 @@ The following parameters are supported:
 
 -always           If given, request for confirmation of edit is short circuited
                   Use for unattended run
+-force-reload     If given, countrylists will be always parsed regardless if
+                  needed or not
 """
 
 
 import locale
+import os
+import sys
 
 import pywikibot
 from pywikibot import pagegenerators
-from pywikibot.bot import Bot
+
-import mwparserfromhell as mwparser
+import jogobot
 
 from summarypage import SummaryPage
 
@@ -55,10 +67,10 @@ class ChartsBot( ):
     """
     Bot which automatically updates a ChartsSummaryPage like
     [[Portal:Charts_und_Popmusik/Aktuelle_Nummer-eins-Hits]] by reading linked
-    CountryListsAn incomplete sample bot.
+    CountryLists
     """
 
-    def __init__( self, generator, always ):
+    def __init__( self, generator, always, force_reload ):
         """
         Constructor.
 
@@ -68,11 +80,20 @@ class ChartsBot( ):
         @param always: if True, request for confirmation of edit is short
                         circuited. Use for unattended run
         @type always: bool
+        @param force-reload: If given, countrylists will be always parsed
+                             regardless if needed or not
+        @type force-reload: bool
         """
 
         self.generator = generator
         self.always = always
 
+        # Force parsing of countrylist
+        self.force_reload = force_reload
+
+        # Output Information
+        jogobot.output( "Chartsbot invoked" )
+
         # Set the edit summary message
         self.site = pywikibot.Site()
         self.summary = "Bot: Aktualisiere Übersichtsseite Nummer-eins-Hits"
@@ -96,7 +117,7 @@ class ChartsBot( ):
         ################################################################
 
         # Initialise and treat SummaryPageWorker
-        sumpage = SummaryPage( text )
+        sumpage = SummaryPage( text, self.force_reload )
         sumpage.treat()
 
         # Check if editing is needed and if so get new text
@@ -104,7 +125,7 @@ class ChartsBot( ):
             text = sumpage.get_new_text()
 
         if not self.save(text, page, self.summary, False):
-            pywikibot.output(u'Page %s not saved.' % page.title(asLink=True))
+            jogobot.output(u'Page %s not saved.' % page.title(asLink=True))
 
     def load(self, page):
         """Load the text of the given page."""
@@ -112,11 +133,11 @@ class ChartsBot( ):
             # Load the page
             text = page.get()
         except pywikibot.NoPage:
-            pywikibot.output(u"Page %s does not exist; skipping."
+            jogobot.output( u"Page %s does not exist; skipping."
-                             % page.title(asLink=True))
+                            % page.title(asLink=True), "ERROR" )
         except pywikibot.IsRedirectPage:
-            pywikibot.output(u"Page %s is a redirect; skipping."
+            jogobot.output( u"Page %s is a redirect; skipping."
-                             % page.title(asLink=True))
+                            % page.title(asLink=True), "ERROR" )
         else:
             return text
         return None
@@ -126,13 +147,17 @@ class ChartsBot( ):
         """Update the given page with new text."""
         # only save if something was changed (and not just revision)
         if text != page.get():
+
+            # Show diff only in interactive mode or in verbose mode
+            if not self.always or pywikibot.config.verbose_output:
+
                 # Show the title of the page we're working on.
                 # Highlight the title in purple.
-            pywikibot.output(u"\n\n>>> \03{lightpurple}%s\03{default} <<<"
+                jogobot.output( u">>> \03{lightpurple}%s\03{default} <<<"
                                 % page.title())
                 # show what was changed
                 pywikibot.showDiff(page.get(), text)
-            pywikibot.output(u'Comment: %s' % comment)
+                jogobot.output(u'Comment: %s' % comment)
 
             if self.always or pywikibot.input_yn(
                     u'Do you want to accept these changes?',
@@ -143,17 +168,17 @@ class ChartsBot( ):
                     page.save(summary=comment or self.comment,
                               minor=minorEdit, botflag=botflag)
                 except pywikibot.LockedPage:
-                    pywikibot.output(u"Page %s is locked; skipping."
+                    jogobot.output( u"Page %s is locked; skipping."
-                                     % page.title(asLink=True))
+                                    % page.title(asLink=True), "ERROR" )
                 except pywikibot.EditConflict:
-                    pywikibot.output(
+                    jogobot.output(
                         u'Skipping %s because of edit conflict'
-                        % (page.title()))
+                        % (page.title()), "ERROR")
                 except pywikibot.SpamfilterError as error:
-                    pywikibot.output(
+                    jogobot.output(
                         u'Cannot change %s because of spam blacklist \
 entry %s'
-                        % (page.title(), error.url))
+                        % (page.title(), error.url), "ERROR")
                 else:
                     return True
         return False
@@ -168,9 +193,30 @@ def main(*args):
     @param args: command line arguments
     @type args: list of unicode
     """
+
     # Process global arguments to determine desired site
     local_args = pywikibot.handle_args(args)
 
+    # Get the jogobot-task_slug (basename of current file without ending)
+    task_slug = os.path.basename(__file__)[:-len(".py")]
+
+    # Before run, we need to check wether we are currently active or not
+    try:
+        # Will throw Exception if disabled/blocked
+        jogobot.is_active( task_slug )
+
+    except jogobot.jogobot.Blocked:
+        (type, value, traceback) = sys.exc_info()
+        jogobot.output( "\03{lightpurple} %s (%s)" % (value, type ),
+                        "CRITICAL" )
+
+    except jogobot.jogobot.Disabled:
+        (type, value, traceback) = sys.exc_info()
+        jogobot.output( "\03{red} %s (%s)" % (value, type ),
+                        "ERROR" )
+
+    # Bot/Task is active
+    else:
         # This factory is responsible for processing command line arguments
         # that are also used by other scripts and that determine on which pages
         # to work on.
@@ -181,11 +227,18 @@ def main(*args):
         # If always is True, bot won't ask for confirmation of edit (automode)
         always = False
 
+        # If force_reload is True, bot will always parse Countrylist regardless
+        # if parsing is needed or not
+        force_reload = False
+
         # Parse command line arguments
         for arg in local_args:
             if arg.startswith("-always"):
                 always = True
+            elif arg.startswith("-force-reload"):
+                force_reload = True
             else:
+                pass
                 genFactory.handleArg(arg)
 
         if not gen:
@@ -194,7 +247,8 @@ def main(*args):
             # The preloading generator is responsible for downloading multiple
             # pages from the wiki simultaneously.
             gen = pagegenerators.PreloadingGenerator(gen)
-        bot = ChartsBot(gen, always)
+            bot = ChartsBot(gen, always, force_reload)
+            if bot:
                 bot.run()
         else:
             pywikibot.showHelp()

countrylist.py

@@ -25,6 +25,7 @@
 Provides a class for handling charts list per country and year
 """
 
+import re
 import locale
 from datetime import datetime
 
@@ -66,7 +67,8 @@ class CountryList():
 
         # Check if page exits
         if not self.page.exists():
-            return False
+            raise CountryListError( "CountryList " +
+                                    str(wikilink.title) + " does not exists!" )
 
         # Initialise attributes
         __attr = (  "wikicode", "entry", "chartein", "_chartein_raw",
@@ -74,10 +76,12 @@ class CountryList():
         for attr in __attr:
             setattr( self, attr, None )
 
+        self.parsed = False
+
         # Try to find year
         self.find_year()
 
-    def parsing_needed( self, revid ):
+    def is_parsing_needed( self, revid ):
         """
         Check if current revid of CountryList differs from given one
 
@@ -94,22 +98,25 @@ class CountryList():
 
     def find_year( self ):
         """
-        Try to find the year related to CountryList
+        Try to find the year related to CountryList using regex
         """
-        self.year = datetime.now().year
+        match = re.search( r"^.+\((\d{4})\)", self.page.title() )
 
-        # Check if year is in page.title, if not try last year
+        # We matched something
-        if str( self.year ) not in self.page.title():
+        if match:
-            self.year -= 1
+            self.year = int(match.group(1))
-        # If last year does not match, raise YearError
+
-        if str( self.year ) not in self.page.title():
+        else:
-            raise CountryListYearError
+            raise CountryListError( "CountryList year is errorneous!" )
 
     def parse( self ):
         """
         Handles the parsing process
         """
 
+        # Set revid
+        self.revid = self.page.latest_revision_id
+
         # Parse page with mwparser
         self.generate_wikicode()
 
@@ -121,16 +128,19 @@ class CountryList():
         self.prepare_titel()
         self.prepare_interpret()
 
+        # For easy detecting wether we have parsed self
+        self.parsed = True
+
     def detect_belgian( self ):
         """
         Detect wether current entry is on of the belgian (Belgien/Wallonien)
         """
         # Check if begian province name is in link text or title
-        if "Wallonien" in str( self.wikilink.text ) \
+        if( "Wallonien" in str( self.wikilink.text ) or
-            or "Wallonien" in str( self.wikilink.title):
+            "Wallonien" in str( self.wikilink.title) ):
                 return "Wallonie"
-        elif "Flandern" in str( self.wikilink.text ) \
+        elif( "Flandern" in str( self.wikilink.text ) or
-            or "Flandern" in str( self.wikilink.title):
+              "Flandern" in str( self.wikilink.title) ):
                 return "Flandern"
         else:
             return None
@@ -151,23 +161,30 @@ class CountryList():
         # For belgian list we need to select subsection of country
         belgian = self.detect_belgian()
 
+        # Select Singles-Section
+        # Catch Error if we have none
+        try:
             if belgian:
                 singles_section = self.wikicode.get_sections(
                     matches=belgian )[0].get_sections( matches="Singles" )[0]
             else:
-            singles_section = self.wikicode.get_sections( matches="Singles" )[0]
+                singles_section = self.wikicode.get_sections(
+                    matches="Singles" )[0]
+
+        except IndexError:
+            raise CountryListError( "No Singles-Section found!")
 
         # Since we have multiple categories in some countrys we need
         # to select the first wrapping template
         try:
-            wrapping_template = next( singles_section.ifilter_templates(
+            wrapping = next( singles_section.ifilter_templates(
                 matches="Nummer-eins-Hits" ) )
         except StopIteration:
                 raise CountryListError( "Wrapping template is missing!")
 
         # Select the last occurence of template "Nummer-eins-Hits Zeile" in
         # Wrapper-template
-        for self.entry in wrapping_template.get("Inhalt").value.ifilter_templates(
+        for self.entry in wrapping.get("Inhalt").value.ifilter_templates(
                 matches="Nummer-eins-Hits Zeile" ):
                     pass
 
@@ -225,7 +242,15 @@ class CountryList():
         If param is not present raise Error
         """
         if self.entry.has( "Chartein" ):
-            self._chartein_raw = self.entry.get("Chartein").value.strip()
+            self._chartein_raw = self.entry.get("Chartein").value
+
+            # Remove possible ref-tags
+            for ref in self._chartein_raw.ifilter_tags(matches="ref"):
+                self._chartein_raw.remove( ref )
+
+            # Remove whitespace
+            self._chartein_raw = str(self._chartein_raw).strip()
+
         else:
             raise CountryListEntryError( "Template Parameter 'Chartein' is \
 missing!" )
@@ -239,6 +264,10 @@ missing!" )
         if not self._titel_raw:
             self.get_titel_value()
 
+        # Try to find a wikilink for Titel on countrylist
+        if "[[" not in self._titel_raw:
+            self.titel = self._search_links( str(self._titel_raw) )
+        else:
             self.titel = self._titel_raw
 
     def get_titel_value( self ):
@@ -247,7 +276,14 @@ missing!" )
         If param is not present raise Error
         """
         if self.entry.has( "Titel" ):
-            self._titel_raw = self.entry.get("Titel").value.strip()
+            self._titel_raw = self.entry.get("Titel").value
+
+            # Remove possible ref-tags
+            for ref in self._titel_raw.ifilter_tags(matches="ref"):
+                self._titel_raw.remove( ref )
+
+            # Remove whitespace
+            self._titel_raw = str(self._titel_raw).strip()
         else:
             raise CountryListEntryError( "Template Parameter 'Titel' is \
 missing!" )
@@ -293,31 +329,10 @@ missing!" )
                 parts.append( word )
                 parts.append( " " )
 
-        # If we have indexes with out links, search for links
+        # If we have indexes without links, search for links
         if indexes:
 
-            # Iterate over wikilinks of refpage and try to find related links
+            parts = self._search_links( parts, indexes )
-            for wikilink in self.wikicode.ifilter_wikilinks():
-
-                # Iterate over interpret names
-                for index in indexes:
-
-                    # Check wether wikilink matches
-                    if parts[index] == wikilink.text \
-                        or parts[index] == wikilink.title:
-
-                            # Overwrite name with complete wikilink
-                            parts[index] = str( wikilink )
-
-                            # Remove index from worklist
-                            indexes.remove( index )
-
-                            # Other indexes won't also match
-                            break
-
-                # If worklist is empty, stop iterating over wikilinks
-                if not indexes:
-                    break
 
             # Join the collected links
             sep = " "
@@ -333,11 +348,127 @@ missing!" )
         If param is not present raise Error
         """
         if self.entry.has( "Interpret" ):
-            self._interpret_raw = self.entry.get("Interpret").value.strip()
+            self._interpret_raw = self.entry.get("Interpret").value
+
+            # Remove possible ref-tags
+            for ref in self._interpret_raw.ifilter_tags(matches="ref"):
+                self._interpret_raw.remove( ref )
+
+            # Handle SortKeyName and SortKey
+            for template in self._interpret_raw.ifilter_templates(
+                    matches="SortKey" ):
+
+                if template.name == "SortKeyName":
+                    # Differing Link-Destination is provided as param 3
+                    if template.has(3):
+                        # Construct link out of Template, Params:
+                        # 1 = Surname
+                        # 2 = Name
+                        # 3 = Link-Dest
+                        interpret_link = mwparser.nodes.wikilink.Wikilink(
+                            str(template.get(3).value),
+                            str(template.get(1).value) + " " +
+                            str(template.get(2).value) )
+
+                    # Default Link-Dest [[Surname Name]]
+                    else:
+                        interpret_link = mwparser.nodes.wikilink.Wikilink(
+                            str(template.get(1).value) + " " +
+                            str(template.get(2).value) )
+
+                    # Replace Template with link
+                    self._interpret_raw.replace( template, interpret_link )
+
+                # SortKey
+                else:
+                    # Replace SortKey with text from param 2 if present
+                    if template.has(2):
+                        self._interpret_raw.replace( template,
+                                                     template.get(2).value)
+                    # Else Remove SortKey (text should follow behind SortKey)
+                    else:
+                        self._interpret_raw.replace( template, None)
+
+                # Normally won't be needed as there should be only one
+                # SortKey-Temlate but ... its a wiki
+                break
+
+            # Remove whitespace
+            self._interpret_raw = str(self._interpret_raw).strip()
         else:
             raise CountryListEntryError( "Template Parameter 'Interpret' is \
 missing!" )
 
+    def _search_links( self, keywords, indexes=None ):
+        """
+        Search matching wikilinks for keyword(s) in CountryList's wikicode
+
+        @param keywords: One or more keywords to search for
+        @type keywords: str, list
+        @param indexes: List with numeric indexes for items of keywords to work
+                        on only
+        @type indexes: list of ints
+        @return: List or String with replaced keywords
+        @return type: str, list
+        """
+
+        # Maybe convert keywords string to list
+        if( isinstance( keywords, str ) ):
+            keywords = [ keywords, ]
+            string = True
+        else:
+            string = False
+
+        # If indexes worklist was not provided, work on all elements
+        if not indexes:
+            indexes = list(range( len( keywords ) ))
+
+        # Iterate over wikilinks of refpage and try to find related links
+        for wikilink in self.wikicode.ifilter_wikilinks():
+
+            # Iterate over interpret names
+            for index in indexes:
+
+                # Check wether wikilink matches
+                if( keywords[index] == wikilink.text or
+                    keywords[index] == wikilink.title ):
+
+                    # Overwrite name with complete wikilink
+                    keywords[index] = str( wikilink )
+
+                    # Remove index from worklist
+                    indexes.remove( index )
+
+                    # Other indexes won't also match
+                    break
+
+            # If worklist is empty, stop iterating over wikilinks
+            if not indexes:
+                break
+
+        # Choose wether return list or string based on input type
+        if not string:
+            return keywords
+        else:
+            return str(keywords[0])
+
+    def __str__( self ):
+        """
+        Returns str repression for Object
+        """
+        if self.parsed:
+            return ("CountryList( Link = \"{link}\", Revid = \"{revid}\", " +
+                    "Interpret = \"{interpret}\", Titel = \"{titel}\", " +
+                    "Chartein = \"{chartein}\" )").format(
+                        link=repr(self.wikilink),
+                        revid=self.revid,
+                        interpret=self.interpret,
+                        titel=self.titel,
+                        chartein=repr(self.chartein))
+        else:
+            return "CountryList( Link = \"{link}\" )".format(
+                link=repr(self.wikilink))
+
 
 class CountryListError( Exception ):
     """
@@ -345,8 +476,104 @@ class CountryListError( Exception ):
     """
     pass
 
+
 class CountryListEntryError( CountryListError ):
     """
     Handles errors occuring in class CountryList related to entrys
     """
     pass
+
+
+class CountryListUnitTest():
+    """
+    Defines Test-Functions for CountryList-Module
+    """
+
+    testcases = ( { "Link": mwparser.nodes.Wikilink( "Benutzer:JogoBot/Charts/Tests/Liste der Nummer-eins-Hits in Frankreich (2015)" ),  # noqa
+                    "revid": 148453827,
+                    "interpret": "[[Adele (Sängerin)|Adele]]",
+                    "titel": "[[Hello (Adele-Lied)|Hello]]",
+                    "chartein": datetime( 2015, 10, 23 ) },
+                  { "Link": mwparser.nodes.Wikilink( "Benutzer:JogoBot/Charts/Tests/Liste der Nummer-eins-Hits in Belgien (2015)", "Wallonien"),  # noqa
+                    "revid": 148455281,
+                    "interpret": "[[Nicky Jam]] & [[Enrique Iglesias (Sänger)|Enrique Iglesias]]",  # noqa
+                    "titel": "El perdón",
+                    "chartein": datetime( 2015, 9, 12 ) } )
+
+    def __init__( self, page=None ):
+        """
+        Constructor
+        Set attribute page
+        """
+        if page:
+            self.page_link = mwparser.nodes.Wikilink( page  )
+        else:
+            self.page_link = None
+
+    def treat( self ):
+        """
+        Start testing either manually with page provided by cmd-arg page or
+        automatically with predefined test case
+        """
+        if self.page_link:
+            self.man_test()
+        else:
+            self.auto_test()
+
+    def auto_test( self ):
+        """
+        Run automatic tests with predefined test data from wiki
+        """
+
+        for case in type(self).testcases:
+
+            self.countrylist = CountryList( case["Link"] )
+
+            if( self.countrylist.is_parsing_needed( case["revid"] ) or not
+                self.countrylist.is_parsing_needed( case["revid"] + 1 ) ):
+                    raise Exception(
+                        "CountryList.is_parsing_needed() does not work!" )
+
+            self.countrylist.parse()
+
+            for key in case:
+
+                if key == "Link":
+                    continue
+
+                if not case[key] == getattr(self.countrylist, key ):
+                    raise Exception( key + " – " + str(
+                                     getattr(self.countrylist, key ) ))
+
+    def man_test( self ):
+        """
+        Run manual test with page given in parameter
+        """
+        self.countrylist = CountryList( self.page_link )
+
+        self.countrylist.parse()
+
+        print( self.countrylist )
+        print( "Since we have no data to compare, you need to manually " +
+               "check data above against given page to ensure correct " +
+               "working of module!" )
+
+
+def main(*args):
+    """
+    Handling direct calls --> unittest
+    """
+    # Process global arguments to determine desired site
+    local_args = pywikibot.handle_args(args)
+
+    # Parse command line arguments
+    for arg in local_args:
+        if arg.startswith("-page:"):
+            page = arg[ len("-page:"): ]
+
+    # Call unittest-class
+    test = CountryListUnitTest( page )
+    test.treat()
+
+if __name__ == "__main__":
+    main()

summarypage.py

@@ -25,44 +25,56 @@
 Provides classes for handling Charts summary page
 """
 
-import locale
 from datetime import datetime, timedelta
 
-import pywikibot
+# import pywikibot
 import mwparserfromhell as mwparser
 
 from countrylist import CountryList, CountryListError
 
+
 class SummaryPage():
     """
     Handles summary page related actions
     """
 
-    def __init__( self, text ):
+    def __init__( self, text, force_reload=False ):
         """
         Create Instance
+
+        @param text: Page Text of summarypage
+        @type text: str
+        @param force-reload: If given, countrylists will be always parsed
+                             regardless if needed or not
+        @type force-reload: bool
+
         """
 
         # Parse Text with mwparser
         self.wikicode = mwparser.parse( text )
 
+        # Force parsing of countrylist
+        self.force_reload = force_reload
+
     def treat( self ):
         """
         Handles parsing/editing of text
         """
 
         # Get mwparser.template objects for Template "/Eintrag"
-        for entry in self.wikicode.filter_templates( matches="/Eintrag" ) :
+        for entry in self.wikicode.filter_templates( matches="/Eintrag" ):
 
             # Instantiate SummaryPageEntry-object
-            summarypageentry = SummaryPageEntry( entry )
+            summarypageentry = SummaryPageEntry(entry,
+                                                force_reload=self.force_reload)
+
             # Treat SummaryPageEntry-object
             summarypageentry.treat()
 
             # Get result
             # We need to replace origninal entry since objectid changes due to
             # recreation of template object and reassignment won't be reflected
-            self.wikicode.replace( entry, summarypageentry.new_entry.template )
+            self.wikicode.replace(entry, summarypageentry.get_entry().template)
 
     def get_new_text( self ):
         """
@@ -85,18 +97,31 @@ class SummaryPageEntry():
 
     write_needed = False
 
-    def __init__( self, entry ):
+    def __init__( self, entry, force_reload=False ):
         """
         Constructor
+
+        @param entry: Entry template of summarypage entry
+        @type text: mwparser.template
+        @param force-reload: If given, countrylists will be always parsed
+                             regardless if needed or not
+        @type force-reload: bool
         """
         self.old_entry = SummaryPageEntryTemplate( entry )
         self.new_entry = SummaryPageEntryTemplate( )
 
+        # Force parsing of countrylist
+        self.force_reload = force_reload
+
     def treat( self ):
         """
         Controls parsing/update-sequence of entry
         """
-        self.parse()
+        # Get CountryList-Object
+        self.get_countrylist()
+
+        # Check if parsing country list is needed
+        if( self.countrylist.parsed):
 
             self.correct_chartein()
 
@@ -104,9 +129,9 @@ class SummaryPageEntry():
 
         self.is_write_needed()
 
-    def parse( self ):
+    def get_countrylist( self ):
         """
-        Handles parsing process of entry template
+        Get the CountryList-Object for current entry
         """
 
         # Get wikilink to related countrylist
@@ -115,44 +140,61 @@ class SummaryPageEntry():
         # Get saved revision of related countrylist
         self.get_countrylist_saved_revid()
 
-
         # Get current year
-        current_year = datetime.now().year;
+        current_year = datetime.now().year
-
-        # Store old link.title
-        link_title = self.countrylist_wikilink.title
 
         # If list is from last year, replace year
-        if (current_year - 1) in link_title:
+        if (current_year - 1) in self.countrylist_wikilink.title:
-            self.countrylist_wikilink.title.replace( (current_year - 1), current_year )
+            self.countrylist_wikilink.title.replace( (current_year - 1),
+                                                     current_year )
 
         # Try to get current years list
         try:
             self.countrylist = CountryList( self.countrylist_wikilink )
 
-            if self.countrylist:
+            self.maybe_parse_countrylist()
-                self.countrylist.parse()
 
         # Maybe fallback to last years list
         except CountryListError:
 
-            self.countrylist_wikilink.title = link_title
+            # If list is from last year, replace year
+            if (current_year ) in self.countrylist_wikilink.title:
+                self.countrylist_wikilink.title.replace( current_year,
+                                                         (current_year - 1) )
+
             self.countrylist = CountryList( self.countrylist_wikilink )
 
-            if self.countrylist:
+            self.maybe_parse_countrylist()
-                self.countrylist.parse()
+
-            else:
+            if not self.countrylist:
                 raise SummaryPageEntryError( "CountryList does not exists!" )
 
+    def maybe_parse_countrylist( self ):
+        """
+        Parse countrylist if page-object exists and if parsing is needed or
+        param -force-reload is set
+        """
+
+        # Fast return if no countrylist-object
+        if not self.countrylist:
+            return
+
+        # Parse if needed or forced
+        if( self.countrylist.is_parsing_needed( self.countrylist_revid ) or
+            self.force_reload ):
+                self.countrylist.parse()
+
     def get_countrylist_wikilink( self ):
         """
         Load wikilink to related countrylist
         """
         if self.old_entry.Liste:
             try:
-                self.countrylist_wikilink = next( self.old_entry.Liste.ifilter_wikilinks() )
+                self.countrylist_wikilink = next(
+                    self.old_entry.Liste.ifilter_wikilinks() )
             except StopIteration:
-                raise SummaryPageEntryError( "Parameter Liste does not contain valid wikilink!")
+                raise SummaryPageEntryError(
+                    "Parameter Liste does not contain valid wikilink!" )
         else:
             raise SummaryPageEntryError( "Parameter Liste is not present!")
 
@@ -161,7 +203,7 @@ class SummaryPageEntry():
         Load saved revid of related countrylist if Param is present
         """
         if self.old_entry.Liste_Revision:
-            self.countrylist_revid = int( self.old_entry.Liste_Revision.strip())
+            self.countrylist_revid = int(self.old_entry.Liste_Revision.strip())
         else:
             self.countrylist_revid = 0
 
@@ -171,7 +213,8 @@ class SummaryPageEntry():
         """
 
         self.new_entry.Liste = self.countrylist_wikilink
-        self.new_entry.Liste_Revision = self.countrylist.page.latest_revision_id
+        self.new_entry.Liste_Revision = \
+            self.countrylist.page.latest_revision_id
         self.new_entry.Interpret = self.countrylist.interpret
         self.new_entry.Titel = self.countrylist.titel
         self.new_entry.Chartein = self._corrected_chartein
@@ -210,9 +253,20 @@ class SummaryPageEntry():
         Detects wether writing of entry is needed and stores information in
         Class-Attribute
         """
-        type( self ).write_needed = ( ( self.old_entry != self.new_entry ) or \
+        type( self ).write_needed = ( ( self.old_entry != self.new_entry ) and
+                                      self.countrylist.parsed or
                                       type( self ).write_needed )
 
+    def get_entry( self ):
+        """
+        Returns the new entry if CountryList was parsed otherwise returns the
+        old one
+        """
+        if( self.countrylist.parsed):
+            return self.new_entry
+        else:
+            return self.old_entry
+
 
 class SummaryPageEntryTemplate():
     """
@@ -229,8 +283,8 @@ class SummaryPageEntryTemplate():
         Creates Instance of Class for given mwparser.template object of
         SummmaryPageEntry Template. If no object was given create empty one.
 
-        @param    template_obj    mw.parser.template   Object of
+        @param template_obj Object of SummmaryPageEntry Template
-                                  SummmaryPageEntry Template
+        @type template_obj: mwparser.template
         """
 
         # Check if object was given
@@ -240,25 +294,25 @@ class SummaryPageEntryTemplate():
             if isinstance( template_obj,
                            mwparser.nodes.template.Template ):
 
-                self.template = template_obj;
+                self.template = template_obj
-                self.__initial = False;
+                self.__initial = False
 
             # Otherwise raise error
             else:
-                raise SummaryPageEntryTemplateError( "Wrong type given" );
+                raise SummaryPageEntryTemplateError( "Wrong type given" )
 
         # Otherwise initialise template
         else:
             self.__initial_template()
-            self.__initial = True;
+            self.__initial = True
 
     def __initial_template( self ):
         """
         Builds the initial template
         """
 
-        self.template = next( mwparser.parse(
+        self.template = next( mwparser.parse( "{{Portal:Charts und Popmusik/\
-"{{Portal:Charts und Popmusik/Aktuelle Nummer-eins-Hits/Eintrag|Liste=|Liste_Revision=|Interpret=|Titel=NN\
+Aktuelle Nummer-eins-Hits/Eintrag|Liste=|Liste_Revision=|Interpret=|Titel=NN\
 |Chartein=|Korrektur=|Hervor=}}" ).ifilter_templates() )
 
     def __getattr__( self, name ):
@@ -302,7 +356,7 @@ class SummaryPageEntryTemplate():
             cmpto = self
         else:
             raise SummaryPageEntryTemplateError(
-"One of the compared instances must have been initial!" )
+                "One of the compared instances must have been initial!" )
 
         # Iterate over each param
         for param in initial.template.params:
@@ -319,8 +373,8 @@ class SummaryPageEntryTemplate():
                 continue
 
             # Compare other param values, if one unequal write is needed
-            if initial.template.get( param ).value.strip() != \
+            if( initial.template.get( param ).value.strip() !=
-                cmpto.template.get( param ).value.strip():
+                cmpto.template.get( param ).value.strip() ):
                     return True
 
         # If not returned True until now
@@ -333,12 +387,14 @@ class SummaryPageError( Exception ):
     """
     pass
 
+
 class SummaryPageEntryError( SummaryPageError ):
     """
     Handles errors occuring in class SummaryPageEntry
     """
     pass
 
+
 class SummaryPageEntryTemplateError( SummaryPageError ):
     """
     Handles errors occuring in class SummaryPageEntryTemplate