pyeasysql 1.0__tar.gz

PyEasySQL-1.0/EasySQL/ABC.py

@@ -0,0 +1,43 @@
+from abc import ABC
+from typing import Union, TypeVar, List, Set, Tuple
+
+
+class SQLType(ABC):
+    @property
+    def name(self):
+        raise NotImplementedError
+
+    @property
+    def default(self):
+        raise NotImplementedError
+
+    def parse(self, value) -> str:
+        raise NotImplementedError
+
+    def cast(self, value):
+        raise NotImplementedError
+
+
+class SQLExecutable(ABC):
+    def execute(self, operation, params=()):
+        raise NotImplementedError
+
+
+class SQLCommand(ABC):
+    def get_value(self, *args, **kwargs) -> str:
+        raise NotImplementedError
+
+
+class SQLCommandExecutable(SQLCommand, ABC):
+    def execute(self, *args, **kwargs):
+        raise NotImplementedError
+
+
+# Extra Typings
+T = TypeVar('T')
+Collection = Union[List[T], Set[T], Tuple[T]]
+ListOrSingle = Union[T, Collection[T]]
+
+
+def is_collection(value):
+    return isinstance(value, (list, set, tuple))

PyEasySQL-1.0/EasySQL/Classes.py

@@ -0,0 +1,322 @@
+from typing import List, Optional, Union, Any, Dict
+
+import mysql.connector
+
+from .ABC import ListOrSingle, SQLCommandExecutable, Collection, SQLType
+from .Exceptions import MissingArgumentException, MisMatchException, DatabaseSafetyException
+from .Logging import logger
+from .Where import Where
+
+__all__ = ['EasyDatabase', 'EasyTable', 'EasyColumn', 'Select', 'Insert', 'Update', 'Delete']
+
+
+class EasyColumn:
+    def __init__(self, name: str, sql_type: SQLType, default: Any = None, primary: bool = False, not_null: bool = False, auto_increment: bool = False):
+        self.name = name
+        self.sql_type = sql_type
+        self.default = default if default else sql_type.default if not_null else None
+        self.primary = primary
+        self.auto_increment = auto_increment
+        self.not_null = not_null
+
+    def __hash__(self):
+        return hash((self.name,))
+
+    def __repr__(self):
+        return f'<EasyColumn "{self.name}" type={self.sql_type}>'
+
+    def __eq__(self, other):
+        if isinstance(other, EasyColumn):
+            return self.name == other.name and self.sql_type == other.sql_type
+        return False
+
+    def get_sql(self):
+        value = f'{self.name} {self.sql_type.name}'
+        if self.primary:
+            value += ' PRIMARY KEY'
+        elif self.not_null:
+            value += ' NOT NULL'
+        if self.auto_increment:
+            value += ' AUTO_INCREMENT'
+        if self.default is not None:
+            value += f' DEFAULT {self.sql_type.parse(self.default)}'
+        return value
+
+    def parse(self, value):
+        return self.sql_type.parse(value)
+
+    def cast(self, value):
+        return self.sql_type.cast(value)
+
+
+class EasyDatabase:
+    def __init__(self, host="127.0.0.1", port=3306, database=None, user="root", password=None):
+        if database is None:
+            raise MissingArgumentException('Database argument is required.')
+        if password is None:
+            raise MissingArgumentException('Password is not provided.')
+
+        self._database = database
+        self._password = password
+        self._host = host
+        self._port = port
+        self._user = user
+
+        self._connection = None
+        self._safe = True
+        self.prepare()
+
+    @property
+    def safe(self):
+        return self._safe
+
+    def remove_safety(self, *, confirm: bool):
+        self._safe = not confirm
+
+    @property
+    def connection(self):
+        try:
+            self._connection.ping()
+        except Exception as e:
+            logger.info(f'Connecting to the database called {self._database} due {e}')
+            self._connection = mysql.connector.connect(host=self._host, port=self._port, database=self._database, user=self._user, password=self._password)
+        return self._connection
+
+    def prepare(self):
+        return self.connection.is_connected()
+
+    @property
+    def cursor(self):
+        self._cursor = self.connection.cursor()
+        return self._cursor
+
+    def execute(self, operation, params=(), auto_commit=True):
+        cursor = self.cursor
+
+        logger.debug(f'SQL command has been requested to be executed:\n\tCommand: "{operation}"\n\tParameters: {params}\n\tCommit: {auto_commit}')
+        cursor.execute(operation, params)
+        if auto_commit:
+            self.commit()
+
+        return cursor
+
+    def commit(self):
+        return self.connection.commit()
+
+
+class EasyTable:
+    def __init__(self, database: EasyDatabase, name: str, columns: List[EasyColumn]):
+        self._database = database
+        self._name = name
+        self._columns = columns
+
+        self.create()
+
+    def assert_columns(self, columns):
+        if columns is None or columns == '*':
+            return
+        for column in columns:
+            if column not in self._columns:
+                raise MisMatchException(f'Column "{column}" is not implemented in this table.')
+
+    def manage_values(self, values: Union[Collection[Any], Dict[Union[EasyColumn, str], Any]]) -> Dict[EasyColumn, Any]:
+        if isinstance(values, dict):
+            columns = [self.get_column(column) for column in values.keys()]
+            values = list(values.values())
+        else:
+            columns = self._columns
+            values = list(values)
+
+        self.assert_columns(columns)
+        if len(values) != len(columns):
+            raise MisMatchException('Values does not match with columns.')
+
+        return {columns[i]: values[i] for i in range(len(columns))}
+
+    def create(self):
+        command = f"CREATE TABLE IF NOT EXISTS {self._name} ({', '.join([column.get_sql() for column in self._columns])});"
+        self._database.execute(command)
+
+    @property
+    def columns(self):
+        return self._columns
+
+    @property
+    def name(self):
+        return self._name
+
+    def get_column(self, target) -> Optional[EasyColumn]:
+        if target in self._columns:
+            return target
+        for column in self._columns:
+            if column.name == target:
+                return column
+        return None
+
+    def select(self, columns: ListOrSingle[Union[EasyColumn, str]] = None, where: Where = None):
+        if columns is not None:
+            if isinstance(columns, str):
+                columns = [columns]
+            columns = [self.get_column(column) for column in columns]
+
+        return Select(self._database, columns, self, where).execute()
+
+    def insert(self, values: Union[Collection[Any], Dict[Union[EasyColumn, str], Any]]):
+        return Insert(self._database, self.manage_values(values), self).execute()
+
+    def update(self, values: Union[Collection[Any], Dict[Union[EasyColumn, str], Any]], where: Where = None):
+        return Update(self._database, self.manage_values(values), self, where).execute()
+
+    def delete(self, where: Where = None):
+        return Delete(self._database, self, where).execute()
+
+    def set(self, values: Union[Collection[Any], Dict[Union[EasyColumn, str], Any]], where: Where = None):
+        values = self.manage_values(values)
+        selection = self.select(values.keys(), where)
+        if selection and len(selection) > 0:
+            self.update(values, where)
+        else:
+            self.insert(values)
+
+
+class Select(SQLCommandExecutable):
+    def __init__(self, database: EasyDatabase, columns: Collection[EasyColumn] = None, table: EasyTable = None, where: Where = None):
+        if table and columns:
+            table.assert_columns(columns)
+
+        self._database = database
+        self._table = table
+        self._columns = columns
+        self._where = where
+
+    def _asserts(self):
+        if self._table is None:
+            raise MissingArgumentException('Table is missing.')
+        self._table.assert_columns(self._columns)
+
+    def where(self, where: Where):
+        self._where = self._where or where
+        return self
+
+    def from_table(self, table: EasyTable):
+        self._table = self._table or table
+        return self
+
+    def get_value(self) -> str:
+        self._asserts()
+        columns = ', '.join([column.name for column in self._columns]) if self._columns else '*'
+        return f"SELECT {columns} FROM {self._table.name}" + (f' {self._where.get_value()};' if self._where else ";")
+
+    def execute(self):
+        self._asserts()
+        result = self._database.execute(self.get_value(), auto_commit=False).fetchall()
+        columns = self._columns if self._columns else self._table.columns
+        new_result = []
+        for item in result:
+            new_result.append(tuple([columns[i].cast(item[i]) for i in range(len(columns))]))
+        return new_result
+
+
+class Insert(SQLCommandExecutable):
+    def __init__(self, database: EasyDatabase, values: Dict[EasyColumn, Any], table: EasyTable = None):
+        if table:
+            table.assert_columns(values.keys())
+
+        self._database = database
+        self._values = values
+        self._table = table
+
+    def _asserts(self):
+        if self._table is None:
+            raise MissingArgumentException('Table is missing.')
+        self._table.assert_columns(self._values.keys())
+
+    def into_table(self, table: EasyTable):
+        self._table = self._table or table
+        return self
+
+    def get_value(self) -> str:
+        self._asserts()
+        columns = ', '.join([column.name for column in self._values.keys()])
+        values = ', '.join([column.parse(value) for column, value in self._values.items()])
+        return f"INSERT INTO {self._table.name} ({columns}) VALUES ({values});"
+
+    def execute(self):
+        self._asserts()
+        command = self.get_value()
+        return self._database.execute(command).lastrowid
+
+
+# noinspection SqlWithoutWhere
+# The asserts will not allow the missing where
+class Update(SQLCommandExecutable):
+    def __init__(self, database: EasyDatabase, values: Dict[EasyColumn, Any], table: EasyTable = None, where: Where = None):
+        if table:
+            table.assert_columns(values.keys())
+
+        self._database = database
+        self._values = values
+        self._table = table
+        self._where = where
+
+    def _asserts(self, safety: bool = True):
+        if self._table is None:
+            raise MissingArgumentException('Table is missing.')
+        self._table.assert_columns(self._values.keys())
+
+        if self._database.safe and safety:
+            if self._where is None:
+                raise DatabaseSafetyException('Safety Warning: Update without any condition is prohibited.')
+
+    def table(self, table: EasyTable):
+        self._table = self._table or table
+        return self
+
+    def where(self, where: Where):
+        self._where = self._where or where
+        return self
+
+    def get_value(self) -> str:
+        self._asserts(safety=False)
+        columns = ', '.join([column.name for column in self._values.keys()])
+        set_command = ', '.join([f'{column.name} = {column.parse(value)}' for column, value in self._values.items()])
+        return f"UPDATE {self._table.name} SET {set_command}" + f' {self._where.get_value()};' if self._where else ";"
+
+    def execute(self):
+        self._asserts()
+        command = self.get_value()
+        return self._database.execute(command).lastrowid
+
+
+# noinspection SqlWithoutWhere
+# The asserts will not allow the missing where
+class Delete(SQLCommandExecutable):
+    def __init__(self, database: EasyDatabase, table: EasyTable = None, where: Where = None):
+        self._database = database
+        self._table = table
+        self._where = where
+
+    def _asserts(self, safety: bool = True):
+        if self._table is None:
+            raise MissingArgumentException('Table is missing.')
+
+        if self._database.safe:
+            if self._where is None and safety:
+                raise DatabaseSafetyException('Safety Warning: Delete without any condition is prohibited.')
+
+    def where(self, where: Where):
+        self._where = self._where or where
+        return self
+
+    def from_table(self, table: EasyTable):
+        self._table = self._table or table
+        return self
+
+    def get_value(self) -> str:
+        self._asserts(safety=False)
+        return f"DELETE FROM {self._table.name}" + f' {self._where.get_value()};' if self._where else ";"
+
+    def execute(self):
+        self._asserts()
+        command = self.get_value()
+        return self._database.execute(command).lastrowid

