Python State Examples

Example #1

#!/usr/bin/python3
""" Print id from State object if name == argv[4] """

if __name__ == "__main__":

    from sqlalchemy.orm import sessionmaker
    from sqlalchemy import create_engine
    from model_state import Base, State
    from sys import argv

    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
        argv[1], argv[2], argv[3]),
                           pool_pre_ping=True)

    Session = sessionmaker(bind=engine)
    session = Session()

    obj = State(name="Louisiana")
    session.add(obj)
    session.commit()
    print(obj.id)

Example #2

File: 11-model_state_insert.py Project: Mauricio-KND/holbertonschool-higher_level_programming

#!/usr/bin/python3
"""
Adds the State object “Louisiana” to the database hbtn_0e_6_usa.
"""
import sqlalchemy
import sys
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

from model_state import Base, State

if __name__ == "__main__":
    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format
                           (sys.argv[1], sys.argv[2], sys.argv[3]),
                           pool_pre_ping=True)
    Base.metadata.create_all(engine)
    Session = sessionmaker(bind=engine)
    session = Session()
    state_add = State(name='Louisiana')
    session.add(state_add)
    item = session.query(State).filter_by(name="Louisiana").first()
    print("{}".format(item.id))
    session.commit()
    session.close()

Example #3

#!/usr/bin/python3
"""add louisiana"""
from sys import argv as a
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base
from model_state import Base, State
Base = declarative_base()

if __name__ == "__main__":
    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
        a[1], a[2], a[3]))
    Base.metadata.create_all(engine)

    Session = sessionmaker(bind=engine)
    session = Session()

    states_name = session.query(State.name, State.id).all()
    new_state = State()
    new_state.id = len(states_name) + 1
    new_state.name = "Louisiana"
    print(new_state.id)
    session.add(new_state)
    session.commit()
    session.close()

Example #4

#!/usr/bin/python3
"""a script that adds a new state named Louisiana"""

from sys import argv
from model_state import Base, State
from sqlalchemy import (create_engine)
from sqlalchemy.orm import sessionmaker

if __name__ == "__main__":
    engine = create_engine(
                'mysql+mysqldb://{}:{}@localhost:3306/{}'
                .format(argv[1], argv[2], argv[3]), pool_pre_ping=True)
    Base.metadata.create_all(engine)

    Session = sessionmaker(bind=engine)
    session = Session()
    add_state = State(name="Louisiana")
    session.add(add_state)
    session.commit()
    print(add_state.id)
    session.close()

Example #5

File: 11-model_state_insert.py Project: daniela2001-png/holbertonschool-higher_level_programming

#!/usr/bin/python3
'''
enumere todos los State objetos de la base de datoshbtn_0e_6_usa
'''

from model_state import Base, State
from sqlalchemy.orm import sessionmaker
from sqlalchemy import (create_engine)
import sys
if __name__ == "__main__":
    '''
    en este punto creamos el engine a nuetsra base de datos mysqldb
    tomado el input con argv[] y creamos el session instance
    '''
    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
        sys.argv[1], sys.argv[2], sys.argv[3]),
                           pool_pre_ping=True)
    # creamos nuestro objeto sesisonmarker
    Session = sessionmaker(bind=engine)
    session = Session()
    objeto_to_add = State(name="Louisiana")
    session.add(objeto_to_add)
    session.commit()
    print("{}".format(objeto_to_add.id))
    session.close()

Example #6

#!/usr/bin/python3
"""Start link class to table in database
"""
import sys
from sqlalchemy.orm import sessionmaker
from model_state import Base, State
from sqlalchemy.orm import Session
from sqlalchemy import (create_engine)

if __name__ == "__main__":
    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
        sys.argv[1], sys.argv[2], sys.argv[3]),
                           pool_pre_ping=True)
    Base.metadata.create_all(engine)
    Session = sessionmaker(bind=engine)
    session = Session()
    lou = State(name="Louisiana")
    session.add(lou)
    session.commit()
    print(lou.id)
    session.close()

