dictature 0.12.1__py3-none-any.whl → 0.13.1__py3-none-any.whl

dictature/backend/mysql.py

@@ -0,0 +1,119 @@
+try:
+    import mysql.connector
+except ImportError:
+    raise ImportError('Requires: pip install mysql-connector-python') from None
+from typing import Iterable
+
+from .mock import DictatureBackendMock, DictatureTableMock, Value
+
+
+class DictatureBackendMySQL(DictatureBackendMock):
+    def __init__(self, host: str, port: int = 3306, user: str = None, password: str = None,
+                 database: str = None, prefix: str = 'tb_', **kwargs) -> None:
+        """
+        Create a new MySQL backend
+        :param host: MySQL server host
+        :param port: MySQL server port (default: 3306)
+        :param user: MySQL username
+        :param password: MySQL password
+        :param database: MySQL database name
+        :param kwargs: Additional connection parameters
+        """
+        self.__connection_params = {
+            'host': host,
+            'port': port,
+            'user': user,
+            'password': password,
+            'database': database,
+            **kwargs
+        }
+
+        # Remove None values from connection params
+        self.__connection_params = {k: v for k, v in self.__connection_params.items() if v is not None}
+
+        self.__connection = mysql.connector.connect(**self.__connection_params)
+        self.__cursor = self.__connection.cursor()
+        self.__prefix = prefix.replace('`', '').replace("'", '')
+
+    def keys(self) -> Iterable[str]:
+        # noinspection SqlResolve
+        tables = self._execute(f"SELECT table_name FROM information_schema.tables WHERE table_schema = %s AND table_name LIKE '{self.__prefix}%'", (self.__connection_params['database'],))
+        return {table[0][3:] for table in tables}
+
+    def table(self, name: str) -> 'DictatureTableMock':
+        return DictatureTableMySQL(self, name, self.__prefix)
+
+    def _execute(self, query: str, data: tuple = ()) -> list:
+        self.__cursor.execute(query, data)
+        return self.__cursor.fetchall()
+
+    def _commit(self) -> None:
+        self.__connection.commit()
+
+    def __del__(self):
+        if hasattr(self, '_DictatureBackendMySQL__connection'):
+            self.__connection.close()
+
+
+class DictatureTableMySQL(DictatureTableMock):
+    def __init__(self, parent: "DictatureBackendMySQL", name: str, prefix: str) -> None:
+        self.__parent = parent
+        # MySQL table names don't need backticks for simple names, but we'll use them for consistency
+        self.__table = f"`{prefix}{name.replace('`', '')}`"
+
+    def keys(self) -> Iterable[str]:
+        # noinspection PyProtectedMember
+        result = self.__parent._execute(f"SELECT `key` FROM {self.__table}")
+        return set(map(lambda x: x[0], result))
+
+    def drop(self) -> None:
+        # noinspection PyProtectedMember
+        self.__parent._execute(f"DROP TABLE {self.__table}")
+
+    def key_exists(self, item: str) -> bool:
+        # noinspection PyProtectedMember
+        result = self.__parent._execute(f"SELECT `value` FROM {self.__table} WHERE `key`=%s", (item,))
+        return len(result) > 0
+
+    def create(self) -> None:
+        # noinspection PyProtectedMember
+        self.__parent._execute(f"""
+        CREATE TABLE IF NOT EXISTS {self.__table} (
+        `key` VARCHAR(700) NOT NULL UNIQUE,
+        `value` TEXT,
+        `type` INT NOT NULL DEFAULT 0,
+        PRIMARY KEY (`key`)
+        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
+        """)
+
+    def set(self, item: str, value: Value) -> None:
+        if self.key_exists(item):
+            # noinspection PyProtectedMember
+            self.__parent._execute(f"""
+            UPDATE {self.__table} SET `value`=%s, `type`=%s WHERE `key`=%s
+            """, (value.value, value.mode, item))
+        else:
+            # noinspection PyProtectedMember
+            self.__parent._execute(
+                f"INSERT INTO {self.__table} (`key`, `value`, `type`) VALUES (%s, %s, %s)",
+                (item, value.value, value.mode)
+            )
+        # noinspection PyProtectedMember
+        self.__parent._commit()
+
+    def get(self, item: str) -> Value:
+        # noinspection PyProtectedMember
+        r = self.__parent._execute(f"SELECT `value`, `type` FROM {self.__table} WHERE `key`=%s", (item,))
+        if r:
+            value: str = r[0][0]
+            type_value: int = r[0][1]
+            return Value(value=value, mode=type_value)
+        raise KeyError(item)
+
+    def delete(self, item: str) -> None:
+        # noinspection PyProtectedMember
+        self.__parent._execute(
+            f"DELETE FROM {self.__table} WHERE `key`=%s", (item,)
+        )
+        # noinspection PyProtectedMember
+        self.__parent._commit()