PyEasySQL-1.0/EasySQL/Exceptions.py

@@ -0,0 +1,31 @@
+class MissingArgumentException(Exception):
+    def __init__(self, message):
+        self.message = message
+
+    def __repr__(self):
+        return f'<MissingArgumentException "{self.message}">'
+
+    def __str__(self):
+        return self.message
+
+
+class MisMatchException(Exception):
+    def __init__(self, message):
+        self.message = message
+
+    def __repr__(self):
+        return f'<MisMatchException "{self.message}">'
+
+    def __str__(self):
+        return self.message
+
+
+class DatabaseSafetyException(Exception):
+    def __init__(self, message):
+        self.message = message
+
+    def __repr__(self):
+        return f'<DatabaseSafetyException "{self.message}">'
+
+    def __str__(self):
+        return self.message

PyEasySQL-1.0/EasySQL/Logging.py

@@ -0,0 +1,18 @@
+import logging
+import sys
+
+logger = logging.getLogger('EasySQL')
+formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+handler = logging.StreamHandler(sys.stdout)
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+
+
+def enable_debug():
+    logger.setLevel(logging.DEBUG)
+    handler.setLevel(logging.DEBUG)
+
+
+def disable_debug():
+    logger.setLevel(logging.INFO)
+    handler.setLevel(logging.INFO)

