flask response svg or png qrcode generator using pyqrcode module

import pyqrcode, png

text = pyqrcode.create('')

text.svg('./app/static/uploads/uca-url.svg', scale=8)

text.png('./app/static/uploads/uca-url.png', scale=8)

# print(text.text())

# print(text.terminal(module_color='red', background='yellow'))

# print(url.terminal(quiet_zone=1))

@users_api.route('/')

def base_index():

import io

import pyqrcode, png

qr = pyqrcode.create('5035265994')

qr.png('test.png', scale=8)

image_binary = io.open("test.png", "rb")

print('***********type is ', type(image_binary))

response = make_response(image_binary.read())

response.headers.set('Content-Type', 'image/png')

# response.headers.set('Content-Disposition', 'attachment', filename='test.png')

return response

# return json_error(), 404

python switcher case while else type() format (%s %03d {})

b = 'True'

print(type(b) == str)

print(type(b) == bool)

switcher = {

True: print('it is true'),

1: 'Monday',

2: 'Tuesday',

3: 'Wednesday',

4: 'Thursday',

5: 'Friday',

6: 'Saturday'

}

print(switcher.get(True, 'else'))

a = 3

while (a > 0):

print(a)

a -= 1

else:

print("Reached 0")

# Here age is a string object

age = "18"

print(age)

# Converting string to integer

int_age = int(age)

print(int_age)

age = False

int_age = int(age)

print(int_age)

print('%(language)s has %(number)05d quote types.' % {

"language": "Python",

"number": 2

})

print('form({})'.format(b))

nginx.conf

#user  nobody;
worker_processes  1;

#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

#pid        logs/nginx.pid;


events {
    worker_connections  1024;
}


http {
    include       mime.types;
    default_type  application/octet-stream;

    #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
    #                  '$status $body_bytes_sent "$http_referer" '
    #                  '"$http_user_agent" "$http_x_forwarded_for"';

    #access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

    #gzip  on;

    server {
        listen       80;
        server_name  api.odo.mn seller.odo.mn supply.odo.mn admin.odo.mn order.odo.mn odo.mn;

        #charset koi8-r;

        #access_log  logs/host.access.log  main;

        location / {
            root   html;
            index  index.html index.htm;
        }

        #error_page  404              /404.html;

        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }

        # proxy the PHP scripts to Apache listening on 127.0.0.1:80
        #
        #location ~ \.php$ {
        #    proxy_pass   http://127.0.0.1;
        #}

        # pass the PHP scripts to FastCGI server listening on 127.0.0.1:9000
        #
        #location ~ \.php$ {
        #    root           html;
        #    fastcgi_pass   127.0.0.1:9000;
        #    fastcgi_index  index.php;
        #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
        #    include        fastcgi_params;
        #}

        # deny access to .htaccess files, if Apache's document root
        # concurs with nginx's one
        #
        #location ~ /\.ht {
        #    deny  all;
        #}

location / {
proxy_pass http://0.0.0.0:5000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
}
    }

server {
listen 80;
server_name login.odo.mn;
location / {
proxy_pass http://0.0.0.0:8002;
proxy_set_header Host login.odo.mn;
}
}


    # another virtual host using mix of IP-, name-, and port-based configuration
    #
    #server {
    #    listen       8000;
    #    listen       somename:8080;
    #    server_name  somename  alias  another.alias;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}


    # HTTPS server
    #
    #server {
    #    listen       443 ssl;
    #    server_name  localhost;

    #    ssl_certificate      cert.pem;
    #    ssl_certificate_key  cert.key;

    #    ssl_session_cache    shared:SSL:1m;
    #    ssl_session_timeout  5m;

    #    ssl_ciphers  HIGH:!aNULL:!MD5;
    #    ssl_prefer_server_ciphers  on;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}

}

python your oauth server login using google account integration

from flask import flash, redirect, url_for, session, request, jsonify

from flask_oauthlib.client import OAuth

from app.models.company_models import Company, CompanyInfo, Branch

from app.models.shared_models import Sphere, Business

from app import instance, oauth as my_oauth, my_mail

from app.models.auth_models import User

from flask_login import login_user, logout_user, current_user, login_required

import urllib

from app.helpers.url_helper import base_url

from app.libraries.odo.odo_common import uuid_generator