Example #7

#!/usr/bin/python3
"""a script that prints the State object with the name
passed as argument from the database hbtn_0e_6_usa"""

from model_state import Base, State
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
import sys

if __name__ == '__main__':
    username = sys.argv[1]
    password = sys.argv[2]
    DB_name = sys.argv[3]

    engine = create_engine('mysql+mysqldb://{}:{}@localhost:3306/{}'.format(
        username, password, DB_name),
                           pool_pre_ping=True)
    Base.metadata.create_all(engine)
    Session = sessionmaker(bind=engine)
    session = Session()
    lousiana = State(name="Louisiana")
    session.add(lousiana)

    print(session.query(State).filter_by(name="Louisiana").first().id)
    session.commit()
    session.close()

Example #8

#!/usr/bin/python3
"""
11. Add a new state
"""

from model_state import Base, State
from sqlalchemy import create_engine, select, Table, MetaData
import sys
from sqlalchemy.orm import sessionmaker

if __name__ == '__main__':
    MY_HOST = "localhost"
    MY_USER = sys.argv[1]
    MY_PASS = sys.argv[2]
    MY_DB = sys.argv[3]

    m = "mysql://{}:{}@{}:3306/{}".format(MY_USER, MY_PASS, MY_HOST, MY_DB)
    engine = create_engine(m, encoding='latin1')
    conn = engine.connect()
    Base.metadata.create_all(engine)
    Session = sessionmaker(bind=engine)
    session = Session()
    session.add(State(name='Louisiana'))
    session.commit()
    sess = session.query(State).filter_by(name='Louisiana')
    for state in sess:
        print("{}".format(state.id))
    session.close()

Example #9

#!/usr/bin/python3
"""
script que agregue el Stateobjeto "Louisiana" a la base de datoshbtn_0e_6_usa
"""

from model_state import Base, State
from sqlalchemy.orm import sessionmaker
from sqlalchemy import (create_engine)
import sys
if __name__ == "__main__":
    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
        sys.argv[1], sys.argv[2], sys.argv[3]),
                           pool_pre_ping=True)

    Session = sessionmaker(bind=engine)
    session = Session()
    new_object = State(name="Louisiana")
    session.add(new_object)
    session.commit()
    print("{}".format(new_object.id))
    session.close()

Example #10

File: 11-model_state_insert.py Project: AraqueGD/holbertonschool-higher_level_programming

#!/usr/bin/python3
from sqlalchemy import create_engine
from sqlalchemy.orm import Session, sessionmaker
from sys import argv
from model_state import Base, State

if __name__ == "__main__":
    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
        argv[1], argv[2], argv[3]),
                           pool_pre_ping=True)

    Session = sessionmaker(bind=engine)
    session = Session()

    new_user = State(name="Louisiana")
    session.add(new_user)
    session.commit()

    sql = session.query(State).filter_by(name="Louisiana").first()
    print("{}".format(sql.id))
    session.close()

Example #11

File: 11-model_state_insert.py Project: ChristianCampos-55/holbertonschool-higher_level_programming

#!/usr/bin/python3
"""Adds a state to DB"""
from sys import argv
from model_state import Base, State
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine

if __name__ == '__main__':
    ngine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
        argv[1], argv[2], argv[3]))
    Sess = sessionmaker(bind=ngine)
    sess = Sess()
    new_one = State(name='Louisiana')
    sess.add(new_one)
    sess.commit()
    print(new_one.id)
    sess.close()

Example #12

File: 11-model_state_insert.py Project: chrisvanndy/holbertonschool-higher_level_programming

#!/usr/bin/python3
""" Create an engine"""

from sys import argv
from model_state import Base, State

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

