@@ -23,14 +23,12 @@ _:py:class:`webuntis.session.Session`. Unless noted otherwise, they get saved
 in a dictionary located in the instance's ``options`` attribute and can be
 modified afterwards.
 
-  - ``credentials``: A dictionary containing ``username`` and  ``password``. Before
-    the session is used, :py:meth:`webuntis.session.JSONRPCSession.login` must
-    be called, in order to add a ``jsessionid`` key, which will be deleted when
-    calling :py:meth:`webuntis.session.JSONRPCSession.logout`.
-    
-    In theory, you can obtain the jsessionid yourself and add it to the
-    ``credentials`` dictionary. In this case, the other two keys are obviously
-    not needed.
+  - ``username``: The username used for the API.
+
+  - ``password``: The password used for the API.
+
+  - ``jsessionid``: The current session key. Shouldn't be changed unless you
+    know what you're doing.
 
   - ``school``: A string containing a valid school name.
 
 
@@ -25,6 +25,112 @@
     import simplejson as json  # from dependency "simplejson"
 
 
+class JSONRPCRequest(object):
+    def __init__(self, session, method, params=None):
+        self._session = session
+        self._method = method
+        self._params = params or {}
+
+    def request(self):
+        data = None
+        i = 0
+        while data is None and i <= self._session.options['login_repeat']:
+            i += 1
+            try:
+                data = self._make_request()
+            except errors.NotLoggedInError as e:
+                if self._session.options['login_repeat'] > 0:
+                    self._session.logout(suppress_errors=True)
+                    self._session.login()
+                else:
+                    raise e
+
+        return data
+
+    def _make_request(self):
+        '''
+        A method for sending a JSON-RPC request.
+
+        :param method: The JSON-RPC method to be executed
+        :type method: str
+
+        :param params: JSON-RPC parameters to the method (should be JSON
+        serializable)
+        :type params: dict
+        '''
+
+        def _handle_json_error():
+            '''A helper function for handling JSON error codes.'''
+            logging.error(res_data)
+            try:
+                error = res_data['error']
+                exc = self._errorcodes[error['code']](error['message'])
+            except KeyError:
+                exc = errors.RemoteError(
+                    'Some JSON-RPC-ish error happened. Please report this to the \
+    developer so he can implement a proper handling.',
+                    str(res_data),
+                    str(req_data)
+                )
+
+            raise exc
+
+        url = self._session.options['server']
+        url += '?school=' + self._session.options['school']
+        cookie_header = True
+        if self._method == 'authenticate':
+            cookie_header = False
+        elif 'jsessionid' not in self._session.options:
+            raise errors.AuthError('Don\'t have JSESSIONID. Did you already log out?')
+
+        req_data = {
+            'id': str(datetime.datetime.today()),
+            'method': self._method,
+            'params': self._params,
+            'jsonrpc': '2.0'
+        }
+
+        req_data_json = json.dumps(req_data).encode()
+
+        logging.debug('Making new request:')
+        logging.debug('URL: ' + url)
+        logging.debug(req_data_json)
+
+        req = urlrequest.Request(
+            url,
+            req_data_json,
+            {
+                'User-Agent': self._session.options['useragent'],
+                'Content-Type': 'application/json'
+            }
+        )
+        if cookie_header:
+            req.add_header(
+                'Cookie',
+                'JSESSIONID=' + self._session.options['jsessionid']
+            )
+
+        # this will eventually raise errors, e.g. if there's an unexpected http
+        # status code
+        res = urlrequest.urlopen(req)
+
+        res_str = res.read().decode('utf-8')
+
+        try:
+            res_data = json.loads(res_str)
+            logging.debug('Valid JSON found')
+            logging.debug(res_data)
+        except ValueError:
+            raise errors.RemoteError('Invalid JSON', str(res_str))
+
+        if res_data['id'] != req_data['id']:
+            raise errors.RemoteError('Request id was not the same as the one returned')
+        elif 'result' in res_data:
+            return res_data['result']
+        else:
+            handle_json_error(req_data, res_data)
+
+
 class JSONRPCSession(object):
     '''Lower-level version of :py:class:`Session`. Do not use this.'''
 
@@ -39,7 +145,7 @@ class JSONRPCSession(object):
     def __init__(self, **kwargs):
         # The OptionStore is an extended dictionary, associating validators
         # and other helper methods with each key
-        self.options = utils.FilterDict(utils.option_utils.option_parsers)
+        self.options = utils.FilterDict(utils.option_utils.options)
         options = {
             'server': None,
             'school': None,
@@ -48,24 +154,17 @@ def __init__(self, **kwargs):
             'password': None,
             'jsessionid': None,
             'cachelen': 20,  # Not implemented in LruDict
-            'keep_session_alive': True
+            'login_repeat': 0
         }
         options.update(kwargs)
 
-        self.options.update({
-            'server': options['server'],
-            'school': options['school'],
-            'useragent': options['useragent'],
-            'credentials': {
-                'username': options['username'],
-                'password': options['password'],
-                'jsessionid': options['jsessionid']
-            },
-            'keep_session_alive': options['keep_session_alive']
-        })
         if options['cachelen'] > 0:
             self._cache = utils.LruDict(maxlen=options['cachelen'])
 
+        del options['cachelen']
+
+        self.options.update(options)
+
     def __enter__(self):
         '''Context-manager'''
         return self