GOOGLE_CLIENT_ID = '1059700860469-sdfaasdf.apps.googleusercontent.com'

GOOGLE_CLIENT_SECRET = 'asdf'

# one of the Redirect URIs from Google APIs console

AUTH_REDIRECT_URI = '/googleauth/callback'

google_oauth = OAuth(instance)

google = google_oauth.remote_app(

'google',

consumer_key=GOOGLE_CLIENT_ID,

consumer_secret=GOOGLE_CLIENT_SECRET,

request_token_params={

'scope': 'email'

},

base_url='https://www.googleapis.com/oauth2/v1/',

request_token_url=None,

access_token_method='POST',

access_token_url='https://accounts.google.com/o/oauth2/token',

authorize_url='https://accounts.google.com/o/oauth2/auth',

)

@instance.route('/googleauth', methods=['GET', 'POST'])

def googleauth_index():

return redirect(url_for('googleauth_login', **request.args))

@instance.route('/googleauth/login')

def googleauth_login():

session['x_response_type'] = request.args['response_type']

session['x_client_id'] = request.args['client_id']

session['x_redirect_uri'] = request.args['redirect_uri']

session['x_scope'] = request.args['scope']

if 'google_token' in session:

token = session['google_token']

if not token is None:

googleauth_revoke()

session.pop('google_token')

return google.authorize(callback=url_for('googleauth_authorized', _external=True))

@instance.route('/googleauth/logout')

def googleauth_logout():

if 'google_token' in session:

token = session['google_token']

if token:

googleauth_revoke()

session.pop('google_token')

return redirect(base_url('order'))

@instance.route(AUTH_REDIRECT_URI)

def googleauth_authorized():

resp = google.authorized_response()

# try to revoke

if resp is None:

return 'Access denied: reason=%s error=%s' % (

request.args['error_reason'],

request.args['error_description']

)

session['google_token'] = (resp['access_token'], '')

google_user = google.get('userinfo').data

user = User.query.filter_by(email=google_user['email']).first()

if not user:

new_password = uuid_generator()

user = User()

user.username = google_user['email']

user.email = google_user['email']

user.password = new_password

user.role_id = 6 # new user is admin for your self

try:

user.save()

body = "Google хэрэглэгчээр системд бүртгүүлсэн нууц үг: " + new_password + ""

my_mail.Send("Таны систем дээрх нууц үг", body, [user.email])

except Exception as e:

flash('Хэрэглэгч бүртгэхэд алдаа гарлаа! ' +

str(e), category='error')

if login_user(user):

response_type = session['x_response_type']

client_id = session['x_client_id']

redirect_uri = session['x_redirect_uri']

scope = session['x_scope']

return redirect(url_for('googleauth_confirm_authorization', response_type=response_type, client_id=client_id, redirect_uri=redirect_uri, scope=scope))

@instance.route('/googleauth/confirm', methods=['GET', 'POST'])

@login_required

def googleauth_confirm_authorization():

return my_oauth.confirm_authorization_request()

@google.tokengetter

def googleauth_get_google_oauth_token():

return session.get('google_token')

def googleauth_revoke():

if 'google_token' in session:

token = session['google_token']

if not token is None:

try:

request = urllib.request.Request(

"https://accounts.google.com/o/oauth2/revoke?token=" + token[0])

request.add_header(

"Content-type", "application/x-www-form-urlencoded")

urllib.request.urlopen(request).read()

except Exception as e:

print(e)

python flask mail send example using smtp protocol with google less secure app access

from flask import Flask, Blueprint, url_for

from flask_mail import Mail, Message

import os

mail_settings = {

"MAIL_SERVER": 'smtp.gmail.com',

"MAIL_PORT": 587,

"MAIL_USE_TLS": True,

"MAIL_USE_SSL": False,

"MAIL_USERNAME": 'acc@gmail.com',

"MAIL_PASSWORD": 'password',

"DEBUG": True

}

app = Flask(__name__)

app.config.update(mail_settings)

mail = Mail(app)

site = Blueprint('site', __name__)

@site.route('/')

def index():

return '<a href="' + url_for('site.send') + '">send</a>'

@site.route('/send_mail')

def send():

msg = Message(subject="Hello",

sender=app.config.get("MAIL_USERNAME"),

recipients=["boroog@gmail.com"],

body="This is a test email I sent with Gmail and Python!")