if __name__ == "__main__":
    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
        argv[1], argv[2], argv[3], pool_pre_ping=True))

    Base.metadata.create_all(engine)

    Session = sessionmaker(bind=engine)

    sesh = Session()

    newstate = State(name="Louisiana")

    sesh.add(newstate)

    sesh.commit()

    print(newstate.id)

Example #13

#!/usr/bin/python3
# adds the State object “Louisiana” to the database hbtn_0e_6_usa

import sys
from model_state import Base, State
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

if __name__ == '__main__':
    u = sys.argv[1]
    p = sys.argv[2]
    mydb = sys.argv[3]

    query_c = 'mysql+mysqldb://{}:{}@localhost:3306/{}'
    engine = create_engine(query_c.format(u, p, mydb), pool_pre_ping=True)

    Base.metadata.create_all(engine)
    Session = sessionmaker(bind=engine)
    s = Session()

    s.add(State(name='Louisiana'))
    print(s.query(State).filter_by(name="Louisiana").first().id)
    s.commit()
    s.close()

Example #14

File: 100-relationship_states_cities.py Project: mauricioolarte/holbertonschool-higher_level_programming

#!/usr/bin/python3
"""Start link class to table in database
"""
import sys
from model_state import Base, State
from sqlalchemy.orm import sessionmaker
from sqlalchemy import (create_engine)
from sqlalchemy import asc

if __name__ == "__main__":
    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
        sys.argv[1], sys.argv[2], sys.argv[3]),
                           pool_pre_ping=True)
    Base.metadata.create_all(engine)
    Session = sessionmaker(bind=engine)
    session = Session()

    state = State(name='California')
    SanFrancisco = City(name='San Francisco', state_id=state)

    session.add_all([state, SanFrancisco])
    session.commit()

Example #15

File: 11-model_state_insert.py Project: edward0rtiz/holbertonschool-higher_level_programming

#!/usr/bin/python3

import sys
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from model_state import State

if __name__ == '__main__':
    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'
                           .format(sys.argv[1], sys.argv[2], sys.argv[3]),
                           pool_pre_ping=True)

    Session = sessionmaker(bind=engine)
    session = Session()

    insert_state = State(name='Louisiana')
    session.add(insert_state)
    session.commit()
    print(insert_state.id)

Example #16

#!/usr/bin/python3
import sys
from model_state import Base, State
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

if __name__ == "__main__":
    connection = 'mysql+mysqldb://{}:{}@localhost:3306/{}'
    user_name = sys.argv[1]
    password = sys.argv[2]
    db_name = sys.argv[3]
    eng = create_engine(connection.format(user_name, password, db_name),
                        pool_pre_ping=True)
    Session = sessionmaker(bind=eng)
    session = Session()
    state_to_add = State(name="Louisiana")
    session.add(state_to_add)
    session.commit()
    obj = session.query(State).filter_by(name="Louisiana").first()
    print(obj.id)

Example #17

File: 11-model_state_insert.py Project: epg01/holbertonschool-higher_level_programming

Base = declarative_base()


if __name__ == '__main__':
    # Nos conectamos a la base de datos.
    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
        sys.argv[1], sys.argv[2], sys.argv[3]), pool_pre_ping=True)

    # llamamos al metodo MetaData.create_all(), pasando nuestro "engine"
    # como fuente de conectividad de base de datos.

    Base.metadata.create_all(engine)

    Session = sessionmaker()

    # bind=engine una vez que el motor
    # este disponible.

    Session.configure(bind=engine)

    # siempre que necesite tener una conversación con la base de datos,
    # cree una instancia de Session

    session = Session()

    add_name = State(name='Louisiana')
    session.add(add_name)
    session.commit()
    print(add_name.id)
    session.close()

Example #18

#!/usr/bin/python3
"""Start link class to table in database
"""
import sys

from sqlalchemy.orm.session import Session
from model_state import Base, State
from sqlalchemy.orm import sessionmaker
from sqlalchemy import (create_engine)

