added PKG-INFO file from upstream tarball

[python-simplemediawiki.debian] / simplemediawiki.py

diff --git a/simplemediawiki.py b/simplemediawiki.py
index 71bc4fd940f9e5538a28a9dcddc39f9f4666bf0c..ab0f3f7d69b82b8e31cb6a279d54cf87ca24daae 100644 (file)
--- a/simplemediawiki.py
+++ b/simplemediawiki.py
@@ -46,31 +46,87 @@ class MediaWiki():
 
     api_url: URL to api.php (usually similar to http://example.com/w/api.php)
     """
-    _cj = cookielib.CookieJar()
     _high_limits = None
     _namespaces = None
     _psuedo_namespaces = None
+    _mediawiki_version = None
 
-    def __init__(self, api_url):
+    def __init__(self, api_url, cookie_file=None, user_agent=DEFAULT_UA):
         self._api_url = api_url
+        if cookie_file:
+            self._cj = cookielib.MozillaCookieJar(cookie_file)
+            try:
+                self._cj.load()
+            except IOError:
+                self._cj.save()
+                self._cj.load()
+        else:
+            self._cj = cookielib.CookieJar()
+        self._opener = urllib2.build_opener(
+                urllib2.HTTPCookieProcessor(self._cj)
+        )
+        self._opener.addheaders = [('User-agent', user_agent)]
 
-    def call(self, params):
-        """
-        Make a call to the wiki. Returns a dictionary that represents the JSON
-        returned by the API.
-        """
-        params['format'] = 'json'
-        opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(self._cj))
-        request = urllib2.Request(self._api_url, urllib.urlencode(params))
+    def _fetch_http(self, url, params):
+        request = urllib2.Request(url, urllib.urlencode(params))
         request.add_header('Accept-encoding', 'gzip')
-        response = opener.open(request)
+        response = self._opener.open(request)
+        if isinstance(self._cj, cookielib.MozillaCookieJar):
+            self._cj.save()
         if response.headers.get('Content-Encoding') == 'gzip':
             compressed = StringIO(response.read())
             gzipper = gzip.GzipFile(fileobj=compressed)
             data = gzipper.read()
         else:
             data = response.read()
-        return json.loads(data)
+        return data
+
+    def call(self, params):
+        """
+        Make a call to the wiki. Returns a dictionary that represents the JSON
+        returned by the API.
+        """
+        params['format'] = 'json'
+        return json.loads(self._fetch_http(self._api_url, params))
+
+    def normalize_api_url(self):
+        """
+        This function checks the given URL for a correct API endpoint and
+        returns that URL, while also helpfully setting this object's API URL to
+        it. If it can't magically conjure an API endpoint, it returns False.
+        """
+        data, data_json = self._normalize_api_url_tester(self._api_url)
+        if data_json:
+            return self._api_url
+        else:
+            # if there's an index.php in the URL, we might find the API
+            if 'index.php' in self._api_url:
+                test_api_url = self._api_url.split('index.php')[0] + 'api.php'
+                print test_api_url
+                test_data, test_data_json = \
+                        self._normalize_api_url_tester(test_api_url)
+                print (test_data, test_data_json)
+                if test_data_json:
+                    self._api_url = test_api_url
+                    return self._api_url
+            return False
+
+    def _normalize_api_url_tester(self, api_url):
+        data = self._fetch_http(api_url, {'action': 'query',
+                                          'meta': 'siteinfo',
+                                          'siprop': 'general',
+                                          'format': 'json'})
+        try:
+            data_json = json.loads(data)
+            # may as well set the version
+            try:
+                version_string = data_json['query']['general']['generator']
+                self._mediawiki_version = version_string.split(' ', 1)[1]
+            except KeyError:
+                pass
+            return (data, data_json)
+        except ValueError:
+            return (data, None)
 
     def login(self, user, passwd, token=None):
         """
@@ -85,12 +141,22 @@ class MediaWiki():
             data['lgtoken'] = token
         result = self.call(data)
         if result['login']['result'] == 'Success':
+            self._high_limits = None
             return True
         elif result['login']['result'] == 'NeedToken' and not token:
             return self.login(user, passwd, result['login']['token'])
         else:
             return False
 
+    def logout(self):
+        """
+        Conveinence function for logging out of the wiki.
+        """
+        data = {'action': 'logout'}
+        self.call(data)
+        self._high_limits = None
+        return True
+
     def limits(self, low, high):
         """
         Convenience function for determining appropriate limits in the API. If
@@ -143,4 +209,7 @@ class MediaWiki():
 
 
 __author__ = 'Ian Weller <ian@ianweller.org>'
-__version__ = '1.0'
+__version__ = '1.0.2'
+DEFAULT_UA = 'python-simplemediawiki/%s ' + \
+        '+https://github.com/ianweller/python-simplemediawiki' \
+        % __version__