mail.send(msg)

return 'SENT'

# flask_mail сан ашиглахгүй гэвэл доорх код бас ажиллана

# # SMTP_SSL Example

# import smtplib

# # server_ssl = smtplib.SMTP_SSL("smtp.gmail.com", 465)

# smtpserver = smtplib.SMTP("smtp.gmail.com", 587)

# smtpserver.ehlo()

# smtpserver.starttls()

# smtpserver.ehlo()

# smtpserver.login("acc@gmail.com", "password")

# # ssl server doesn't support or need tls, so don't call server_ssl.starttls()

# smtpserver.sendmail("acc@gmail.com", "boroog@gmail.com", "test message")

# #server_ssl.quit()

# smtpserver.close()

return 'SENT'

app.register_blueprint(site)

if __name__ == '__main__':

app.run('127.0.0.1', 5000)

python alembic sqlalchemy base model __init__

from collections import OrderedDict

from flask import json, jsonify

from sqlalchemy import func, text

from sqlalchemy import Column, Boolean, Integer, String, DateTime, ForeignKey

from sqlalchemy.ext.declarative import declared_attr

from app import db

class CoreModel(db.Model):

__abstract__ = True

# __tablename__ = name_model as name

@declared_attr

def __tablename__(cls):

cn = cls.__name__.lower()

_i = cn.rfind('_model')

if _i > 0:

return cn[:_i]

else:

return cn

# result as list

@classmethod

def to_list(cls, query_result, obj_field_names=None):

data_array = []

for result_item in query_result:

item = result_item.as_dict()

if obj_field_names is not None:

for obj_field_name in obj_field_names:

obj_field = getattr(result_item, obj_field_name)

if isinstance(obj_field, CoreModel):

item[obj_field_name] = obj_field.as_dict()

data_array.append(item)

return data_array

# model as dict

def as_dict(self, obj_field_names=None):

data_object = OrderedDict()

for key in self.__mapper__.c.keys():

val_field = getattr(self, key)

if not isinstance(val_field, CoreModel):

data_object[key] = val_field

if obj_field_names is not None:

for obj_field_name in obj_field_names:

obj_field = getattr(self, obj_field_name)

if isinstance(obj_field, CoreModel):

data_object[obj_field_name] = obj_field.as_dict()

return data_object

def addme(self):

db.session.add(self)

return self

def save(self):

db.session.add(self)

db.session.commit()

return self

def rollback(self):

db.session.rollback()

return self

@classmethod

def commit(cls):

db.session.commit()

@classmethod

def execute(cls, sql, params=None):

if params is None:

params = {}

resultproxy = db.engine.execute(text(sql), params)

d, a = {}, []

for rowproxy in resultproxy:

# rowproxy.items() returns an array like [(key0, value0), (key1, value1)]

for tup in rowproxy.items():

# build up the dictionary

d = {**d, **{tup[0]: tup[1]}}

a.append(d)

return a

class BaseModel(CoreModel):

__abstract__ = True

id = Column(Integer, primary_key=True)

created_at = Column(DateTime, server_default=func.now())

modified_at = Column(DateTime, server_default=func.now(),

server_onupdate=func.now())

deleted = Column(Boolean, nullable=False, default=False)

@classmethod

def get_first(self):

return self.query.order_by(self.id.asc()).first()

@classmethod

def get_last(self):

return self.query.order_by(self.id.desc()).first()

@classmethod

def get_list_all(self):

lst = []

for item in self.query.order_by(self.id.asc()).all():

lst.append(item.as_dict())

return lst

@classmethod

def get_list(self, **kwargs):

query = self.query.filter_by(**kwargs)

lst = []

for item in query.order_by(self.id.asc()).all():

lst.append(item.as_dict())

return lst

class FullBaseModel(BaseModel):

__abstract__ = True

created_ip = Column(String(length=50))

created_by = Column(Integer, ForeignKey('user.id'))

modified_ip = Column(String(length=50))

modified_by = Column(Integer, ForeignKey('user.id'))

ordering = Column(Integer, nullable=False, default=0)

python Flask, make_response, redirect, session, url_for

from flask import Flask, make_response, redirect, session, url_for

SECRET_KEY = 'develop'