if __name__ == "__main__":
    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
        sys.argv[1], sys.argv[2], sys.argv[3]),
                           pool_pre_ping=True)
    Base.metadata.create_all(engine)

    Session = sessionmaker(bind=engine)
    session = Session()

    lou_state = session.query(State.name, State.id).all()
    popeyes = State()
    popeyes.id = len(lou_state) + 1
    popeyes.name = 'Louisiana'
    print(popeyes.id)
    session.add(popeyes)
    session.commit()
    session.close()

Example #19

File: 11-model_state_insert.py Project: RodrigoSierraV/holbertonschool-higher_level_programming

#!/usr/bin/python3
"""
   script that lists all State objects that contain the letter
   a from the database hbtn_0e_6_usa
"""

import sys
import sqlalchemy
from model_state import Base, State
from sqlalchemy import (create_engine)
from sqlalchemy.orm import sessionmaker

if __name__ == "__main__":

    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
        sys.argv[1], sys.argv[2], sys.argv[3]),
                           pool_pre_ping=True)
    Base.metadata.create_all(engine)

    Session = sessionmaker(bind=engine)
    session = Session()

    new_state = State()
    new_state.name = 'Louisiana'

    session.add(new_state)
    session.commit()
    session.refresh(new_state)
    print(new_state.id)
    session.close()

Example #20

#!/usr/bin/python3
"""State Model"""
from model_state import Base, State
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from sys import argv

if __name__ == "__main__":
    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
        argv[1], argv[2], argv[3]),
                           pool_pre_ping=True)
    session = sessionmaker(bind=engine)()
    state = State("Louisiana")
    session.add(state)
    session.commit()
    result = session.query(State).order_by(State.id)
    for i in result:
        idi = i.id
    print(str(idi))

Example #21

File: 11-model_state_insert.py Project: angellovc/holbertonschool-higher_level_programming

#!/usr/bin/python3
"""  adds the State object “Louisiana” to the database  """
import sys
from model_state import Base, State
from sqlalchemy import (create_engine)
from sqlalchemy.orm import sessionmaker

if __name__ == '__main__':
    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
        sys.argv[1], sys.argv[2], sys.argv[3]),
                           pool_pre_ping=True)
    Session = sessionmaker(bind=engine)
    session = Session()
    louisiana = State("Louisiana")
    session.add(louisiana)
    session.commit()
    print(louisiana.id)

Example #22

File: 11-model_state_insert.py Project: KarenCampo777/holbertonschool-higher_level_programming

#!/usr/bin/python3
"""
   Script that changes the name of a State object from the database
"""
if __name__ == "__main__":

    from sqlalchemy import create_engine
    from sqlalchemy.orm import sessionmaker
    from model_state import Base, State
    import sys

    # Creates the engine we need
    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
        sys.argv[1], sys.argv[2], sys.argv[3]),
                           pool_pre_ping=True)

    Session = sessionmaker(bind=engine)
    session = Session()

    state_name = State(name="Louisiana")
    session.add(state_name)
    session.commit()
    print(state_name.id)
    session.close()

Example #23

#!/usr/bin/python3
"""
task 11
"""

from sys import argv
from sqlalchemy import create_engine
from model_state import State, Base
from sqlalchemy.orm import Session

if __name__ == "__main__":
    """
    func
    """
    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
        argv[1], argv[2], argv[3]),
                           pool_pre_ping=True)
    Base.metadata.create_all(engine)

    session = Session(engine)
    new = State(name="Louisiana")
    session.add(new)
    session.commit()
    print("{}".format(new.id))
    session.close()

Example #24

#!/usr/bin/python3
"""
Listing all objects from State table
"""

if __name__ == '__main__':
    from sys import argv
    from model_state import Base, State
    from sqlalchemy import (create_engine)
    from sqlalchemy.orm import sessionmaker

    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
        argv[1], argv[2], argv[3]),
                           pool_pre_ping=True)

    Base.metadata.create_all(engine)
    Session = sessionmaker(bind=engine)
    session = Session()
    louis = State(name='Louisiana')
    session.add(louis)
    session.commit()
    print(louis.id)
    session.close()