dictature/backend/sqlite.py

@@ -1,15 +1,16 @@
 import sqlite3
-from typing import Iterable, Union, Optional
 from pathlib import Path
+from typing import Iterable, Union, Optional
 
 from .mock import DictatureBackendMock, DictatureTableMock, Value, ValueMode
 
 
 class DictatureBackendSQLite(DictatureBackendMock):
-    def __init__(self, file: Union[str, Path]) -> None:
+    def __init__(self, file: Union[str, Path], prefix: str = 'tb_') -> None:
         """
         Create a new SQLite backend
         :param file: file to store the database
+        :param prefix: prefix for the tables (default: 'tb_')
         """
         if isinstance(file, str):
             file = Path(file)
@@ -19,13 +20,14 @@ class DictatureBackendSQLite(DictatureBackendMock):
             check_same_thread=False if sqlite3.threadsafety >= 3 else True
         )
         self.__cursor = self.__connection.cursor()
+        self.__prefix = prefix.replace("'", "").replace('`', '')
 
     def keys(self) -> Iterable[str]:
-        tables = self._execute("SELECT tbl_name FROM sqlite_master WHERE type='table' AND tbl_name LIKE 'tb_%'")
+        tables = self._execute(f"SELECT tbl_name FROM sqlite_master WHERE type='table' AND tbl_name LIKE '{self.__prefix}%'")
         return {table[0][3:] for table in tables}
 
     def table(self, name: str) -> 'DictatureTableMock':
-        return DictatureTableSQLite(self, name)
+        return DictatureTableSQLite(self, name, self.__prefix)
 
     def _execute(self, query: str, data: tuple = ()) -> list:
         return list(self.__cursor.execute(query, data))
@@ -38,10 +40,10 @@ class DictatureBackendSQLite(DictatureBackendMock):
 
 
 class DictatureTableSQLite(DictatureTableMock):
-    def __init__(self, parent: "DictatureBackendSQLite", name: str) -> None:
+    def __init__(self, parent: "DictatureBackendSQLite", name: str, prefix: str) -> None:
         self.__parent = parent
         self.__supports_jsonization: Optional[bool] = None
-        self.__table = "`tb_%s`" % name.replace('`', '``')
+        self.__table = "`%s`" % (prefix + name).replace('`', '``')
 
     def keys(self) -> Iterable[str]:
         # noinspection PyProtectedMember