app = Flask(__name__)
app.config.from_object(__name__)

@app.route('/')
def index():
    return '<a href="%s">Go here.</a>' % url_for('do_redirect')

@app.route('/redirect/')
def do_redirect():
    session['hello'] = 'world!'
    return redirect(url_for('dump_session'))

@app.route('/session/')
def dump_session():
    response = make_response(repr(session))
    response.content_type = 'text/plain'
    return response

if __name__ == '__main__':
    app.run()

how to add current project path to alembic env.py for module dynamically import

from __future__ import with_statement

from alembic import context

from sqlalchemy import engine_from_config, pool

from logging.config import fileConfig

import sys, os

base_alembic_dir = os.path.abspath(os.path.dirname(__file__))

base_project_dir = os.path.dirname(base_alembic_dir)

sys.path.append(base_project_dir)

# this is the Alembic Config object, which provides

# access to the values within the .ini file in use.

config = context.config

# Interpret the config file for Python logging.

# This line sets up loggers basically.

fileConfig(config.config_file_name)

# add your model's MetaData object here

# for 'autogenerate' support

# from myapp import mymodel

# target_metadata = mymodel.Base.metadata

target_metadata = None

# other values from the config, defined by the needs of env.py,

# can be acquired:

# my_important_option = config.get_main_option("my_important_option")

# ... etc.

flask alembic sqlalchemy make base model using cls.__name__ to table name

from collections import OrderedDict

from flask import json, jsonify

from sqlalchemy import func, text

from sqlalchemy import Boolean, Column, Integer, String, ForeignKey

from sqlalchemy.ext.declarative import declared_attr

from app import db

class CoreModel(db.Model):

__abstract__ = True

# __tablename__ = name_model as name

@declared_attr

def __tablename__(cls):

cn = cls.__name__.lower()

_i = cn.rfind('_')

if _i > 0:

return cn[:_i]

else:

return cn

# model as dict

def as_dict(self):

result = OrderedDict()

for key in self.__mapper__.c.keys():

result[key] = getattr(self, key)

return result

def addme(self):

db.session.add(self)

@classmethod

def commit(self):

db.session.commit()

def save(self):

db.session.add(self)

db.session.commit()

return self

def delete(self):

db.session.delete(self)

db.session.commit()

class BaseModel(CoreModel):

__abstract__ = True

id = db.Column(db.Integer, primary_key=True)

created_at = db.Column(db.TIMESTAMP)

modified_at = db.Column(db.TIMESTAMP)

deleted = db.Column(db.Boolean, nullable=False, default=False)

@classmethod

def get_first(self):

return self.query.order_by(self.id.asc()).first()

@classmethod

def get_last(self):

return self.query.order_by(self.id.desc()).first()

@classmethod

def get_list_all(self):

lst = []

for item in self.query.order_by(self.id.asc()).all():

lst.append(item.as_dict())

return lst

class FullBaseModel(BaseModel):

__abstract__ = True

created_ip = db.Column(db.String(length=50))

created_by = db.Column(db.Integer, db.ForeignKey('user.id'))

modified_ip = db.Column(db.String(length=50))

modified_by = db.Column(db.Integer, db.ForeignKey('user.id'))

ordering = db.Column(db.Integer, nullable=False, default=0)

python flask json jsonify convert json string object

from flask import jsonify, json

try:

# Initialize a employee list

employeeList = []

# create a instances for filling up employee list

for i in range(0, 2):

empDict = {

'firstName': 'Roy',

'lastName': 'Augustine'

}

employeeList.append('adsf')

# convert to json data

jsonStr = json.dumps(employeeList)

jsonObj = json.loads(jsonStr)

print(jsonObj)

# print(jsonify(Employees=jsonStr))

except Exception as e:

print(str(e))

python __repr__ vs __str__ and cast variable, isinstance tuple vs list, dict for repr(), str(), int(), eval(code or string)

class Point3D(object):

def __init__(self, x, y, z):

self.x = x

self.y = y

self.z = z

def __repr__(self):

return str(self.z)

def __str__(self):

return "(%s, %s, %s)" % (self.x, self.y, self.z)

my_point = Point3D(1, 2, 3)

print(my_point)

v = str(repr(my_point))

b = isinstance(v, str)

if b:

v1 = int(v) + 1

