Develop Reference

I want to specify the class (type) of the parameter

class PostgreSql():
def __init__(self):
pass
class User():
def __init__(self):
pass
def set_dsn(self, connects_database: bool):
self.dsn = "host={host} user={user} password={password} port={port}".format(
host=self.host,
user=self.user,
password=self.password,
port=self.port,
)
if connects_database==True:
self.dsn = "{dsn} {database}".format(
dsn=self.dsn,
database=self.database
)
def set_host(self, host: str):
self.host = host
def set_user(self, user: str, password: str):
self.user = user
self.password = password
def set_port(self, port: str):
self.port = port
def set_database(self, database: str):
self.database = database
class Session():
def __init__(self):
pass
def connect(self, dsn: str):
self.con = psycopg2.connect(dsn=dsn)
self.cur = self.con.cursor()
def create_database(self, name: str):
query = SQL("CREATE DATABASE {name}").format(name=Identifier(name))
try:
self.cur.execute(query=query)
except DuplicateDatabase:
print("{name} Database Already Created.".format(name=name))
else:
print("{name} Database Create.".format(name=name))
def create_table(self, name: str, coulmn: str):
"""This function is create new table in database of instance connection.
Args:
name : Name of the table to be created.
coulmn : Column in the table to be created.
Format is "(name data_type condition, name2 data_type2 condition2...)".
"""
self.cur.execute(
query=SQL("CREATE TABLE {name} %s;").format(name=Identifier(name)),
vars=[coulmn]
)
def create_tables(self, names: list, coulmn: str):
"""This function is create new tables in database of instance connection.
Args:
names : Names of the table to be created.
coulmn : Column in the table to be created.
Format is "(name data_type condition, name2 data_type2 condition2...)".
"""
for name in names:
self.cur.execute(
query=SQL("CREATE TABLE {name} %s;").format(name=Identifier(name)),
vars=[coulmn]
)
full code
def connect(self, dsn: str):
self.con = psycopg2.connect(dsn=dsn)
self.cur = self.con.cursor()
This is the source of the code I want to change.
def connect(self, dsn: User):
self.con = psycopg2.connect(dsn=User.dsn)
self.cur = self.con.cursor()
I want the connect function to take a user class as a parameter, not a simple string class, and refer to the dsn of the user class.
However, the User class does not appear in the visual studio code, so it cannot be specified.
Reference Image
Why can't the connect function read the User class?

you should be calling the class from its parent class :
def connect(self, dsn: PostgreSql.User):
self.con = psycopg2.connect(dsn=User.dsn)
self.cur = self.con.cursor()
and you should import annotations:
from __future__ import annotations

SQLAlchemy: execute() got an unexpected keyword argument

I have database.py which contains the database exec functions
import sqlachemy
class DB():
def __init__(self, **kwargs):
self.connection = None
self.connect(**kwargs)
def connect(self, **kwargs):
if 'url' in kwargs and kwargs.get('url') is not None:
return self.connectUrl(kwargs.get('url'), kwargs.get('username'),
kwargs.get('password'), kwargs.get('database'))
else :
return self.connectHost(kwargs.get('host'), kwargs.get('port'), kwargs.get('username'),
kwargs.get('password'), kwargs.get('database'))
def execute(self, query):
if self.connect is None:
raise Exception('No connection')
try:
with self.connection.connect() as conn:
return conn.execute(query)
except (pymysql.err.OperationalError, sqlalchemy.exc.OperationalError) as e:
print(e)
except (Exception) as e:
print(e)
else:
return None
Also I've a main.py. Im importing the DB class from the above file and using it here.
from database import db
# db connection
def connect():
global db
db = DB(
database="DATABASE_NAME",
username="DATABASE_USER",
password="XXXXXXXXX",
url="XXXXXXX",
host="XXXXXXXXXXX",
port="XXXXXXX",
)
SQL_QUERY = """ select * from sample_table where country = :country and age = :age """
_age = 5
_country = 'US'
connect()
query = text(SQL_QUERY).bindparams(bindparam("country", String), bindparam("age", String))
db.execute(query, age=_age, country=_country)
When I'm trying to execute this script, I'm getting an error
db.execute(query,age=_age, country=_country) TypeError: execute() got an unexpected keyword argument 'age'
Can anyone help me with this?

you can simply pass variables as tuple :
query = 'select * from sample_table where country = ? and age = ?'
_age = 5
_country = 'US'
connect()
db.execute(query, (_age,_country,))

Use decorator to connect to a postgres database

