Revert "Move to aiosqlite and enable WAL"

This reverts commit afd2e3f0bc.

Signed-off-by: wulan17 <wulan17@nusantararom.org>

pyrogram/storage/file_storage.py

@@ -18,7 +18,7 @@
 
 import logging
 import os
-import aiosqlite
+import sqlite3
 from pathlib import Path
 
 from .sqlite_storage import SQLiteStorage
@@ -34,38 +34,39 @@ class FileStorage(SQLiteStorage):
 
         self.database = workdir / (self.name + self.FILE_EXTENSION)
 
-    async def update(self):
+    def update(self):
-        version = await self.version()
+        version = self.version()
 
         if version == 1:
-            await self.conn.execute("DELETE FROM peers")
+            with self.lock, self.conn:
+                self.conn.execute("DELETE FROM peers")
 
             version += 1
 
         if version == 2:
-            await self.conn.execute("ALTER TABLE sessions ADD api_id INTEGER")
+            with self.lock, self.conn:
+                self.conn.execute("ALTER TABLE sessions ADD api_id INTEGER")
 
             version += 1
 
-        await self.version(version)
+        self.version(version)
 
     async def open(self):
         path = self.database
         file_exists = path.is_file()
 
-        self.conn = await aiosqlite.connect(str(path), timeout=1)
+        self.conn = sqlite3.connect(str(path), timeout=1, check_same_thread=False)
-
-        await self.conn.execute("PRAGMA journal_mode=WAL")
 
         if not file_exists:
-            await self.create()
+            self.create()
         else:
-            await self.update()
+            self.update()
 
-        try:  # Python 3.6.0 (exactly this version) is bugged and won't successfully execute the vacuum
+        with self.conn:
-            await self.conn.execute("VACUUM")
+            try:  # Python 3.6.0 (exactly this version) is bugged and won't successfully execute the vacuum
-        except aiosqlite.OperationalError:
+                self.conn.execute("VACUUM")
-            pass
+            except sqlite3.OperationalError:
+                pass
 
     async def delete(self):
         os.remove(self.database)

pyrogram/storage/memory_storage.py

@@ -18,7 +18,7 @@
 
 import base64
 import logging
-import aiosqlite
+import sqlite3
 import struct
 
 from .sqlite_storage import SQLiteStorage
@@ -33,8 +33,8 @@ class MemoryStorage(SQLiteStorage):
         self.session_string = session_string
 
     async def open(self):
-        self.conn = await aiosqlite.connect(":memory:")
+        self.conn = sqlite3.connect(":memory:", check_same_thread=False)
-        await self.create()
+        self.create()
 
         if self.session_string:
             # Old format

pyrogram/storage/sqlite_storage.py

@@ -17,7 +17,7 @@
 #  along with Pyrogram.  If not, see <http://www.gnu.org/licenses/>.
 
 import inspect
-import aiosqlite
+import sqlite3
 import time
 from threading import Lock
 from typing import List, Tuple, Any
@@ -97,20 +97,22 @@ class SQLiteStorage(Storage):
     def __init__(self, name: str):
         super().__init__(name)
 
-        self.conn = None  # type: aiosqlite.Connection
+        self.conn = None  # type: sqlite3.Connection
+        self.lock = Lock()
 
-    async def create(self):
+    def create(self):
-        await self.conn.executescript(SCHEMA)
+        with self.lock, self.conn:
+            self.conn.executescript(SCHEMA)
 
-        await self.conn.execute(
+            self.conn.execute(
-            "INSERT INTO version VALUES (?)",
+                "INSERT INTO version VALUES (?)",
-            (self.VERSION,)
+                (self.VERSION,)
-        )
+            )
 
-        await self.conn.execute(
+            self.conn.execute(
-            "INSERT INTO sessions VALUES (?, ?, ?, ?, ?, ?, ?)",
+                "INSERT INTO sessions VALUES (?, ?, ?, ?, ?, ?, ?)",
-            (2, None, None, None, 0, None, None)
+                (2, None, None, None, 0, None, None)
-        )
+            )
 
     async def open(self):
         raise NotImplementedError
@@ -118,27 +120,29 @@ class SQLiteStorage(Storage):
     async def save(self):
         await self.date(int(time.time()))
 
-        await self.conn.commit()
+        with self.lock:
+            self.conn.commit()
 
     async def close(self):
-        await self.conn.close()
+        with self.lock:
+            self.conn.close()
 
     async def delete(self):
         raise NotImplementedError
 
     async def update_peers(self, peers: List[Tuple[int, int, str, str, str]]):