s = str(v1) + ';'

print(s)

else:

print(b, ";")

print(isinstance(('a', 'b'), tuple))

print(isinstance(['a', 'b'], list))

dic = {'abc': 'abc', 'def': {'a1': 'a1v', 'a2': 'a2v'}}

for elem in dic.values():

if isinstance(elem, dict):

for ndx, item in elem.items():

print(ndx, ' => ', item, 'is ')

for i in item:

print(i)

python flask alembic engine sqlalchemy db instance with models example

from sqlalchemy import func, text

from sqlalchemy import Boolean, Column, Integer, \

    String, ForeignKey

from app import db

# Set up user_loader

# @login_manager.user_loader

# def load_user(user_id):

#    return User.query.get(int(user_id))

class Node(db.Model):

    __tablename__ = 'node'

    id = Column(Integer(), primary_key=True)

    name = Column(String(200))

    parent_id = Column('parent_id', Integer())

    lft = Column('lft', Integer())

    rgt = Column('rgt', Integer())

    deleted = Column('deleted', Boolean, default=False)

    def __init__(self, name, parent_id, lft, rgt):

        self.name = name

        self.parent_id = parent_id

        self.lft = lft

        self.rgt = rgt

    @classmethod

    def saveAsRoot(self, name):

        cut = self.getLowerBound() + 1

        node = self(name, 0, cut, cut + 1)

        db.session.add(node)

        db.session.commit()

        self.preOrder(self, 0, 0)

        return node

    def addNodeChild(self, parent_id, node_name):

        node = self(node_name, parent_id, None, None)

        db.session.add(node)

        db.session.commit()

        self.preOrder(self, 0, 0)

        return node

    def preOrder(self, parent, left):

        right = left + 1

        result = Node.query.filter_by(parent_id=parent)

        for r in result:

            right = self.preOrder(self, r.id, right)

        n = Node.query.get(parent)

        if n:

            n.lft = left

            n.rgt = right

            db.session.commit()

        return right + 1

    def getLowerBound():

        data = db.session.query(func.max(Node.rgt)).scalar()

        if data:

            return data

        return 1

    def path(id):

        sql = text(

            'SELECT parent.name FROM node AS n, node AS parent WHERE n.lft BETWEEN parent.lft AND parent.rgt AND n.id = :id ORDER BY parent.lft;')

        result = db.engine.execute(sql, {'id': id})

        names = []

        for row in result:

            names.append(row[0])

        return ">".join(names)

class Goods(db.Model):

    __tablename__ = 'goods'

    id = Column(Integer(), primary_key=True)

    sku = Column(String(200))

    name = Column(String(200))

    unit = Column(String(20))

    photo_path = Column(String(255))

    node_id = Column('node_id', Integer(), ForeignKey('node.id'))

    deleted = Column('deleted', Boolean, default=False)

class Company(db.Model):

    __tablename__ = 'company'

    id = db.Column(db.Integer, primary_key=True)

    name = db.Column(db.String(60), index=True, unique=True)

    phone = db.Column(db.String(60), index=True)

    email = db.Column(db.String(60), index=True)

    address = db.Column(db.Text)

    deleted = db.Column(db.Boolean, default=0)

    company_type = Column(String(20))

class Zone(db.Model):

    __tablename__ = 'zone'

    id = db.Column(db.Integer, primary_key=True)

    name = db.Column(db.String(60), index=True, unique=True)

    deleted = db.Column(db.Boolean, default=0)

    @classmethod

    def allArray(self):

        zones = []

        for n in Zone.query.all():

            zones.append({'id': n.id, 'name': n.name})

        return zones

class Settings(db.Model):

    __tablename__ = 'settings'

    id = db.Column(db.Integer, primary_key=True)

    name = db.Column(db.String(60), index=True, unique=True)

    settings_key = db.Column(db.String(60), index=True, unique=True)

    value = db.Column(db.Text, index=True, unique=True)

    deleted = db.Column(db.Boolean, default=0)

