test db con sqlitedict

core/__init__.py

@@ -13,51 +13,17 @@ except:
 # Connect to database
 from . import filetools
 from platformcode import config
-import sqlite3, threading
-
-db_name = filetools.join(config.get_data_path(), "kod_db.sqlite")
-db_semaphore = threading.Semaphore()
+from collections import defaultdict
+from lib.sqlitedict import SqliteDict
 
 
-class safeConn(sqlite3.Connection):
-    """thread-safe sqlite3.Connection"""
-    def commit(self):
-        db_semaphore.acquire()
-        try:
-            super(safeConn, self).commit()
-        finally:
-            db_semaphore.release()
+class nested_dict_sqlite(defaultdict):
+    'like defaultdict but default_factory receives the key'
+
+    def __missing__(self, key):
+        self[key] = value = self.default_factory(key)
+        return value
 
 
-class safeCur(sqlite3.Cursor):
-    """thread-safe sqlite3.Cursor"""
-    def execute(self, *args, **kwargs):
-        db_semaphore.acquire()
-        try:
-            super(safeCur, self).execute(*args, **kwargs)
-        finally:
-            db_semaphore.release()
-
-    def executescript(self, *args, **kwargs):
-        db_semaphore.acquire()
-        try:
-            super(safeCur, self).executescript(*args, **kwargs)
-        finally:
-            db_semaphore.release()
-
-    def executemany(self, *args, **kwargs):
-        db_semaphore.acquire()
-        try:
-            super(safeCur, self).executemany(*args, **kwargs)
-        finally:
-            db_semaphore.release()
-
-
-db_conn = sqlite3.connect(db_name, factory=safeConn, timeout=15, check_same_thread=False)
-db = db_conn.cursor(safeCur)
-
-# Create tables if not already exists
-db.execute('CREATE TABLE IF NOT EXISTS tmdb_cache (url TEXT PRIMARY KEY, response TEXT, added TEXT);')
-db.execute('CREATE TABLE IF NOT EXISTS viewed (tmdb_id TEXT PRIMARY KEY, season INT, episode INT, played_time REAL);')
-db.execute('CREATE TABLE IF NOT EXISTS dnscache(domain TEXT NOT NULL UNIQUE, ip	TEXT NOT NULL, PRIMARY KEY(domain));')
-db_conn.commit()
+db_name = filetools.join(config.get_data_path(), "db.sqlite")
+db = nested_dict_sqlite(lambda table: SqliteDict(db_name, table, 'c', True))

core/resolverdns.py

@@ -15,7 +15,7 @@ from lib import doh
 from platformcode import logger
 import requests
 from core import scrapertools
-from core import db, db_conn
+from core import db
 
 if 'PROTOCOL_TLS' in ssl.__dict__:
     protocol = ssl.PROTOCOL_TLS
@@ -50,18 +50,13 @@ class CipherSuiteAdapter(host_header_ssl.HostHeaderSSLAdapter):
         super(CipherSuiteAdapter, self).__init__(**kwargs)
 
     def flushDns(self, request, domain, **kwargs):
-        db.execute('delete from dnscache where domain=?', (domain,))
-        db_conn.commit()
+        del db['dnscache'][domain]
         return self.send(request, flushedDns=True, **kwargs)
 
     def getIp(self, domain):
-        ip = None
-        try:
-            db.execute('select ip from dnscache where domain=?', (domain,))
-            ip = db.fetchall()[0][0]
-            logger.info('Cache DNS: ' + domain + ' = ' + str(ip))
-        except:
-            pass
+        ip = db['dnscache'].get(domain, None)
+        logger.info('Cache DNS: ' + domain + ' = ' + str(ip))
+
         if not ip:  # not cached
             try:
                 ip = doh.query(domain)[0]
@@ -74,11 +69,7 @@ class CipherSuiteAdapter(host_header_ssl.HostHeaderSSLAdapter):
         return ip
 
     def writeToCache(self, domain, ip):
-        try:
-            db.execute('insert into dnscache values(?,?)', (domain, ip))
-            db_conn.commit()
-        except:
-            pass
+        db['dnscache'][domain] = ip
 
     def init_poolmanager(self, *args, **kwargs):
         kwargs['ssl_context'] = self.ssl_context

core/tmdb.py

@@ -3,6 +3,7 @@
 # from future import standard_library
 # standard_library.install_aliases()
 # from builtins import str
+import datetime
 import sys, requests
 PY3 = False
 if sys.version_info[0] >= 3: PY3 = True; unicode = str; unichr = chr; long = int
@@ -15,7 +16,7 @@ else:
 from future.builtins import range
 from future.builtins import object
 
-import ast, copy, re, sqlite3, time, xbmcaddon
+import ast, copy, re, time
 
 from core import filetools, httptools, jsontools, scrapertools
 from core.item import InfoLabels
@@ -62,7 +63,7 @@ def_lang = info_language[config.get_setting("info_language", "videolibrary")]
 # ------------------------------------------------- -------------------------------------------------- -----------
 
 otmdb_global = None
-from core import db, db_conn
+from core import db
 
 
 # The function name is the name of the decorator and receives the function that decorates.
@@ -73,17 +74,11 @@ def cache_response(fn):
     # start_time = time.time()
 
     def wrapper(*args, **kwargs):
-        import base64
-
-        def check_expired(ts):
-            import datetime
-
+        def check_expired(saved_date):
             valided = False
 
             cache_expire = config.get_setting("tmdb_cache_expire", default=0)
-
-            saved_date = datetime.datetime.fromtimestamp(ts)
-            current_date = datetime.datetime.fromtimestamp(time.time())
+            current_date = datetime.datetime.now()
             elapsed = current_date - saved_date
 
             # 1 day
@@ -130,23 +125,16 @@ def cache_response(fn):
 
                 url = re.sub('&year=-', '', args[0])
                 if PY3: url = str.encode(url)
-                url_base64 = base64.b64encode(url)
-                db.execute("SELECT response, added FROM tmdb_cache WHERE url=?", (url_base64,))
-                row = db.fetchone()
 
-                if row and check_expired(float(row[1])):
-                    result = eval(base64.b64decode(row[0]))
+                row = db['tmdb_cache'].get(url)
+
+                if row and check_expired(row[1]):
+                    result = row[0]
 
                 # si no se ha obtenido información, llamamos a la funcion
                 if not result:
                     result = fn(*args)
-                    result = str(result)
-                    if PY3: result = str.encode(result)
-                    result_base64 = base64.b64encode(result)
-                    db.execute("INSERT OR REPLACE INTO tmdb_cache (url, response, added) VALUES (?, ?, ?)",
-                              (url_base64, result_base64, time.time()))
-
-                    db_conn.commit()
+                    db['tmdb_cache'][url] = [result, datetime.datetime.now()]
 
             # elapsed_time = time.time() - start_time
             # logger.debug("TARDADO %s" % elapsed_time)