used generators as custom functions, added condition to check if args are provided in tuple, re wrote the documentation.

Author: Pyloris

.gitignore

@@ -1,2 +1,4 @@
 src/sqlsy.egginfo*
 src/sqlsy/__pycache__/*
+dist/*
+

README.md

@@ -1,4 +1,6 @@
 # sqlsy
+![badge4](https://img.shields.io/badge/MIT-License-red)
+![badge3](https://img.shields.io/badge/version-v1.0.0-magenta)
 ![badge1](https://img.shields.io/static/v1?label=python%203&message=SQL&color=blue)
 ![badge2](https://img.shields.io/static/v1?label=easy&message=install&color=green)
 
@@ -9,7 +11,8 @@ A simple Python Module to easy fill your sql tables with data.
 pip install sqlsy
 ```
 
-A python module to easy filling in dummy data insde mysql databases.
+## Quick Usage
+A simple script to fill in data inside of a mysql table
 
 ```python
 from sqlsy import Engine
@@ -19,63 +22,99 @@ from sqlsy import Int, VarChar      # sql datatypes to define schema
 config = {
   'user':'username',
   'password':'pas@word',
-  'host':'localhost'
+  'host':'localhost',
+  'database':'dbName'   # database to use: optional as it can be selected using a method
 }
 
-# define the schema of the table to fill
+# custom function should be a generator
+def get_id(n1, n2):
+  i = n1
+  while i < n2:
+    yield i
+    i += 1
 
+# define the schema of the table to fill
 # hook specifies what data to generate
 schema = {
-  'id':Int(hook='sequence', args=[0,30]),     # generates numbers 0 - 30 including 30
+  'id':Int(custom_func=get_id(0,30)),     # generates numbers 0 - 30 including 30
   'name':VarChar(hook='name'),        # here generate fake names
-  'job':VarChar(hook='job')           # here generate fake jobs
+  'ph_number':VarChar(hook='phone_number')           # here generate fake jobs
 }
 
 
 # create engine instance
 engine = Engine(config)
 
-# create a database to store above table, if not already created
-engine.create_db('employee')
-
-# create the table with above schema
-engine.create_table('person', schema)
-
+# ASSUMING that the table is already created
 # call the method to fill in the table
 # 101 rows as id can take values from 0 to 30 = 31
 engine.fill_table("person", schema, 31)       # give it tablename, schema of table and no of rows.
 
 # print the table if you want
 engine.print_table("table_name")
 
-# delete all the data added to the table
-engine.clear_table("table_name")
+# close the connection
+engine.close()
+```
 
-# drop the database if you want to
-engine.drop_db("employee")
+## API provided by Engine Class
+The API include following methods and attributes:
+Let the `engine` be an instance of `Engine` class
+```python
+engine = Engine(config)
 ```
+### Attributes
+- `engine.config` : Stores the provided config for mysql api connection
+- `engine.conn` : It is what stores the connection object after connection is opened.
+- `engine.cursor` : It stores the cursor to execute queries on the database.
+
+## Methods
+- `engine.fetch(table_name, [col_name1, col_name2])` : Grab the data from the specified columns directly
+
+- `engine.create_db(database_name)` : Creates a database with name as provided in argument.
 
-![image](https://user-images.githubusercontent.com/76217003/230254219-aafe049f-93cd-45ff-ab97-22d960785add.png)
+- `engine.create_table(table_name, schema)` : Creates a table with the specified Schema.
 
+- `engine.drop_db(db_name)` : Drops the database if it exists
+
+- `engine.drop_table(tb_name)` : Drops the table if it exists
+
+- `engine.fill_table(tb_name, tb_schema, n_rows)` : Fills the table with tb_name as name and tb_schema as schema with n_rows of data. Make sure the provided hooks or custom_functions generate equal to or more than n_rows of data.
+
+- `engine.print_table(tb_name)` : It prints the table in pretty format for you to see.
+
+- `engine.clear_table(tb_name)` : It removes all the data from the table with provided table name
+
+- `engine.close()` : It closes the connection to the database. If not called, the connection will be closed when `engine` object is destroyed.
 
 # Schema Functions to specify datatypes
-`Int` - means "INT" of SQL.
 
-`Float` - means "Float" of SQL. Doesnt support size and pricision as recommended by the Mysql docs.
+### How to Describe Schema
+> Schema can be describe by using the provided functions which are documented below:
+
+1. `Int` - means "INT" of SQL.
+
+2. `Float` - means "Float" of SQL. Doesnt support size and pricision as recommended by the Mysql docs.
+
+3. `Char` - means "CHAR" of SQL. By default of size 255.
+
+4. `VarChar` - means "VARCHAR" of SQL. By default of size 255 # does not take size like in SQL.
 
-`Char` - means "CHAR" of SQL. By default of size 255.
+### Equivalent to SQL counterparts
+`Date`, `DateTime`, `Time`, `Timestamp`
 
-`VarChar` - means "VARCHAR" of SQL. By default of size 255 # does not take size like in SQL.
+# How Data is Generated
+This module is designed such that the below provided hooks actually are mapped to functions which are responsible for data generation.
 
-`Date` - means DATE of sql, `DateTime`, `Time` and `Timestamp`
+Below are the Hooks which can be used to generate data automatically, also Custom Generator functions can be provided which will then be called to generate data.
 
 
-# Hooks
-### Int/Float
+### Hooks for Int / Float type data
 `random_int` : generates random integers - provide range with arguments
 ```python
+# schema description
 tb_name = {
-  'age':Int(hook='random_int', args=[10,50])
+  'age':Int(hook='random_int', args=(10,50))
 }
 ```
 
@@ -85,26 +124,26 @@ tb_name = {
 
 ```python
 schema = {
-  'id':Float(hook='random_float', args=[50,200])
+  'id':Float(hook='random_float', args=(50,200))
 }
 ```
 
 `sequence` : generates sequenctial numbers from the range given using `args`.
 
 ```python
 schema = {
-  'id':Int(hook='sequence', args=[50,100])
+  'id':Int(hook='sequence', args=(50,100))
 }
 ```
 
 `random_choice` : Randomly chooses values from a given list
 ```python
 schema = {
-  'stream':VarChar(hook='random_choice', args=[['bca', 'btech', 'commerce', 'mtech']])
+  'stream':VarChar(hook='random_choice', args=(['bca', 'btech', 'commerce', 'mtech']))
 }
 ```
 
-### VarChar/Char
+### Hooks for VarChar / Char type data
 `name` : generates full names
 
 `first_name` : generates first names
@@ -124,7 +163,7 @@ schema = {
 `phone_number` : generates phone numbers
 
 
-### Date/DateTime/Time/Timestamp
+### Hooks for Date/DateTime/Time/Timestamp type data
 
 `future_datetime` : generates a future datetime
 

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sqlsy"
-version = "0.0.4"
+version = "1.0.0"
 description = "Fill your database Quickly with dummy data"
 readme = "README.md"
 authors = [{ name="shoaib wani", email="shoaibwani010@gmail.com"}]

src/sqlsy/__init__.py

@@ -0,0 +1,2 @@
+from .engine import Engine
+from .schema import Int, VarChar, Float, Char, Date, DateTime, Time, Timestamp

src/sqlsy/engine.py

@@ -20,8 +20,6 @@ class Engine:
 	def __init__(self, config: dir):
 		self.config = config
 		self.conn = self.connect_db()
-
-		# cursor
 		self.cursor = self.conn.cursor()
 
 
@@ -93,7 +91,7 @@ def create_table(self, tb_name:str, schema:dir):
 	# drop the database
 	def drop_db(self, db_name):
 		try:
-			self.cursor.execute("drop database {}".format(db_name))
+			self.cursor.execute("drop database if exists {}".format(db_name))
 			self.conn.commit()
 			cprint("[+] Dropped {} database".format(db_name), 'blue')
 		except mysql.connector.Error as err:
@@ -103,7 +101,7 @@ def drop_db(self, db_name):
 	# drop the table
 	def drop_table(self, tb_name):
 		try:
-			self.cursor.execute("drop table {}".format(tb_name))
+			self.cursor.execute("drop table if exists {}".format(tb_name))
 			self.conn.commit()
 			cprint("[+] Dropped Table {}".format(tb_name), 'blue')
 		except mysql.connector.Error as err:
@@ -160,15 +158,20 @@ def fill_table(self, table_name:str, schema:dict, n: int):
 
 		for i in track(range(n), description=colored(f"[+] Working on {table_name}: ", 'blue')):
 			data.clear()
-
-			for col,attr in zip(schema.keys(),schema.values()):
-				self.set_col(col)
-				if attr['args'] == None:
-					data.append(attr['callback']())
-				else:
-					# pass the arguments in
-					data.append(attr['callback'](*attr['args']))
-
+			try:
+				for col,attr in zip(schema.keys(),schema.values()):
+					self.set_col(col)
+					if 'custom_flag' in attr.keys():
+						data.append(next(attr['callback']))
+					elif attr['args'] == None:
+						data.append(attr['callback']())
+					else:
+						# pass the arguments in
+						data.append(attr['callback'](*attr['args']))
+			except StopIteration:
+				cprint("[x] The custom function generated less data then target rows!", "red")
+				self.clear_table(table_name)
+				exit(0)
 			try:
 				# add the data
 				self.cursor.execute(query % tuple(data))
@@ -216,10 +219,18 @@ def print_table(self, table_name:str):
 		# print the table
 		console.print(table)
 
+	def close(self):
+		try:
+			self.conn.close()
+			cprint("[+] Closed the Connection to database", "green")
+		except mysql.connector.Error as err:
+			cprint('[x] Couldnt close the connection : {}'.format(err), "red")
+
 
 	def __del__(self):
 		try:
-			self.conn.close()
-			cprint("[+] Closed the connection to mysql", "green")
+			if self.conn.is_connected():
+				self.conn.close()
+				cprint("[+] Closed the connection to mysql", "green")
 		except mysql.connector.Error as err:	
 			cprint("[x] Couldn't close connection : {}".format(err), "red")

src/sqlsy/schema.py

@@ -4,17 +4,23 @@
 ####
 
 from termcolor import cprint
-from .mapping import mapping
+from .utils.mapping import mapping
 
 
 #  Sql datatypes
 def datatype(func):
-	def sql_dtype(*, hook=None, custom_func=None, args:list = None, constraints:list=None):
+	def sql_dtype(hook=None, custom_func=None, args:tuple = None, constraints:list=None):
 
 		mini_scheme = {}
 
 		# store the args
-		mini_scheme['args'] = args
+		if args and isinstance(args, tuple):
+			mini_scheme['args'] = args
+		elif args:
+			cprint("[x] Provide Arugments in a Tuple", 'red')
+			exit(1)
+		else:
+			mini_scheme['args'] = args
 		mini_scheme['constraints'] = constraints
 
 		# check for data generator
@@ -23,6 +29,8 @@ def sql_dtype(*, hook=None, custom_func=None, args:list = None, constraints:list
 			throw()
 
 		elif custom_func:
+			# set flag for custom function
+			mini_scheme['custom_flag'] = True
 			mini_scheme['callback'] = custom_func
 
 		elif hook:
@@ -36,50 +44,50 @@ def sql_dtype(*, hook=None, custom_func=None, args:list = None, constraints:list
 
 
 @datatype
-def Int(*, hook=None, custom_func=None, args:list=None, this=None):
+def Int(hook=None, custom_func=None, args:list=None, this=None):
 	# used in dynamic query building
 	this['type'] = 'int'
 	return this
 
 
 @datatype
-def Float(*, hook=None, custom_func=None, args:list=None, this=None):
+def Float(hook=None, custom_func=None, args:list=None, this=None):
 	# store the float type
 	this['type'] = 'float'
 	return this
 
 
 @datatype
-def Char(*, hook=None, custom_func=None, args:list=None, this=None):
+def Char(hook=None, custom_func=None, args:list=None, this=None):
 	this['type'] = 'char(255)'
 	return this
 
 
 @datatype
-def VarChar(*, hook=None, custom_func=None, args:list = None, this=None):
+def VarChar(hook=None, custom_func=None, args:list = None, this=None):
 	this['type'] = 'varchar(255)'
 	return this
 
 
 @datatype
-def Date(*, hook=None, custom_func=None, args:list = None, this=None):
+def Date(hook=None, custom_func=None, args:list = None, this=None):
 	this['type'] = 'date'
 	return this
 
 
 @datatype
-def Time(*, hook=None, custom_func=None, args:list = None, this=None):
+def Time(hook=None, custom_func=None, args:list = None, this=None):
 	this['type'] = 'time'
 	return this
 
 
 @datatype
-def DateTime(*, hook=None, custom_func=None, args:list = None, this=None):
+def DateTime(hook=None, custom_func=None, args:list = None, this=None):
 	this['type'] = 'datetime'
 	return this
 
 
 @datatype
-def Timestamp(*, hook=None, custom_func=None, args:list = None, this=None):
+def Timestamp(hook=None, custom_func=None, args:list = None, this=None):
 	this['type'] = 'timestamp'
 	return this