class Location(db.Model):

    __tablename__ = 'location'

    id = Column(Integer(), primary_key=True)

    name = Column(String(200))

    parent_id = Column('parent_id', Integer())

    lft = Column('lft', Integer())

    rgt = Column('rgt', Integer())

    zone_id = db.Column(db.Integer, db.ForeignKey('zone.id'))

    deleted = Column('deleted', Boolean, default=False)

    def __init__(self, name, parent_id, lft, rgt, zone_id):

        self.name = name

        self.parent_id = parent_id

        self.lft = lft

        self.rgt = rgt

        self.zone_id = zone_id

    @classmethod

    def saveAsRoot(self, name):

        cut = self.getLowerBound() + 1

        node = self(name, 0, cut, cut + 1, None)

        db.session.add(node)

        db.session.commit()

        self.preOrder(self, 0, 0)

        return node

    def addNodeChild(self, parent_id, node_name):

        node = self(node_name, parent_id, None, None, None)

        db.session.add(node)

        db.session.commit()

        self.preOrder(self, 0, 0)

        return node

    def preOrder(self, parent, left):

        right = left + 1

        result = Location.query.filter_by(parent_id=parent)

        for r in result:

            right = self.preOrder(self, r.id, right)

        n = Location.query.get(parent)

        if n:

            n.lft = left

            n.rgt = right

            db.session.commit()

        return right + 1

    def getLowerBound():

        data = db.session.query(func.max(Location.rgt)).scalar()

        if data:

            return data

        return 1

    def path(id):

        sql = text(

            'SELECT parent.name FROM location AS n, location AS parent WHERE n.lft BETWEEN parent.lft AND parent.rgt AND n.id = :id ORDER BY parent.lft;')

        result = db.engine.execute(sql, {'id': id})

        names = []

        for row in result:

            names.append(row[0])

        return ">".join(names)

    def map(cls):

        sql = text(

            'SELECT parent.name FROM location AS n, location AS parent WHERE n.lft BETWEEN parent.lft AND parent.rgt AND n.id = :id ORDER BY parent.lft;')

        result = db.engine.execute(sql, {'id': cls.id})

        names = []

        for row in result:

            names.append(row[0])

        return ">".join(names)

    def toTree(self):

        nodes = Location.query.filter_by(parent_id=0)

        tree = []

        for n in nodes:

            tree.append({'id': n.id, 'name': n.name, 'parent_id': n.parent_id, 'zone_id': n.zone_id,

                         'children': self.TReverse(self, n)})

        return tree

    def TReverse(self, node):

        nodes = Location.query.filter_by(parent_id=node.id)

        if nodes == None:

            return []

        tree = []

        for n in nodes:

            tree.append({'id': n.id, 'name': n.name, 'parent_id': n.parent_id, 'zone_id': n.zone_id,

                         'children': self.TReverse(self, n)})

        return tree

class Seller(db.Model):

    __tablename__ = 'seller'

    id = db.Column(db.Integer, primary_key=True)

    name = db.Column(db.String(120))

    email = db.Column(db.String(120))

    phone = db.Column(db.String(120))

    address = db.Column(db.Text)

    company_id = db.Column(db.Integer, db.ForeignKey('company.id'))

    location_id = db.Column(db.Integer, db.ForeignKey('location.id'))

    company = db.relationship('Company')

    location = db.relationship('Location')

    users = db.relationship('User', secondary='seller_user')

    deleted = db.Column(db.Boolean, default=0)

    @classmethod

    def covarage_area(cls, id):

        return SellerLocationCoverage.query.filter_by(seller_id=id, is_active=1)

class Buyer(db.Model):

    __tablename__ = 'buyer'

    id = db.Column(db.Integer, primary_key=True)

    name = db.Column(db.String(120))

    email = db.Column(db.String(120))

    phone = db.Column(db.String(120))

    fax = db.Column(db.String(120))

    address = db.Column(db.Text)

    company_id = db.Column(db.Integer, db.ForeignKey('company.id'))

    deleted = db.Column(db.Boolean, default=0)

    users = db.relationship('User', secondary='buyer_users', backref=db.backref('buyers', lazy='dynamic'))

    @classmethod

    def company(self, buyer):

        if buyer.company_id:

            return Company.query.get(buyer.company_id).name

        return "---"

class BuyerUser(db.Model):

    __tablename__ = 'buyer_users'

    id = db.Column(db.Integer, primary_key=True)

    buyer_id = db.Column(db.Integer, db.ForeignKey('buyer.id'))

    user_id = db.Column(db.Integer, db.ForeignKey('user.id'))