{dictature-0.12.1.dist-info → dictature-0.13.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dictature
-Version: 0.12.1
+Version: 0.13.1
 Summary: dictature -- A generic wrapper around dict-like interface with mulitple backends
 Author-email: Adam Hlavacek <git@adamhlavacek.com>
 Project-URL: Homepage, https://github.com/esoadamo/dictature
@@ -61,6 +61,7 @@ Currently, the following backends are supported:
 - `DictatureBackendMISP`: stores the data in a MISP instance
 - `DictatureBackendWebdav`: stores data in a WebDav share as files
 - `DictatureBackendS3`: stores data in an S3 bucket
+- `DictatureBackendMySQL`: stores data in a MySQL database
 
 ### Transformers
 

{dictature-0.12.1.dist-info → dictature-0.13.1.dist-info}/RECORD

@@ -4,8 +4,9 @@ dictature/backend/__init__.py,sha256=d5s6QCJOUzFglVNg8Cqqx_8b61S-AOTGjEUIF6FS69U
 dictature/backend/directory.py,sha256=_-8Fx7Ef4tFbOQWHcARfKjm0kbZUpmN1f1ysyWINOr4,3600
 dictature/backend/misp.py,sha256=R9osuEJa79SoXErwByIwhViJ26cEfw2nKhWu8XxkO7Y,4860
 dictature/backend/mock.py,sha256=o4YBl6Wk-q6IHFdykGeryTKcQFsJHvymlONPbbwVkak,5891
+dictature/backend/mysql.py,sha256=LdbcytXCnu2pqx3LfOH__-dFy85IwB-HGMFOxDIGBvA,4624
 dictature/backend/s3.py,sha256=9Vcf4-RagyjpV9F4m9ZQ1vjb4lbZfEcOZQBuD_SPwZg,6580
-dictature/backend/sqlite.py,sha256=zyphYEeLY4eGuBCor16i80_-brdipMpXZ3_kONwErsE,5237
+dictature/backend/sqlite.py,sha256=mHEfRufqRcDfl0mIPl9eK0ODyUmgYD9SWjbllI87Hp0,5434
 dictature/backend/webdav.py,sha256=Y-3_WTcMyKVUnsVjiUZAxuy10FK0Yr-7Mgn13clg3po,5039
 dictature/transformer/__init__.py,sha256=JIFJpXU6iB9hIUM8L7HL2o9Nqjm_YbMEuQBQC8ZJ6b4,124
 dictature/transformer/aes.py,sha256=ZhC1dT9QpnziErkDLriWLgXDEFNGQW0KG4aqSN2AZpA,1926
@@ -14,8 +15,8 @@ dictature/transformer/hmac.py,sha256=vURsB0HlzRPn_Vkl7lGmZV9OKempQuds8AanmadDxIo
 dictature/transformer/mock.py,sha256=7zu65ZqUV_AVRaPSzNd73cVMXixXt31SeuX9OKZxaJQ,948
 dictature/transformer/passthrough.py,sha256=Pt3N6G_Qh6HJ_q75ETL5nfAwYHLB-SjkVwUwbbbMik8,344
 dictature/transformer/pipeline.py,sha256=OaQaJeJ5NpICetJe08r8ontqstsXGuW8jDbKw1zxYs4,842
-dictature-0.12.1.dist-info/LICENSE,sha256=n1U9DKr8sM5EY2QHcvxSGiKTDWUT8MyXsOC79w94MT0,1072
-dictature-0.12.1.dist-info/METADATA,sha256=FDWISHrqfqU3SooFoZ8xRyAQ2IF8ryNGbKZYed3cJyE,3335
-dictature-0.12.1.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-dictature-0.12.1.dist-info/top_level.txt,sha256=-RO39WWCF44lqiXhSUcACVqbk6SkgReZTz7ZmHKH3-U,10
-dictature-0.12.1.dist-info/RECORD,,
+dictature-0.13.1.dist-info/LICENSE,sha256=n1U9DKr8sM5EY2QHcvxSGiKTDWUT8MyXsOC79w94MT0,1072
+dictature-0.13.1.dist-info/METADATA,sha256=hJZ0-CPWRgnNPvMY2l3uhPiEO9-xuNDgSwUmVM0adfs,3394
+dictature-0.13.1.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+dictature-0.13.1.dist-info/top_level.txt,sha256=-RO39WWCF44lqiXhSUcACVqbk6SkgReZTz7ZmHKH3-U,10
+dictature-0.13.1.dist-info/RECORD,,