PyEasySQL-1.0/EasySQL/Types.py

@@ -0,0 +1,133 @@
+from .ABC import SQLType
+
+
+class INTEGER(SQLType):
+    @property
+    def name(self):
+        return 'INT'
+
+    def parse(self, value):
+        return f'{int(value)}'
+
+    @property
+    def default(self):
+        return 0
+
+    def cast(self, value):
+        return int(value)
+
+
+class STRING(SQLType):
+    def __init__(self, size: int = 255):
+        self.size = size
+
+    @property
+    def name(self):
+        return f'VARCHAR({self.size})'
+
+    def parse(self, value):
+        return f"'{str(value)}'"
+
+    @property
+    def default(self):
+        return ''
+
+    def cast(self, value):
+        return str(value)
+
+
+class BIT(SQLType):
+    def __init__(self, size: int = 1):
+        self.size = size
+
+    @property
+    def name(self):
+        return f'BIT({self.size})'
+
+    def parse(self, value):
+        return f'{int(value)}'
+
+    @property
+    def default(self):
+        return 0
+
+    def cast(self, value):
+        return int(value)
+
+
+class FLOAT(SQLType):
+    @property
+    def name(self):
+        return 'FLOAT'
+
+    def parse(self, value):
+        return f'{float(value)}'
+
+    @property
+    def default(self):
+        return 0
+
+    def cast(self, value):
+        return float(value)
+
+
+class DOUBLE(SQLType):
+    def __init__(self, size: int = 12, dec: int = 6):
+        self.size = size
+        self.dec = dec
+
+    @property
+    def name(self):
+        return f'DOUBLE({self.size},{self.dec})'
+
+    def parse(self, value):
+        return f'{float(value)}'
+
+    @property
+    def default(self):
+        return 0
+
+    def cast(self, value):
+        return float(value)
+
+
+class DECIMAL(SQLType):
+    def __init__(self, size: int = 12, dec: int = 6):
+        self.size = size
+        self.dec = dec
+
+    @property
+    def name(self):
+        return f'DECIMAL({self.size},{self.dec})'
+
+    def parse(self, value):
+        return f'{float(value)}'
+
+    @property
+    def default(self):
+        return 0
+
+    def cast(self, value):
+        return float(value)
+
+
+class BOOL(SQLType):
+    @property
+    def name(self):
+        return f'BIT(1)'
+
+    def parse(self, value):
+        return f'1' if value else f'0'
+
+    @property
+    def default(self):
+        return False
+
+    def cast(self, value):
+        return True if value else False
+
+
+INT = INTEGER
+DEC = DECIMAL
+VARCHAR = STRING
+CHAR = STRING