class SellerLocationCoverage(db.Model):

    __tablename__ = 'seller_coverage_area'

    id = db.Column(db.Integer, primary_key=True)

    seller_id = db.Column(db.Integer, db.ForeignKey('seller.id'))

    location_id = db.Column(db.Integer, db.ForeignKey('location.id'))

    start_at = db.Column(db.DateTime)

    ends_at = db.Column(db.DateTime)

    is_active = db.Column(db.Boolean, default=1)

    location = db.relationship('Location')

class CompanyBranch(db.Model):

    __tablename__ = "company_branch"

    id = db.Column(db.Integer, primary_key=True)

    company_id = db.Column(db.Integer, db.ForeignKey('company.id'))

    location_id = db.Column(db.Integer, db.ForeignKey('location.id'))

    company = db.relationship('Company')

    location = db.relationship('Location')

    branch_name = db.Column(db.String(120))

    phone = db.Column(db.String(120))

    address = db.Column(db.String(200))

    contact = db.Column(db.String(200))

    deleted = db.Column(db.Boolean, default=0)

class SellerUser(db.Model):

    __tablename__ = "seller_user"

    id = db.Column(db.Integer, primary_key=True)

    seller_id = db.Column(db.Integer, db.ForeignKey('seller.id'))

    user_id = db.Column(db.Integer, db.ForeignKey('user.id'))

    seller = db.relationship('Seller')

    user = db.relationship('User')

    def __init__(self, seller_id, user_id):

        self.seller_id = seller_id

        self.user_id = user_id

    def __repr__(self):

        return '<SellerUser {} {}>'.format(self.seller_id, self.user_id)

    def __str__(self):

        return self.id

class SellerGoods(db.Model):

    __tablename__ = "seller_goods"

    id = db.Column(db.Integer, primary_key=True)

    seller_id = db.Column(db.Integer, db.ForeignKey('seller.id'))

    goods_id = db.Column(db.Integer, db.ForeignKey('goods.id'))

    seller = db.relationship('Seller')

    goods = db.relationship('Goods')

    price = db.Column(db.Integer)

    @classmethod

    def seller_goods_discount(cls, goods, seller):

        result = db.session.execute(text('SELECT sd.* FROM seller_discount sd '

                                         'INNER JOIN seller_goods_discount sgd ON sgd.seller_discount_id = sd.id '

                                         'WHERE sd.seller_id=:seller and sgd.goods_id=:goods and now() BETWEEN  start_at and ends_at'),

                                    {'seller': seller,

                                     'goods': goods})

        return result

class SellerDiscount(db.Model):

    __tablename__ = "seller_discount"

    id = db.Column(db.Integer, primary_key=True)

    name = db.Column(db.String(200))

    discount_type = db.Column(db.String(200))

    discount_amount = db.Column(db.Float)

    start_at = db.Column(db.DateTime)

    end_at = db.Column(db.DateTime)

    is_active = db.Column(db.Boolean)

    seller_id = db.Column(db.Integer, db.ForeignKey('Seller.id'))

class SellerGoodsDiscount(db.Model):

    __tablename__ = "seller_goods_discount"

    id = db.Column(db.Integer, primary_key=True)

    seller_discount_id = db.Column(db.Integer, db.ForeignKey('seller_discount.id'))

    goods_id = db.Column(db.Integer, db.ForeignKey('goods.id'))

    for_buyer_id = db.Column(db.Integer, db.ForeignKey('buyer.id'))

    discount = db.relationship('SellerDiscount')

class GoodsPrice(db.Model):

    id = db.Column(db.Integer, primary_key=True)

    seller_id = db.Column(db.Integer, db.ForeignKey('seller.id'))

    goods_id = db.Column(db.Integer, db.ForeignKey('goods.id'))

    seller = db.relationship('Seller')

    goods = db.relationship('Goods')

    price = db.Column(db.Integer)

    start_data = db.Column(db.DateTime)

    end_data = db.Column(db.DateTime)

class Order(db.Model):

    id = db.Column(db.Integer, primary_key=True)

    order_number = db.Column(db.String(20))

    total_price = db.Column(db.Float)

    total_discount = db.Column(db.Float)

    status = db.Column(db.String(20))

    user_id = db.Column(db.Integer, db.ForeignKey('user.id'))

