Remove unused fields from the Sessions

Most of the stuff didn't actually need to be saved and only
belong to the MTProtoState which is not a separate class from
the sessions.

telethon/sessions/sqlite.py

@@ -4,7 +4,6 @@ import os
 import sqlite3
 from base64 import b64decode
 from os.path import isfile as file_exists
-from threading import Lock, RLock
 
 from telethon.tl import types
 from .memory import MemorySession, _SentFileType
@@ -29,10 +28,6 @@ class SQLiteSession(MemorySession):
 
     def __init__(self, session_id=None):
         super().__init__()
-        """session_user_id should either be a string or another Session.
-           Note that if another session is given, only parameters like
-           those required to init a connection will be copied.
-        """
         # These values will NOT be saved
         self.filename = ':memory:'
         self.save_entities = True
@@ -42,12 +37,8 @@ class SQLiteSession(MemorySession):
             if not self.filename.endswith(EXTENSION):
                 self.filename += EXTENSION
 
-        # Cross-thread safety
-        self._seq_no_lock = Lock()
-        self._msg_id_lock = Lock()
-        self._db_lock = RLock()
-
         # Migrating from .json -> SQL
+        # TODO ^ Deprecate
         entities = self._check_migrate_json()
 
         self._conn = None
@@ -204,21 +195,20 @@ class SQLiteSession(MemorySession):
         self._update_session_table()
 
     def _update_session_table(self):
-        with self._db_lock:
-            c = self._cursor()
-            # While we can save multiple rows into the sessions table
-            # currently we only want to keep ONE as the tables don't
-            # tell us which auth_key's are usable and will work. Needs
-            # some more work before being able to save auth_key's for
-            # multiple DCs. Probably done differently.
-            c.execute('delete from sessions')
-            c.execute('insert or replace into sessions values (?,?,?,?)', (
-                self._dc_id,
-                self._server_address,
-                self._port,
-                self._auth_key.key if self._auth_key else b''
-            ))
-            c.close()
+        c = self._cursor()
+        # While we can save multiple rows into the sessions table
+        # currently we only want to keep ONE as the tables don't
+        # tell us which auth_key's are usable and will work. Needs
+        # some more work before being able to save auth_key's for
+        # multiple DCs. Probably done differently.
+        c.execute('delete from sessions')
+        c.execute('insert or replace into sessions values (?,?,?,?)', (
+            self._dc_id,
+            self._server_address,
+            self._port,
+            self._auth_key.key if self._auth_key else b''
+        ))
+        c.close()
 
     def get_update_state(self, entity_id):
         c = self._cursor()
@@ -231,34 +221,30 @@ class SQLiteSession(MemorySession):
             return types.updates.State(pts, qts, date, seq, unread_count=0)
 
     def set_update_state(self, entity_id, state):
-        with self._db_lock:
-            c = self._cursor()
-            c.execute('insert or replace into update_state values (?,?,?,?,?)',
-                      (entity_id, state.pts, state.qts,
-                       state.date.timestamp(), state.seq))
-            c.close()
-            self.save()
+        c = self._cursor()
+        c.execute('insert or replace into update_state values (?,?,?,?,?)',
+                  (entity_id, state.pts, state.qts,
+                   state.date.timestamp(), state.seq))
+        c.close()
+        self.save()
 
     def save(self):
         """Saves the current session object as session_user_id.session"""
-        with self._db_lock:
-            self._conn.commit()
+        self._conn.commit()
 
     def _cursor(self):
         """Asserts that the connection is open and returns a cursor"""
-        with self._db_lock:
-            if self._conn is None:
-                self._conn = sqlite3.connect(self.filename,
-                                             check_same_thread=False)
-            return self._conn.cursor()
+        if self._conn is None:
+            self._conn = sqlite3.connect(self.filename,
+                                         check_same_thread=False)
+        return self._conn.cursor()
 
     def close(self):
         """Closes the connection unless we're working in-memory"""
         if self.filename != ':memory:':
-            with self._db_lock:
-                if self._conn is not None:
-                    self._conn.close()
-                    self._conn = None
+            if self._conn is not None:
+                self._conn.close()
+                self._conn = None
 
     def delete(self):
         """Deletes the current session file"""
@@ -293,11 +279,10 @@ class SQLiteSession(MemorySession):
         if not rows:
             return
 
-        with self._db_lock:
-            self._cursor().executemany(
-                'insert or replace into entities values (?,?,?,?,?)', rows
-            )
-            self.save()
+        self._cursor().executemany(
+            'insert or replace into entities values (?,?,?,?,?)', rows
+        )
+        self.save()
 
     def _fetchone_entity(self, query, args):
         c = self._cursor()
@@ -346,11 +331,10 @@ class SQLiteSession(MemorySession):
         if not isinstance(instance, (InputDocument, InputPhoto)):
             raise TypeError('Cannot cache %s instance' % type(instance))
 
-        with self._db_lock:
-            self._cursor().execute(
-                'insert or replace into sent_files values (?,?,?,?,?)', (
-                    md5_digest, file_size,
-                    _SentFileType.from_type(type(instance)).value,
-                    instance.id, instance.access_hash
-            ))
-            self.save()
+        self._cursor().execute(
+            'insert or replace into sent_files values (?,?,?,?,?)', (
+                md5_digest, file_size,
+                _SentFileType.from_type(type(instance)).value,
+                instance.id, instance.access_hash
+        ))
+        self.save()