KL-Py 0.3.3__tar.gz → 0.3.4__tar.gz

{kl_py-0.3.3 → kl_py-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: KL_Py
-Version: 0.3.3
+Version: 0.3.4
 Summary: A Python simplification module
 Author-email: Abbaskhurram255 <abbaskhurram255@gmail.com>
 Classifier: Programming Language :: Python :: 3

{kl_py-0.3.3 → kl_py-0.3.4}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "KL_Py"
-version = "0.3.3"
+version = "0.3.4"
 authors = [
     { name = "Abbaskhurram255", email = "abbaskhurram255@gmail.com" }
 ]

kl_py-0.3.4/src/KL_Py/_custom_sqlite.py

@@ -0,0 +1,345 @@
+from .KL_Py import *
+from KL_Py import KL_Py
+import sqlite3 as sql
+from ._translate import translate_for_sql
+
+class SQL:
+	def __init__(
+		self,
+		filename: str = "test",
+		db: str = None,
+		errors: bool = False,
+		warnings: bool = True
+	):
+			self.conn = None
+			self.cursor = None
+			errors = str(errors)\
+				.lower() in (
+					"true",
+					"yes",
+					"show"
+				)
+			self.errors = errors
+			warnings = str(warnings)\
+				.lower() in (
+					"true",
+					"yes",
+					"show"
+				)
+			filename = db\
+				if isinstance(db, str)\
+					and str(db).strip()\
+				else filename
+			filename = str(filename)\
+				if filename is not None\
+				else "test"
+			if filename != ":memory:":
+				if not filename.endswith(".db"):
+					filename += ".db"
+				if not os.path.exists(
+					filename
+				):
+						print(
+							f"Info:\n\tNo such database file:"\
+								+ f"\n\t\t{filename!r}."\
+								+ "\n\tCreating one from scratch..."
+						)
+			try:
+				self.conn = sql.connect(
+					filename
+				)
+				self.cursor = self\
+					.conn\
+					.cursor()
+			except Exception as e:
+				if errors:
+					raise
+				if warnings:
+					print(
+						f"Warning:\n\t"\
+							+ "Failed to connect"\
+							+ "\n\tto the database."\
+							+ f"\n\tReason:\n\t\t{e}"\
+							+ "\n\n\tJust a silent\n\t"\
+							+ "warning before automated\n\t"\
+							+ "termination.\n\tUse errors=True"\
+							+ "\n\tto throw."
+					)
+	@classmethod
+	def connect(
+		cls,
+		*args,
+		**kwargs
+	) -> Self:
+			return cls(
+				*args,
+				**kwargs
+			)
+	conn = connect
+	def execute(
+		self,
+		command: str,
+		errors: bool = False,
+		warnings: bool = True,
+		fetch: int = -1,
+		f=None,
+		max_=None,
+		only=None,
+		sirf=None,
+		*args,
+		**kwargs
+	) ->\
+		Union[
+			list[
+				tuple[
+					Any,
+				]
+			],
+			tuple[
+				Any,
+			],
+			Self
+		]:
+			fetch = f\
+				or max_\
+				or only\
+				or sirf\
+				or fetch
+			if isinstance(
+				fetch,
+				float
+			):
+					fetch = int(
+						fetch
+					)
+			if not isinstance(
+				fetch,
+				int
+			):
+					fetch = -1
+			errors = str(errors)\
+				.lower() in (
+					"true",
+					"yes",
+					"show"
+				)
+			errors = errors or self.errors
+			warnings = str(warnings)\
+				.lower() in (
+					"true",
+					"yes",
+					"show"
+				)
+			warnings = warnings
+			if not (
+				self.conn\
+					and self.cursor\
+					and isinstance(
+						command,
+						str
+					)\
+					and str(
+						command
+					).strip()
+			)\
+				and not errors:
+					if warnings:
+						print(
+							"Warning:\n\tNot connected to the database,"\
+								+ "\n\tor invalid SQL command syntax."\
+								+ "\n\n\tJust a silent\n\t"\
+								+ "warning before automated\n\t"\
+								+ "termination.\n\tUse errors=True"\
+								+ "\n\tto throw."
+						)
+					return self
+			try:
+				command = command\
+					.strip()
+				translated_command: str = translate_for_sql(
+					command
+				)
+				self.cursor.execute(
+					translated_command,
+					*args,
+					**kwargs
+				)
+				self.conn.commit()
+				if self.cursor\
+					and callable(
+						getattr(
+							self.cursor,
+							"fetchall"
+						)
+					)\
+					and "select"\
+						in translated_command\
+							.lower():
+								results: list = self.cursor\
+									.fetchall()
+								if results\
+									and 0 <= fetch <= len(results):
+										results_sliced = results[
+											:fetch
+										]
+										if len(results_sliced)\
+											== 1:
+												results_sliced =\
+													results_sliced[
+														0
+													]
+										return results_sliced
+								return results
+				return self
+			except Exception as e:
+				if errors:
+					raise
+				err_msg: str = str(e)
+				if "unique constraint failed" in err_msg\
+					.lower():
+						# this message is thrown
+						# when you add a duplicate
+						# value
+						# to a column
+						# with
+						# "UNIQUE"
+						# constraint
+						err_msg = ""
+				if warnings\
+					and err_msg:
+						print(
+							"Warning:\n\t"\
+								+ f"Suppressed"\
+								+ "\n\tSQL Error"\
+								+ "\n\ton execution:\n\t\t"\
+								+ f"{err_msg}\n\t\n\t"\
+								+ f"Inside Query:\n\t\t"\
+								+ translated_command\
+								+ "\n\n\tJust a silent\n\t"\
+								+ "warning before automated\n\t"\
+								+ "termination.\n\tUse errors=True"\
+								+ "\n\tto throw."
+						)
+			return self
+	apply =\
+		karo =\
+		apply_karo =\
+		do =\
+		run =\
+		exec =\
+		execute
+	def drop(
+		self,
+		table_name: str
+	) -> Self:
+			if not (
+				isinstance(table_name, str)\
+					and table_name\
+						.strip()
+			):
+				return self
+			table_name = table_name\
+				.strip()
+			drop_command: str = f"girao table agar mojud "+\
+				table_name
+			return self.execute(
+				drop_command
+			)
+	giraao =\
+		girao =\
+		drop
+	def clear(
+		self,
+		table_name: str
+	) -> Self:
+			if not (
+				isinstance(table_name, str)\
+					and table_name\
+						.strip()
+			):
+				return self
+			table_name = table_name\
+				.strip()
+			clear_command: str = f"saaf karo "+\
+				table_name
+			return self.execute(
+				clear_command,
+				warnings=False
+			)
+	saf =\
+		saf_karo =\
+		saaf =\
+		saaf_karo =\
+		clean =\
+		clear
+	def __call__(
+		self,
+		*args,
+		**kwargs
+	) ->\
+		Union[
+			list[
+				tuple[
+					Any,
+				]
+			],
+			tuple[
+				Any,
+			],
+			Self
+		]:
+				return self.execute(
+					*args,
+					**kwargs
+				)
+	def __enter__(
+		self
+	):
+			return self
+	def __exit__(
+		self,
+		*args,
+		**kwargs
+	):
+			return False
+DB =\
+	Db =\
+	db_conn =\
+	dbconn =\
+	db_connect =\
+	sql_conn =\
+	sqlconn =\
+	sql_connect =\
+	db = SQL
+
+"""
+
+
+def main() -> None:
+	with Db("test2") as db:
+		#db("saaf karo Users")
+		#db("girao table users")
+		query = "BANAO Table agar na mojud Users jisme mojud (id int khas a+, name jumla?   nahi_to  'Anonymous' alheda, age int | 0 mukhtalif, color jumla | 'white')"
+		db(query)
+		db(
+			"`users` me dalo (name, age): ('Jackson', 21)"
+		)(
+			"dalo darmyan `users` (name, age) inhe ('Becky', 22), ('Dammy', 29)"
+		)
+		db('''badlo Users
+		  naya name he 'Jack',
+		  aur age he 27,
+		  aur color he 'black'
+		  jaha name he 'Jackson'
+		'''
+		)
+		results = db(
+			"chuno mukhtlf Name Users mese jahan Name me he 'a'",
+			sirf=1
+		)
+		print(results)
+		
+if __name__ == "__main__":
+	main()
+	
+"""

{kl_py-0.3.3 → kl_py-0.3.4}/src/KL_Py/_translate.py

@@ -127,7 +127,7 @@ def translate_for_jupyter(code: str) -> None:
 		r"kaho": "print",
 		# match-case
 		r"aga?r[_ ]match(?= [^\n\t\:]+\:)": "match",
-		r"(?<=(?<!\w) {2})sath(?! (?:open|khola|[A-Za-z_]\w*\.connect) ?\()": "case",
+		r"(?<=(?<!\w) {2})sath(?! (?:open|khola|(?:[Ss][Qq][Ll]|[Dd][Bb])(?:(?:\.| k[aeio] )conn(?:ect)?)?|[A-Za-z_]\w*(?:\.| k[aeio] )conn(?:ect)?) *\()": "case",
 		# same keyword, different operations
 		# keep the sequence untouched
 		r"sath(?= [A-Za-z_])": "with",
@@ -1508,34 +1508,44 @@ def translate_for_sql(text: str) -> str:
 		or not str(text).strip():
 			return ""
 	dictionary: dict[str, str] = {
-		"bana{1,2}o": "create",
-		"chuno": "select",
-		"badlo": "update",
-		"rakho": "set",
-		"nahi_to|def|shurwat(?:i|[_ ]*me)": "default",
-		"nazaria|alias": "view",
-		"da{1,2}lo": "insert",
+		r"bana{1,2}o": "create",
+		r"chuno": "select",
+		r"badlo": "update",
+		r"rakho|nay?[ai]|ab": "set",
+		r"nahi[_ *]to|def|shurwat(?:i|[_ ]*me)": "default",
+		# similar key different
+		# functionality these 2:
+		# comes before
+		r"(?:al(?:ag|heda)|uni?que?|mukhta?li?f)(?= *[\w\(\*])": "distinct",
+		# comes after:
+		r"(?:al(?:ag|heda)|uni?que?|mukhta?li?f)": "unique",
+		# SEQUENCE IS
+		# IMPORTANT
+		# different from primary key
+		# that one's for keys like 'ID'
+		r"nazaria|alias": "view",
+		r"da{1,2}lo": "insert",
 		# duplicate replacement
 		# but for flexibility
 		# * stays untouched
 		# otherwise flexibility goes away
 		# do NOT remove ^
-		"darmya{1,2}n|b(?:i|ee)ch": "into",
-		"sab(?:[_ ]?kuch)?": "*",
+		r"darmya{1,2}n|b(?:i|ee)ch": "into",
+		r"sab(?:[_ ]?kuch)?": "*",
 		r"jaha{1,2}n?": "where",
 		r"sirf(?= \d)": "limit",
-		'bar[ai](?: he)?[_ ]ya[_ ]ba?ra{0,2}ba?r(?: he)?': '>=',
-		'chot[ai](?: he)?[_ ]ya[_ ]ba?ra{0,2}ba?r(?: he)?': '<=',
-		'bar[ai](?: he)?': '>',
-		'chot[ai](?: he)?': '<',
-		'(?<=,|(?<=,) )aur': '',
-		'aur': 'and',
-		'ya': 'or',
-		"nahi(?! moj(?:u|oo)d)(?: (?:ba?ra{0,2}ba?r )?he)?": "!=",
-		"(?:ba?ra{0,2}ba?r )?he": "=",
+		r'bar[ai](?: he)?[_ ]ya[_ ]ba?ra{0,2}ba?r(?: he)?': '>=',
+		r'chot[ai](?: he)?[_ ]ya[_ ]ba?ra{0,2}ba?r(?: he)?': '<=',
+		r'bar[ai](?: he)?': '>',
+		r'chot[ai](?: he)?': '<',
+		r'(?<=,|(?<=,) )aur': '',
+		r'aur': 'and',
+		r'ya': 'or',
+		r"nahi(?! moj(?:u|oo)d)(?: (?:ba?ra{0,2}ba?r )?he)?": "!=",
+		r"(?:ba?ra{0,2}ba?r )?he": "=",
 		# sequence matters
-		"gira{1,2}o": "drop",
-		"(?:clea[rn]|sa{1,2}f|kha{1,2}li)[_ ]*(?:karo|table)(?:[_ ]*table)?": "delete from",
+		r"gira{1,2}o": "drop",
+		r"(?:clea[rn]|sa{1,2}f|kha{1,2}li)[_ ]*(?:karo|table)(?:[_ ]*table)?": "delete from",
 		r"agar(?! *\()": "if",
 		# has more priority
 		# than agar( -> IIF
@@ -1555,28 +1565,80 @@ def translate_for_sql(text: str) -> str:
 		# chuno name, agar(age >= 18, 'Adult', 'Minor')
 		#   tor users_age_ranked
 		#   users mese
-		"na(?:hi)?(?= moj(?:u|oo)d)": "not",
-		"tor": "as",
-		"sath": "with",
-		"inhe|vals?": "values",
+		r"na(?:hi)?(?= moj(?:u|oo)d)": "not",
+		r"tor": "as",
+		r"sath": "with",
+		r"i(?:nh|s)e|vals?": "values",
 		# sequence matters
-		"moj(?:u|oo)d": "exists",
+		r"moj(?:u|oo)d": "exists",
 		# data types
-		"(?:str|jumla|lafz|text)(?: not null)?": "text not null",
-		"bint(?: not null)?": "bigint not null",
-		"int(?: not null)?": "integer not null",
-		"(?:fl(?:oa)?t|nr)(?: not null)?": "real not null",
-		"(?:bool|haal)(?: not null)?": "integer default 0 not null",
-		"[Ss]ach|[Hh]an": "true",
-		"[Jj]hoot|[Nn]ahi": "false",
-		"kha{1,2}s": "primary key",
-		"istama{1,2}l(?: db)?": "use",
-		"db": "database",
+		r"(?:str|jumla|lafz|text)(?: not null)?": "text not null",
+		r"bint(?: not null)?": "bigint not null",
+		r"int(?: not null)?": "integer not null",
+		r"(?:fl(?:oa)?t|nr)(?: not null)?": "real not null",
+		r"(?:bool|haal)(?: not null)?": "integer default 0 not null",
+		r"[Ss]ach|[Hh]an": "true",
+		r"[Jj]hoot|[Nn]ahi": "false",
+		r"kha{1,2}s": "primary key",
+		r"istama{1,2}l(?: db)?": "use",
+		r"db": "database",
 	}
-	translation: str = text.lower().strip().rstrip(";")
-	strings_and_column_names: list[str] = re.findall("[`\"\'][^`\"\']*[`\"\']", translation)
-	for i, string in enumerate(strings_and_column_names):
-		translation = translation.replace(string, f"__STRING_{i}__", 1)
+	translation: str = text\
+		.lower()\
+		.strip()\
+		.rstrip(";")
+	strings_and_column_names: list[str] = re.findall(
+		"[`\"\'][^`\"\']*[`\"\']",
+		translation
+	)
+	translation = replacei(
+		translation,
+		r"\bshuru[ _]*me *[\"\'](?<match>[^\"\']*)[\"\']",
+		"like '$match%'"
+	)
+	translation = replacei(
+		translation,
+		r"\bshuru[ _]*me[ _]*nahi *[\"\'](?<match>[^\"\']*)[\"\']",
+		"not like '$match%'"
+	)
+	translation = replacei(
+		translation,
+		r"\ba{1,2}khir[ _]*me *[\"\'](?<match>[^\"\']*)[\"\']",
+		"like '%$match'"
+	)
+	translation = replacei(
+		translation,
+		r"\ba{1,2}khir[ _]*me[ _]*nahi *[\"\'](?<match>[^\"\']*)[\"\']",
+		"not like '%$match'"
+	)
+	translation = replacei(
+		translation,
+		r"\bme(?:[_ ]*(?:he|moj(?:u|oo)d))? *[\"\'](?<match>[^\"\']*)[\"\']",
+		"like '%$match%'"
+	)
+	translation = replacei(
+		translation,
+		r"\bme[_ ]*na(?:hi)?(?:[_ ]*(?:he|moj(?:u|oo)d))? *[\"\'](?<match>[^\"\']*)[\"\']",
+		"not like '%$match%'"
+	)
+	# ^ HAVE to appear RIGHT here
+	# not down there
+	# right before string
+	# replacements
+	# these 6 are
+	# the only replacements
+	# that have to occur
+	# BEFORE
+	# strings are turned
+	# into placeholders
+	for i, string in enumerate(
+		strings_and_column_names
+	):
+			translation = translation.replace(
+				string,
+				f"__STRING_{i}__",
+				1
+			)
 	translation = replace(
 		translation,
 		r"\s+",
@@ -1584,10 +1646,14 @@ def translate_for_sql(text: str) -> str:
 	)
 	# helps better deal with
 	# linebreaks, and tabs
-	translation = replacei(translation, r"\bjis[_ ]?me moj(?:u|oo)d \(*([^\(\)]+)\)*", "($1)")
 	translation = replacei(
 		translation,
-		r"(?<table_name>(?<!\w)`?[A-Za-z_][\w ]*`?) me da{1,2}lo\b",
+		r"\bjis[_ ]?me moj(?:u|oo)d \(*([^\(\)]+)\)*",
+		"($1)"
+	)
+	translation = replacei(
+		translation,
+		r"(?<table_name>(?<!\w)`*[A-Za-z_]\w*`*|`[A-Za-z_][\w ]*`) me da{1,2}lo\b",
 		"insert into $table_name"
 	)
 	# the right spot for this is ^
@@ -1599,21 +1665,67 @@ def translate_for_sql(text: str) -> str:
 			fr"\b({k})\b",
 			v
 		)