I am working on a program to store my picture meta data and thumbnails into a postgres database using python and psycopg2. In the example I have defined a class MyDbase with methods to create a table, store a value and load a value. Each of these methods needs to connect to the database and a cursor object to execute sql commands. To avoid repetition of code to make the connection and get the cursor I have made a sub class DbDecorators with a decorator connect.
My question: is this a proper way to handle this and specifically using the with statement and passing the cursor to the Dbase method (func) inside the wrapper?
from functools import wraps
import psycopg2
class MyDbase:
''' example using a decorator to connect to a dbase
'''
table_name = 'my_table'
class DbDecorators:
host = 'localhost'
db_user = 'db_tester'
db_user_pw = 'db_tester_pw'
database = 'my_database'
#classmethod
def connect(cls, func):
#wraps(func)
def wrapper(*args, **kwargs):
connect_string = f'host=\'{cls.host}\' dbname=\'{cls.database}\''\
f'user=\'{cls.db_user}\' password=\'{cls.db_user_pw}\''
result = None
try:
with psycopg2.connect(connect_string) as connection:
cursor = connection.cursor()
result = func(*args, cursor, **kwargs)
except psycopg2.Error as error:
print(f'error while connect to PostgreSQL {cls.database}: '
f'{error}')
finally:
if connection:
cursor.close()
connection.close()
print(f'PostgreSQL connection to {cls.database} is closed')
return result
return wrapper
#staticmethod
def get_cursor(cursor):
if cursor:
return cursor
else:
print(f'no connection to database')
raise()
#classmethod
#DbDecorators.connect
def create_table(cls, *args):
cursor = cls.DbDecorators().get_cursor(*args)
sql_string = f'CREATE TABLE {cls.table_name} '\
f'(id SERIAL PRIMARY KEY, name VARCHAR(30));'
print(sql_string)
cursor.execute(sql_string)
#classmethod
#DbDecorators.connect
def store_value(cls, name, *args):
cursor = cls.DbDecorators().get_cursor(*args)
sql_string = f'INSERT INTO {cls.table_name} (name) VALUES (%s);'
print(sql_string)
cursor.execute(sql_string, (name,))
#classmethod
#DbDecorators.connect
def load_value(cls, _id, *args):
cursor = cls.DbDecorators().get_cursor(*args)
sql_string = f'SELECT * FROM {cls.table_name} where id = \'{_id}\';'
print(sql_string)
cursor.execute(sql_string)
db_row = cursor.fetchone()
return db_row
def test():
my_db = MyDbase()
my_db.create_table()
my_db.store_value('John Dean')
db_row = my_db.load_value(1)
print(f'id: {db_row[0]}, name: {db_row[1]}')
if __name__ == '__main__':
test()

probably I did not get your request correctly. Why you need decorator but don't use context manager? Like define db client in any file where from you can import it later and then use it in context manager –
from psycopg2 import SomeDataBase
db = SomeDataBase(credentials)
def create_table(table_name):
with db:
sql_string = f'CREATE TABLE {table_name} '\
f'(id SERIAL PRIMARY KEY, name VARCHAR(30));'
db.cursor.execute(sql_string)

Using a context manager will not close the connection, only the cursor. So using the decorator pattern actually makes more sense here. More info on the context manager: https://www.psycopg.org/docs/usage.html (scroll down to the "with statement" section.)

Write a database class in python

For a hobby project I'm doing at the moment I want to write an object oriented python program.But one of the first issue I'm running into is creating a class for my (MySQL) database.
I am trying to use as few packages as possible and I want to try to write the database class by using only pymysql.The problem is that there is an overwhelming amount of libraries and a lack of explanation on writing a good database class in python.
Any suggestions and especially examples would be much appreciated