PyEasySQL-1.0/EasySQL/Where.py

@@ -0,0 +1,69 @@
+from .ABC import SQLCommand
+
+
+class Where(SQLCommand):
+    def __init__(self, sql_string):
+        self.value = sql_string
+
+    def get_value(self) -> str:
+        return f'WHERE {self.value}'
+
+    def AND(self, other: 'Where'):
+        return Where(f'({self.value} AND {other.value})')
+
+    def OR(self, other: 'Where'):
+        return Where(f'({self.value} OR {other.value})')
+
+    def NOT(self):
+        return Where(f'NOT {self.value}')
+
+
+class WhereIsEqual(Where):
+    def __init__(self, column, value):
+        super().__init__(f'{column.name} = {column.parse(value)}')
+
+
+class WhereIsNotEqual(Where):
+    def __init__(self, column, value):
+        super().__init__(f'{column.name} <> {column.parse(value)}')
+
+
+class WhereIsGreater(Where):
+    def __init__(self, column, value):
+        super().__init__(f'{column.name} > {column.parse(value)}')
+
+
+class WhereIsGreaterEqual(Where):
+    def __init__(self, column, value):
+        super().__init__(f'{column.name} => {column.parse(value)}')
+
+
+class WhereIsLesser(Where):
+    def __init__(self, column, value):
+        super().__init__(f'{column.name} < {column.parse(value)}')
+
+
+class WhereIsLesserEqual(Where):
+    def __init__(self, column, value):
+        super().__init__(f'{column.name} =< {column.parse(value)}')
+
+
+class WhereIsLike(Where):
+    def __init__(self, column, value):
+        super().__init__(f'{column.name} LIKE {column.parse(value)}')
+
+
+class WhereIsIn(Where):
+    def __init__(self, column, values):
+        values = (column.parse(value) for value in values)
+        super().__init__(f'{column.name} IN {values}')
+
+
+class WhereIsBetween(Where):
+    def __init__(self, column, a, b):
+        values = (column.parse(a), column.parse(b))
+        super().__init__(f'{column.name} = {values}')
+
+
+__all__ = ['Where', 'WhereIsEqual', 'WhereIsNotEqual', 'WhereIsGreater', 'WhereIsLesser',
+           'WhereIsGreaterEqual', 'WhereIsLesserEqual', 'WhereIsLike', 'WhereIsIn', 'WhereIsBetween']

