예제 #1
0
def remove_vehicle(db: Session, vehicle_id: str) -> bool:
    if vehicle := retrieve_vehicle(db, vehicle_id):
    db.delete(vehicle)
    db.commit()

    return True

    return Falseclass Veicle(BaseModel):
    veicle_id: (uuid.uuid1(str))
    board: str
    model: str
    like_vehicle: str
예제 #2
0
def update_vehicle(
        db:Session, board: str, values: UpdatevahicleValuesType
):
    if student := vehicle_register(db, vehicle_id):
        db.query(retrieve_vehicle()).filter(update_vehicle==update_vehicle).update(values)
        db.commit()
        db.reflesh(update_vehicle)
예제 #3
0
def vehicle_register(db: Session, vehicle: update_vehicle):
    """Creates a new vehicle registration from data sent via API"""
    new_vehicle = vehicle(**vehicle.dict())
    db.add(new_vehicle)
    db.commit()

    db.reflesh(new_vehicle)
    return new_vehicle
예제 #4
0
def retrieve_vehicle(db: Session, vehicle_id: str):
return db.query(vehicle).filter(vehicle.id == vehicle_id).first()


def vehicle_register(db: Session, vehicle: update_vehicle):
    """Creates a new vehicle registration from data sent via API"""
    new_vehicle = vehicle(**vehicle.dict())
    db.add(new_vehicle)
    db.commit()

    db.reflesh(new_vehicle)
    return new_vehicle

def update_vehicle(
        db:Session, board: str, values: UpdatevahicleValuesType
):
    if student := vehicle_register(db, vehicle_id):
        db.query(retrieve_vehicle()).filter(update_vehicle==update_vehicle).update(values)
        db.commit()
        db.reflesh(update_vehicle)
예제 #5
0
def session_multi_add_commit(Session, list_of_instances):
    sess = Session()
    sess.add_all(list_of_instances)
    sess.commit()
예제 #6
0
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String
from sqlalchemy import create_engine
from settings import DB_CONNECTION_STRING
from sqlalchemy import Session

Base = declarative_base()


class Person(Base):
    __tablename__ = "Peaople"
    id = Column(Integer, primery_key=True)
    name = Column(String(20))


engine = create_engine(DB_CONNECTION_STRING)
Base.metadata.create_all(engine)

session = Session(bind=engine)

kolio = Person(name="Kolio")

session.add(kolio)
seesion.commit()
class Cinema:

    HALL_DIMENSION = 10
    FREE_SEAT_SIGN = '.'
    TAKEN_SEAT_SIGN = 'X'

    def __init__(self, engine):
        self.session = Session(bind=engine)

    def show_movies(self):
        movies = self.session.query(Movie).order_by(Movie.rating).all()
        movies_string = "Current movies:\n"
        for movie in movies:
            movies_string += "{}\n".format(movie.__str__())
        return movies_string

    def show_movie_projections(self, movie_id, date=None):
        if date is None:
            movie = self.session.query(Movie).filter(
                Movie.id == movie_id).one()
            projections = movie.projections

            projections_string = "Projections for movie {}:\n".format(
                movie.name)
            for projection in projections:
                projections_string += "{}\n".format(
                    self.projection_date_string(projection))
        else:
            projections = self.session.query(Projection).filter(
                Projection.movie_id == movie_id).order_by(
                Projection.time).all()
            # can I filter backref or ?

            movie = self.session.query(Movie).filter(
                Movie.id == movie_id).one()

            projections_string = '''projections for movie {}
                                    on date {}:\n'''.format(movie.name, date)
            for projection in projections:
                projections_string += "{}\n".format(
                    self.projection_time_string(projection))

        return projections_string

    def available_spots(self, projection):
        taken_seats = len(projection.reservations)  # backref
        return 10 ** 2 - taken_seats

    def projection_date_string(self, projection):
        available_seats = self.available_spots(projection)
        return "[{}] - {} {} ({}) - {} spots available".format(projection.id,
                                                               projection.date,
                                                               projection.time,
                                                               projection.type,
                                                               available_seats)

    def projection_time_string(self, projection):
        available_seats = self.available_spots(projection)
        return "[{}] - {} ({}) - {} spots available".format(projection.id,
                                                            projection.time,
                                                            projection.type,
                                                            available_seats)

    def make_reservation(self):
        username = self.get_username()
        if self.is_give_up(username):
            return

        tickets = self.get_tickets()
        if self.is_give_up(tickets):
            return

        print(self.show_movies)

        movie_id = self.get_movie_id()
        if self.is_give_up(movie_id):
            return

        print(self.show_movie_projections(movie_id))

        projection_id = self.get_projection_id()
        if self.is_give_up(projection_id):
            return

        seats = self.get_seats(tickets)
            pass
 def __init__(self, engine):
     self.session = Session(bind=engine)
예제 #9
0
from sqlalchemy import Column, ForeignKey, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship
from sqlalchemy import create_engine, Session
from sqlalchemy.orm import sessionmaker
from pprint import pprint

# Create an engine that stores data in the local directory's
# sqlalchemy_example.db file.
engine = create_engine('sqlite:////web/Sqlite-Data/example.db')
Session = sessionmaker(bind=engine)
session = Session()
# this loads the sqlalchemy base class
Base = declarative_base()

# Setting up the classes that create the record objects and define the schema


class Customer(Base):
    __tablename__ = 'customer'
    first_name = Column(String(250), nullable=False)
    last_name = Column(String(250), nullable=False)
    username = Column(String(250), nullable=False)
    email = Column(String(250))
    address = Column(String(250))
    town = Column(String(250))


class Item(Base):
    __tablename__ = 'items'
    name = Column(String(250))
예제 #10
0
from flask import (Flask, render_template, jsonify, request, redirect)

# create instance of Flask app
app = Flask(__name__)

# setup database
engine = create_engine("sqlite:///db/belly_button_biodiversity.sqlite",
                       echo=False)

Base = automap_base()
Base.prepare(engine, reflect=True)
Sample = Base.classes.samples
OTU = Base.classes.otu
Metadata = Base.classes.samples_metadata

session = Session(engine)


# create route that renders index.html template
@app.route("/")
def home():
    return render_template("index.html")


@app.route('/names')
def names():
    all_samples = session.query(Sample).statement
    all_samples_df = pd.read_sql_query(all_samples, session.bind)
    all_samples_df.set_index('otu_id', inplace=True)
    return jsonify(list(all_samples_df.columns))