When having the exact same situation, I found the mysql-connector-python class with which I created a small "model" to call from other classes. This is a cut-down version which shows various db calls. As you can see I have a config class which holds all db authentication info and more).
# dependancy: mysql-connector-python (https://dev.mysql.com/downloads/connector/python/2.1.html)
import mysql.connector
import time
import config
import HTMLParser
import StringIO
html_parser = HTMLParser.HTMLParser()
try:
connection = mysql.connector.connect( user=config.DB_USER, password=config.DB_PASSWORD,
host = config.DB_HOST, database=config.DB_DATABASE, unix_socket=config.UNIX_SOCKET)
cursor = connection.cursor()
except mysql.connector.Error as err:
logger.log('Database connection failed for '+config.DB_USER+'#'+config.DB_HOST+'/'+config.DB_DATABASE)
exit()
def get_bad_words():
sql = ("SELECT word FROM word_blacklist")
results = execute(sql)
return results
def get_moderation_method():
sql = ("SELECT var_value FROM settings "
"WHERE var_key = %(key)s")
results = execute(sql, True, {'key':'moderation_method'})
return results[0]
def current_events():
sql = ("SELECT count(id) FROM events WHERE event_date >= DATE_SUB(NOW(), INTERVAL 2 hour) AND event_date <= DATE_ADD(NOW(), INTERVAL 5 hour)")
results = execute(sql, True)
return results[0]
def insert_social_post(channel, filter_type, post_id, validate, user_name, user_id, user_profile_picture, text, post_date, image_url, state):
try:
san_user_name = html_parser.unescape(user_name.encode('utf-8').strip()).decode("utf8").encode('ascii','ignore')
except:
san_user_name = html_parser.unescape(user_name.strip())
try:
san_text = html_parser.unescape(text.encode('utf-8').strip()).decode("utf8").encode('ascii','ignore')
except:
san_text = html_parser.unescape(text.strip())
insert_post = ("INSERT IGNORE INTO social_posts "
"(channel, filter_type, post_id, validate, user_name, user_id, user_profile_picture, text, post_date, image_url, state)"
"VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)")
execute(insert_post, False, [channel, filter_type, str(post_id), validate,
san_user_name.strip(), user_id, user_profile_picture, san_text.strip(), post_date, image_url, state], True)
def delete_posts(ids):
fmt = ','.join(['%s'] * len(ids))
cursor.execute("DELETE FROM `social_posts` WHERE id IN (%s)" % fmt,
tuple(ids))
connection.commit()
def update_campaigns(campaigns):
sql = ("UPDATE social_campaigns "
"SET last_updated = NOW()"
"WHERE id IN ("+(','.join(str(c) for c in campaigns))+")")
execute(sql, False, None, True)
def execute(tuple, single = False, args = {}, commit = False):
cursor.execute(tuple, args)
if commit == True:
connection.commit()
else:
if single == True:
return cursor.fetchone()
else:
return cursor.fetchall()
def lastrowid():
return cursor.lastrowid
def close():
connection.close()
Call upon the class like this:
import db
bad_words = db.get_bad_words()

import sqlite3
"""singleton class to deal with db"""
'''same can be use for pymysql just replace the sqlite3 with pymysql'''
class DBConnection:
instance = None
def __new__(cls, *args, **kwargs):
if cls.instance is None:
cls.instance = super().__new__(DBConnection)
return cls.instance
return cls.instance
def __init__(self, db_name='you-db-name'):
self.name = db_name
# connect takes url, dbname, user-id, password
self.conn = self.connect(db_name)
self.cursor = self.conn.cursor()
def connect(self):
try:
return sqlite3.connect(self.name)
except sqlite3.Error as e:
pass
def __del__(self):
self.cursor.close()
self.conn.close()
# write your function here for CRUD operations

sqlite3.Connection class inheritance, commit not working

This is my first time using sqlite3 through class inheritance, and I've run into a problem where I get no traceback errors, but the queries I execute won't commit. I simplified my code
import sqlite3 as lite
class BaseModel(lite.Connection):
def __init__(self, **args):
lite.Connection.__init__(self, **args)
self.cur = self.cursor()
def execute(self, query):
self.cur.execute(query)
class Model(BaseModel):
def __init__(self, **args):
BaseModel.__init__(self, **args)
def _new_(self):
queries = []
queries.append(' '.join(['CREATE TABLE IF NOT EXISTS tb1',
'(id INTEGER PRIMARY KEY,',
'column1 TEXT,',
'column2 INT)']))
for q in queries:
self.execute(q) # execute the queries
self.commit() # write changes to db
def tables(self):
query = 'SELECT name FROM sqlite_master WHERE type="table" ORDER BY name'
results = self.execute(query)
return results#.fetchall()
if __name__ == '__main__':
model = Model(database='test.db')
model._new_()
# Test Fails because the queries aren't being saved in the db
# see Model.__new__ for details
tables = model.tables() # get all tables
print 'Tables Created:'
if tables:
for t in model.tables():
print '\t%s' % str(t[0])
else: print tables

You need to call self.commit():
self.commit() # write changes to db
Without the () you are merely referencing the method, not invoking it.
Next, your execute() function doesn't return anything:
def execute(self, query):
return self.cur.execute(query)