PyEasySQL-1.0/EasySQL/__init__.py

@@ -0,0 +1,6 @@
+from .ABC import *
+from .Classes import *
+from .Logging import enable_debug, disable_debug
+from .Types import *
+from .Where import *
+from .Exceptions import *

PyEasySQL-1.0/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.1
+Name: PyEasySQL
+Version: 1.0
+Summary: SQL Database management without even a SQL line
+Home-page: https://github.com/ashengaurd/easysql
+Author: Ashenguard
+Author-email: Ashenguard@agmdev.com
+License: MIT License
+Description: # EasySQL
+        This library allow you to run SQL Databases without knowing even SQL.  
+        This library will create SQL queries and execute them as you request and is very simple to use.
+        
+        
+        ## How to install
+        To install just use following command
+        ```shell
+        pip install EasySQL
+        ```
+        This library will have dev/beta builds on the github, to install them you can use
+        ```shell
+        pip install --upgrade git+https://github.com/Ashengaurd/EasySQL.git
+        ```
+        ***
+        By installing this library following libraries and their dependencies will be installed too.
+        > mysql-connector: Which is the basic library for connecting to database
+        
+        # Examples
+        
+        ```python
+        import EasySQL
+        
+        # Define database which will be needed by any table you create.
+        database = EasySQL.EasyDatabase(host='127.0.0.1', port=3306,
+                                        database='DatabaseName',
+                                        user='username', password='PASSWORD')
+        
+        # Define tables and columns
+        col1 = EasySQL.EasyColumn('ID', EasySQL.INT(), primary=True, auto_increment=True)
+        col2 = EasySQL.EasyColumn('Name', EasySQL.STRING(256), not_null=True, default='Missing')
+        col3 = EasySQL.EasyColumn('Premium', EasySQL.BOOL(), not_null=True)
+        
+        table = EasySQL.EasyTable(database, 'Users', [col1, col2, col3])
+        
+        # Insert values with a simple command
+        table.insert({'Name': 'Ashenguard', 'Premium': True})
+        table.insert({col2: 'Sam', col3: False})
+        
+        # Select data with another simple command
+        # It will return a list of tuples which meet conditions
+        all = table.select()
+        premiums = table.select(['ID', 'Name'], EasySQL.WhereIsEqual(col3, True))
+        specific = table.select(['Name'], where=EasySQL.WhereIsLike(col2, "Ash%").AND(EasySQL.WhereIsLesserEqual(col1, 5)))
+        
+        # Delete data with a more simpler command
+        table.delete(EasySQL.WhereIsGreater(col1, 5))
+        
+        # Update data with following command
+        table.update({'Premium': True}, EasySQL.WhereIsEqual(col1, 3).OR(EasySQL.WhereIsEqual(col2, 'Sam')))
+        
+        # Not sure if you should update or insert? Use set and it will be handled
+        table.set({'ID': 5, 'Name': 'Nathaniel', 'Premium': False}, where=EasySQL.WhereIsEqual(col1, 5))
+        
+        # Safety error on delete/update/set without a where statement
+        # table.delete() -> raise EasySQL.DatabaseSafetyException
+        # Turn the safety off with following command.
+        database.remove_safety(confirm=True)
+        # Now there will be no error, it will clean the all data that's why we had safety lock
+        table.delete()
+        ```
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown

PyEasySQL-1.0/PyEasySQL.egg-info/PKG-INFO

@@ -0,0 +1,76 @@
+Metadata-Version: 2.1
+Name: PyEasySQL
+Version: 1.0
+Summary: SQL Database management without even a SQL line
+Home-page: https://github.com/ashengaurd/easysql
+Author: Ashenguard
+Author-email: Ashenguard@agmdev.com
+License: MIT License
+Description: # EasySQL
+        This library allow you to run SQL Databases without knowing even SQL.  
+        This library will create SQL queries and execute them as you request and is very simple to use.
+        
+        
+        ## How to install
+        To install just use following command
+        ```shell
+        pip install EasySQL
+        ```
+        This library will have dev/beta builds on the github, to install them you can use
+        ```shell
+        pip install --upgrade git+https://github.com/Ashengaurd/EasySQL.git
+        ```
+        ***
+        By installing this library following libraries and their dependencies will be installed too.
+        > mysql-connector: Which is the basic library for connecting to database
+        
+        # Examples
+        
+        ```python
+        import EasySQL
+        
+        # Define database which will be needed by any table you create.
+        database = EasySQL.EasyDatabase(host='127.0.0.1', port=3306,
+                                        database='DatabaseName',
+                                        user='username', password='PASSWORD')
+        
+        # Define tables and columns
+        col1 = EasySQL.EasyColumn('ID', EasySQL.INT(), primary=True, auto_increment=True)
+        col2 = EasySQL.EasyColumn('Name', EasySQL.STRING(256), not_null=True, default='Missing')
+        col3 = EasySQL.EasyColumn('Premium', EasySQL.BOOL(), not_null=True)
+        
+        table = EasySQL.EasyTable(database, 'Users', [col1, col2, col3])
+        
+        # Insert values with a simple command
+        table.insert({'Name': 'Ashenguard', 'Premium': True})
+        table.insert({col2: 'Sam', col3: False})
+        
+        # Select data with another simple command
+        # It will return a list of tuples which meet conditions
+        all = table.select()
+        premiums = table.select(['ID', 'Name'], EasySQL.WhereIsEqual(col3, True))
+        specific = table.select(['Name'], where=EasySQL.WhereIsLike(col2, "Ash%").AND(EasySQL.WhereIsLesserEqual(col1, 5)))
+        
+        # Delete data with a more simpler command
+        table.delete(EasySQL.WhereIsGreater(col1, 5))
+        
+        # Update data with following command
+        table.update({'Premium': True}, EasySQL.WhereIsEqual(col1, 3).OR(EasySQL.WhereIsEqual(col2, 'Sam')))
+        
+        # Not sure if you should update or insert? Use set and it will be handled
+        table.set({'ID': 5, 'Name': 'Nathaniel', 'Premium': False}, where=EasySQL.WhereIsEqual(col1, 5))
+        
+        # Safety error on delete/update/set without a where statement
+        # table.delete() -> raise EasySQL.DatabaseSafetyException
+        # Turn the safety off with following command.
+        database.remove_safety(confirm=True)
+        # Now there will be no error, it will clean the all data that's why we had safety lock
+        table.delete()
+        ```
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown

PyEasySQL-1.0/PyEasySQL.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+setup.py
+EasySQL/ABC.py
+EasySQL/Classes.py
+EasySQL/Exceptions.py
+EasySQL/Logging.py
+EasySQL/Types.py
+EasySQL/Where.py
+EasySQL/__init__.py
+PyEasySQL.egg-info/PKG-INFO
+PyEasySQL.egg-info/SOURCES.txt
+PyEasySQL.egg-info/dependency_links.txt
+PyEasySQL.egg-info/requires.txt
+PyEasySQL.egg-info/top_level.txt

PyEasySQL-1.0/PyEasySQL.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

PyEasySQL-1.0/PyEasySQL.egg-info/requires.txt

@@ -0,0 +1 @@
+mysql-connector

PyEasySQL-1.0/PyEasySQL.egg-info/top_level.txt

@@ -0,0 +1 @@
+EasySQL

PyEasySQL-1.0/README.md

@@ -0,0 +1,61 @@
+# EasySQL
+This library allow you to run SQL Databases without knowing even SQL.  
+This library will create SQL queries and execute them as you request and is very simple to use.
+
+
+## How to install
+To install just use following command
+```shell
+pip install EasySQL
+```
+This library will have dev/beta builds on the github, to install them you can use
+```shell
+pip install --upgrade git+https://github.com/Ashengaurd/EasySQL.git
+```
+***
+By installing this library following libraries and their dependencies will be installed too.
+> mysql-connector: Which is the basic library for connecting to database
+
+# Examples
+
+```python
+import EasySQL
+
+# Define database which will be needed by any table you create.
+database = EasySQL.EasyDatabase(host='127.0.0.1', port=3306,
+                                database='DatabaseName',
+                                user='username', password='PASSWORD')
+
+# Define tables and columns
+col1 = EasySQL.EasyColumn('ID', EasySQL.INT(), primary=True, auto_increment=True)
+col2 = EasySQL.EasyColumn('Name', EasySQL.STRING(256), not_null=True, default='Missing')
+col3 = EasySQL.EasyColumn('Premium', EasySQL.BOOL(), not_null=True)
+
+table = EasySQL.EasyTable(database, 'Users', [col1, col2, col3])
+
+# Insert values with a simple command
+table.insert({'Name': 'Ashenguard', 'Premium': True})
+table.insert({col2: 'Sam', col3: False})
+
+# Select data with another simple command
+# It will return a list of tuples which meet conditions
+all = table.select()
+premiums = table.select(['ID', 'Name'], EasySQL.WhereIsEqual(col3, True))
+specific = table.select(['Name'], where=EasySQL.WhereIsLike(col2, "Ash%").AND(EasySQL.WhereIsLesserEqual(col1, 5)))
+
+# Delete data with a more simpler command
+table.delete(EasySQL.WhereIsGreater(col1, 5))
+
+# Update data with following command
+table.update({'Premium': True}, EasySQL.WhereIsEqual(col1, 3).OR(EasySQL.WhereIsEqual(col2, 'Sam')))
+
+# Not sure if you should update or insert? Use set and it will be handled
+table.set({'ID': 5, 'Name': 'Nathaniel', 'Premium': False}, where=EasySQL.WhereIsEqual(col1, 5))
+
+# Safety error on delete/update/set without a where statement
+# table.delete() -> raise EasySQL.DatabaseSafetyException
+# Turn the safety off with following command.
+database.remove_safety(confirm=True)
+# Now there will be no error, it will clean the all data that's why we had safety lock
+table.delete()
+```

PyEasySQL-1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

PyEasySQL-1.0/setup.py

@@ -0,0 +1,26 @@
+import setuptools
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name="PyEasySQL",
+    version="1.0",
+    license='MIT License',
+    author="Ashenguard",
+    author_email="Ashenguard@agmdev.com",
+    description="SQL Database management without even a SQL line",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/ashengaurd/easysql",
+    packages=setuptools.find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Development Status :: 5 - Production/Stable",
+        "Operating System :: OS Independent",
+    ],
+    python_requires='>=3.6',
+    include_package_data=True,
+    install_requires=["mysql-connector"],
+)