-	translation = replacei(translation, r"(?<table_name>(?<!\w)`?[A-Za-z_][\w ]*`?) me[_ ]?se\b", "from ${table_name}")
-	translation = replacei(translation, r"\b(?:a(?:uto)?|khud)[_ ]*(?:\+|barh(?:ti|e))(?!\w)", "autoincrement")
-	translation = replacei(translation, r" \b(not null)\?(?!\w)", "")
-	translation = replacei(translation, r" *\| *", " default ")
-	translation = replacei(translation, r"\b(?<dropping_this_to_prvt_a_lgcl_err>default false) (?<instead_keeping>(?:not null )?default [A-Za-z_]\w*)\b", "$instead_keeping")
+	translation = replacei(
+		translation,
+		r"(?<table_name>(?<!\w)`*[A-Za-z_]\w*`*|`[A-Za-z_][\w ]*`) me[_ ]?se\b",
+		"from ${table_name}"
+	)
+	translation = replacei(
+		translation,
+		r"\b(?:a(?:uto)?|khud)[_ ]*(?:\+|barh(?:ti|e))(?!\w)",
+		"autoincrement"
+	)
+	translation = replacei(
+		translation,
+		r" \b(not null)\?(?!\w)",
+		""
+	)
+	# ^ a potential bug fix
+	# do not remove
+	# this replacement
+	translation = replacei(
+		translation,
+		r"(?<=\)|(?<=\)|(?<=\)|(?<=\)) ) ) )\:(?= *\()",
+		" values "
+	)
+	# do not touch
+	# keep the replacements
+	# as-is
+	translation = replacei(
+		translation,
+		r" *\| *",
+		" default "
+	)
+	translation = replacei(
+		translation,
+		r"\b(?<dropping_this_to_prvt_a_lgcl_err>default false) (?<instead_keeping>(?:not null )?default [A-Za-z_]\w*)\b",
+		"$instead_keeping"
+	)
+	# ^ a potential bug fix 2
+	# do not remove
+	# this replacement
 	translation = replacei(translation, r"\b(?:begin|start|next)(?: transaction)?\:?(?!\w)", "begin transaction")
 	translation = replacei(translation, r"\b(end|upload|push|do)[\!\.]?(?!\w)", "commit")
 	translation = replacei(translation, r"\b(undo|revert|pop)[\!\.]?(?!\w)", "rollback")
-	translation = replacei(translation, r" \b(se|ke)\b", "")
-	# ^ mandatory logical fix
-	# do not drop the iterrogation mark ? at the end
-	# it stays
+	translation = replacei(translation, r" \b(?:se|k[aeio])\b", "")
+	translation = replace(
+		translation,
+		r"\s+",
+		" "
+	)
+	# optional
+	# final
+	# whitespace
+	# re-cleanup
+	# should happen BEFORE
+	# bringing back the strings
 	translation += ";"
 	for j, string in enumerate(strings_and_column_names):
-		translation = translation.replace(f"__STRING_{j}__", string, 1)
+		translation = translation.replace(
+			f"__STRING_{j}__",
+			string,
+			1
+		)
 	return translation
 
 def main() -> None:

{kl_py-0.3.3 → kl_py-0.3.4}/src/KL_Py.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: KL_Py
-Version: 0.3.3
+Version: 0.3.4
 Summary: A Python simplification module
 Author-email: Abbaskhurram255 <abbaskhurram255@gmail.com>
 Classifier: Programming Language :: Python :: 3