class OrderItem(db.Model):

    id = db.Column(db.Integer, primary_key=True)

    quantity = db.Column(db.Integer)

    unit_price = db.Column(db.Float)

    total_price = db.Column(db.Float)

    total_discount = db.Column(db.Float)

    total = db.Column(db.Float)

    status = db.Column(db.String(20))

    order_id = db.Column(db.Integer, db.ForeignKey('order.id'))

    goods_id = db.Column(db.Integer, db.ForeignKey('goods.id'))

    seller_id = db.Column(db.Integer, db.ForeignKey('seller.id'))

    seller_goods_id = db.Column(db.Integer, db.ForeignKey('seller_goods.id'))

class OrderItemDiscount(db.Model):

    id = db.Column(db.Integer, primary_key=True)

    seller_goods_discount_id = db.Column(db.Integer)

    goods_id = db.Column(db.Integer, db.ForeignKey('goods.id'))

    seller_id = db.Column(db.Integer, db.ForeignKey('seller.id'))

    disconut_type = db.Column(db.String(200))

    disconut_amount = db.Column(db.Float)

python class inherit from parent class that super(SelfClassType, self) __init__ or __class__

#The first is used to initialise newly created object, and receives arguments used to do that:

class Input(object):

def __init__(self, x, y):

self.x = x

self.y = y

print("Input inited x=%d, y=%d" % (self.x, self.y))

def __call__(self, a):

self.x = self.x + a

print(self.x, self.y)

class AInput(Input):

input_type = 'password'

def __init__(self, hide_value=True):

self.hide_value = hide_value

super(AInput, self).__init__(5, 10)

print("AInput inited")

def __call__(self, field):

return super(AInput, self).__call__(field)

a = AInput()# __init__

#The second implements function call operator.

a(2)# __call__

python dictionary datatypes features

x = {1:2, 'hello': 'boroo'}

print x

y = 'world'

x.update({'x':y})

x['y'] = 'yeald'

print x['x']

print x

python list append, pop, unshift, shift, deque object insert appendleft clear copy extendleft

from collections import deque

a = [1,2,3,4,5]

a.append(6)

print a

print a.pop()

#['a'] = 'b'

a = ([10] + a + [11]) # Unshift / Push

print a

a = a[:6] # Shift / UnPush

print a, ';;;;;;;;;'

print a.pop(5)

del a[:3]

print a

print deque(a).popleft()

result::::::::::::::::::::::::::

PS D:\Projects\Python.Projects\maths> python main.py
[1, 2, 3, 4, 5, 6]
6 [10, 1, 2, 3, 4, 5, 11] [10, 1, 2, 3, 4, 5] ;;;;;;;;;
5
[3, 4] 3 PS D:\Projects\Python.Projects\maths>

python decimal,float,rmax,min,ound,sorted,sum,int

from decimal import *

getcontext().prec = 4

print Decimal(1) / Decimal(7)

formatted = Decimal('0.142857')

print formatted

#getcontext().prec = 28

print Decimal('0.1428571428571428571428571429')

print Decimal('NaN')

print (Decimal('-Infinity') == '-Infinity')

data = map(Decimal, '1.34 1.87 3.45 2.35 1.00 0.03 9.25'.split())

print max(data)

print min(data)

print sorted(data)

print sum(data)

#Decimal('19.29')

a,b,c,d = data[:4]

print str(a), str(b), str(c), str(d)

#'1.34 1.87 3.45 2.35'

print float(a)

#1.34

print round(a, 1) # round() first converts to binary floating point

#1.3

print int(a)

#1

print (a * 5)

#Decimal('6.70')

print (a * b)

#Decimal('2.5058')

print (c % a)

#Decimal('0.77')

print Decimal(9).sqrt()

#3

print Decimal(3).exp()

#20.09

print Decimal('10').log10()

#1

result:::::::::::::::::::::::::::::::::::

PS D:\Projects\Python.Projects\maths> python main.py 0.1429 0.142857 0.1428571428571428571428571429NaNFalse9.25 0.03 [Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('1.87'), Decimal('2.35'), Decimal('3.45'), Decimal('9.25')] 19.29 1.34 1.87 3.45 2.35 1.34 1.3 1 6.70 2.506 0.77320.09 1 PS D:\Projects\Python.Projects\maths>