-        await self.conn.executemany(
+        with self.lock:
-            "REPLACE INTO peers (id, access_hash, type, username, phone_number)"
+            self.conn.executemany(
-            "VALUES (?, ?, ?, ?, ?)",
+                "REPLACE INTO peers (id, access_hash, type, username, phone_number)"
-            peers
+                "VALUES (?, ?, ?, ?, ?)",
-        )
+                peers
+            )
 
     async def get_peer_by_id(self, peer_id: int):
-        q = await self.conn.execute(
+        r = self.conn.execute(
             "SELECT id, access_hash, type FROM peers WHERE id = ?",
             (peer_id,)
-        )
+        ).fetchone()
-        r = await q.fetchone()
 
         if r is None:
             raise KeyError(f"ID not found: {peer_id}")
@@ -146,12 +150,11 @@ class SQLiteStorage(Storage):
         return get_input_peer(*r)
 
     async def get_peer_by_username(self, username: str):
-        q = await self.conn.execute(
+        r = self.conn.execute(
             "SELECT id, access_hash, type, last_update_on FROM peers WHERE username = ?"
             "ORDER BY last_update_on DESC",
             (username,)
-        )
+        ).fetchone()
-        r = await q.fetchone()
 
         if r is None:
             raise KeyError(f"Username not found: {username}")
@@ -162,65 +165,64 @@ class SQLiteStorage(Storage):
         return get_input_peer(*r[:3])
 
     async def get_peer_by_phone_number(self, phone_number: str):
-        q = await self.conn.execute(
+        r = self.conn.execute(
             "SELECT id, access_hash, type FROM peers WHERE phone_number = ?",
             (phone_number,)
-        )
+        ).fetchone()
-        r = await q.fetchone()
 
         if r is None:
             raise KeyError(f"Phone number not found: {phone_number}")
 
         return get_input_peer(*r)
 
-    async def _get(self):
+    def _get(self):
         attr = inspect.stack()[2].function
 
-        q = await self.conn.execute(
+        return self.conn.execute(
             f"SELECT {attr} FROM sessions"
-        )
+        ).fetchone()[0]
-        return (await q.fetchone())[0]
 
-    async def _set(self, value: Any):
+    def _set(self, value: Any):
         attr = inspect.stack()[2].function
 
-        await self.conn.execute(
+        with self.lock, self.conn:
-            f"UPDATE sessions SET {attr} = ?",
+            self.conn.execute(
-            (value,)
+                f"UPDATE sessions SET {attr} = ?",
-        )
-
-    async def _accessor(self, value: Any = object):
-        return await self._get() if value == object else await self._set(value)
-
-    async def dc_id(self, value: int = object):
-        return await self._accessor(value)
-
-    async def api_id(self, value: int = object):
-        return await self._accessor(value)
-
-    async def test_mode(self, value: bool = object):
-        return await self._accessor(value)
-
-    async def auth_key(self, value: bytes = object):
-        return await self._accessor(value)
-
-    async def date(self, value: int = object):
-        return await self._accessor(value)
-
-    async def user_id(self, value: int = object):
-        return await self._accessor(value)
-
-    async def is_bot(self, value: bool = object):
-        return await self._accessor(value)
-
-    async def version(self, value: int = object):
-        if value == object:
-            q = await self.conn.execute(
-                "SELECT number FROM version"
-            )
-            return (await q.fetchone())[0]
-        else:
-            await self.conn.execute(
-                "UPDATE version SET number = ?",
                 (value,)
             )
+
+    def _accessor(self, value: Any = object):
+        return self._get() if value == object else self._set(value)
+
+    async def dc_id(self, value: int = object):
+        return self._accessor(value)
+
+    async def api_id(self, value: int = object):
+        return self._accessor(value)
+
+    async def test_mode(self, value: bool = object):
+        return self._accessor(value)
+
+    async def auth_key(self, value: bytes = object):
+        return self._accessor(value)
+
+    async def date(self, value: int = object):
+        return self._accessor(value)
+
+    async def user_id(self, value: int = object):
+        return self._accessor(value)
+
+    async def is_bot(self, value: bool = object):
+        return self._accessor(value)
+
+    def version(self, value: int = object):
+        if value == object:
+            return self.conn.execute(
+                "SELECT number FROM version"
+            ).fetchone()[0]
+        else:
+            with self.lock, self.conn:
+                self.conn.execute(
+                    "UPDATE version SET number = ?",
+                    (value,)
+                )