Example #25

#!/usr/bin/python3
""" function main"""
if __name__ == "__main__":
    import sys
    from model_state import Base, State
    from sqlalchemy.orm import sessionmaker
    from sqlalchemy import (create_engine)
    """ main """
    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
        sys.argv[1], sys.argv[2], sys.argv[3]),
                           pool_pre_ping=True)
    Base.metadata.create_all(engine)
    Session = sessionmaker(engine)
    session = Session()
    myobject = State(name='Louisiana')
    session.add(myobject)
    session.commit()
    print(myobject.id)
    session.close()

Example #26

#!/usr/bin/python3
'''
Adds State obj "Louisiana" to input database
'''
if __name__ == '__main__':
    from sys import argv
    from model_state import Base, State
    from sqlalchemy import create_engine
    from sqlalchemy.orm import sessionmaker

    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
        argv[1], argv[2], argv[3]),
                           pool_pre_ping=True)
    Base.metadata.create_all(engine)

    session = sessionmaker(bind=engine)
    Session = session()

    row = State(name='Louisiana')
    Session.add(row)
    Session.commit()
    print(row.id)
    Session.close()

Example #27

File: 11-model_state_insert.py Project: svelezg/higher_level_programming

if __name__ == "__main__":
    engine = create_engine(
        'mysql+mysqldb://{}:{}@localhost/{}'.format(sys.argv[1],
                                                    sys.argv[2], sys.argv[3]),
        pool_pre_ping=True)
    Base.metadata.create_all(engine)

    # create session
    Session = sessionmaker()
    Session.configure(bind=engine)
    session = Session()

    # query = session.query(State).filter(State.name == argv[4]).
    # order_by(State.id).first()

    my_input = 'Louisiana'

    new_state = State(name=my_input)
    session.add(new_state)
    session.flush()
    session.commit()

    query = session.query(State).filter(State.name == my_input).\
        order_by(State.id).first()

    if query is None:
        print('Not found')
    else:
        print(query.id)

Example #28

File: 11-model_state_insert.py Project: paisap/holbertonschool-higher_level_programming

#!/usr/bin/python3
"""Start link class to table in database """
import sys
from model_state import Base, State

from sqlalchemy import (create_engine)
from sqlalchemy.orm import sessionmaker

if __name__ == "__main__":
    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
        sys.argv[1], sys.argv[2], sys.argv[3]),
                           pool_pre_ping=True)
    Base.metadata.create_all(engine)
    Session = sessionmaker(bind=engine)
    session = Session()
    session.add(State(name="Louisiana"))
    session.commit()
    result = session.query(State)[-1]
    print("{}".format(result.id))
    session.close()

Example #29

#!/usr/bin/python3
"""lists all State objects from the database hbtn_0e_6_usa"""
import sys
from model_state import Base, State
from sqlalchemy import (create_engine)
from sqlalchemy.orm import sessionmaker

if __name__ == "__main__":
    engine = create_engine('mysql+mysqldb://{}:{}@localhost/{}'.format(
        sys.argv[1], sys.argv[2], sys.argv[3]),
                           pool_pre_ping=True)
    Base.metadata.create_all(engine)

    Session = sessionmaker(bind=engine)
    session = Session()
    new_state = State(name='Louisiana')
    session.add(new_state)
    session.commit()
    session.refresh(new_state)
    print(new_state.id)

Example #30

#!/usr/bin/python3
from sys import argv
from model_state import Base, State
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker


if __name__ == '__main__':
    engine = create_engine(
        'mysql://{}:{}@localhost:3306/{}'.format(argv[1], argv[2], argv[3]))
    session = sessionmaker(bind=engine)()
    record = State(name='Louisiana')
    session.add(record)
    session.commit()
    print(record.id)