@@ -87,10 +186,10 @@ def logout(self, suppress_errors=False):
         # Send a JSON-RPC 'logout' method without parameters to log out
         try:
             # aborts if we don't have creds
-            self.options['credentials']['jsessionid']
+            self.options['jsessionid']
 
             self._make_request('logout')
-            del self.options['credentials']['jsessionid']
+            del self.options['jsessionid']
         except KeyError:
             if not suppress_errors:
                 raise errors.NotLoggedInError('We already were logged out.')
@@ -108,25 +207,25 @@ def login(self):
         :raises: :py:class:`webuntis.errors.AuthError`
         '''
 
-        if 'username' not in self.options['credentials'] \
-                or 'password' not in self.options['credentials']:
+        if 'username' not in self.options \
+                or 'password' not in self.options:
             raise errors.AuthError('No login data specified.')
 
         logging.debug('Trying to authenticate with username/password...')
         logging.debug('Username: ' +
-                      self.options['credentials']['username'] +
+                      self.options['username'] +
                       ' Password: ' +
-                      self.options['credentials']['password'])
+                      self.options['password'])
         res = self._make_request('authenticate', {
-            'user': self.options['credentials']['username'],
-            'password': self.options['credentials']['password'],
+            'user': self.options['username'],
+            'password': self.options['password'],
             'client': self.options['useragent']
         })
         logging.debug(res)
         if 'sessionId' in res:
             logging.debug('Did get a jsessionid from the server:')
-            self.options['credentials']['jsessionid'] = res['sessionId']
-            logging.debug(self.options['credentials']['jsessionid'])
+            self.options['jsessionid'] = res['sessionId']
+            logging.debug(self.options['jsessionid'])
         else:
             raise errors.AuthError(
                 'Something went wrong while authenticating',
@@ -136,7 +235,7 @@ def login(self):
         return self
 
     def _request(self, method, params=None):
-        '''A wrapper for _make_request using the LRU Cache'''
+        '''A wrapper for :py:class:`JSONRPCRequest` using the LRU Cache'''
 
         if self._cache is None:
             return self._make_request(method, params)
@@ -146,6 +245,10 @@ def _request(self, method, params=None):
                 self._cache[key] = self._make_request(method, params)
             return self._cache[key]
 
+    def _make_request(self, method, params=None):
+        return JSONRPCRequest(self, method, params).request()
+
+
     _errorcodes = {
         -32601: errors.MethodNotFoundError,
         -8504: errors.BadCredentialsError,
@@ -156,96 +259,7 @@ def _request(self, method, params=None):
 
 
 
-    def _make_request(self, method, params=None):
-        '''
-        A method for sending a JSON-RPC request.
-
-        :param method: The JSON-RPC method to be executed
-        :type method: str
-
-        :param params: JSON-RPC parameters to the method (should be JSON
-        serializable)
-        :type params: dict
-        '''
 
-        def _handle_json_error():
-            '''A helper function for handling JSON error codes.'''
-            logging.error(res_data)
-            try:
-                error = res_data['error']
-                exc = self._errorcodes[error['code']](error['message'])
-            except KeyError:
-                exc = errors.RemoteError(
-                    'Some JSON-RPC-ish error happened. Please report this to the \
-    developer so he can implement a proper handling.',
-                    str(res_data),
-                    str(req_data)
-                )
-
-            if type(exc) is errors.NotLoggedInError and self.options['keep_session_alive']:
-                self.logout(suppress_errors=True)
-                self.login()
-                return self._make_request(method, params)
-            else:
-                raise exc
-
-        url = self.options['server']
-        url += '?school=' + self.options['school']
-        cookie_header = True
-        if method == 'authenticate':
-            cookie_header = False
-        elif 'jsessionid' not in self.options['credentials']:
-            raise errors.AuthError('Don\'t have JSESSIONID. Did you already log out?')
-
-        if not params:
-            params = {}
-
-        req_data = {
-            'id': str(datetime.datetime.today()),
-            'method': method,
-            'params': params,
-            'jsonrpc': '2.0'
-        }
-
-        req_data_json = json.dumps(req_data).encode()
-
-        logging.debug('Making new request:')
-        logging.debug('URL: ' + url)
-        logging.debug(req_data_json)
-
-        req = urlrequest.Request(
-            url,
-            req_data_json,
-            {
-                'User-Agent': self.options['useragent'],
-                'Content-Type': 'application/json'
-            }
-        )
-        if cookie_header:
-            req.add_header(
-                'Cookie',
-                'JSESSIONID=' + self.options['credentials']['jsessionid']
-            )
-
-        # this will eventually raise errors, e.g. if there's an unexpected http
-        # status code
-        res = urlrequest.urlopen(req)
-
-        res_str = res.read().decode('utf-8')
-
-        try:
-            res_data = json.loads(res_str)
-            logging.debug('Valid JSON found')
-            logging.debug(res_data)
-        except ValueError:
-            raise errors.RemoteError('Invalid JSON', str(res_str))
-
-        if res_data['id'] != req_data['id']:
-            raise errors.RemoteError('Request id was not the same as the one returned')
-        elif 'result' in res_data:
-            return res_data['result']
-        else:
-            return handle_json_error(req_data, res_data)
 
 
 class Session(JSONRPCSession):