import email, imaplib import zmq import random import datetime, time import logging import json from models import Trade, Session db = Session() with open('config.json') as json_data_file: config = json.load(json_data_file) volume = config['volume'] debug = config['debug'] LOG_FILENAME = config['LOG_FILENAME'] imap = config['imap'] user = config['user'] pwd = config['pwd'] folder = config['folder'] STOPLOSS = config['STOPLOSS'] TAKEPROFIT = config['TAKEPROFIT'] hedging = config['hedge'] def generate_nonce(length=8): return ''.join([str(random.randint(0, 9)) for i in range(length)]) def log(msg): if debug == "1":
def test_all_users(all_users): session = Session() users = session.query(User).all() assert len(users) >= 4 session.close()
from models import User, engine, ModelBase, Session session = Session() def createUser(username, join_date, password): user = User(username=username, date_joined=join_date, password=password) session.add(user) session.commit() def deleteUser(username): user = session.query(User).filter(User.username == username).first() session.delete(user) session.commit() def getUser(username): user = session.query(User).filter_by(username=username).first() return user def getAll(): all_user = session.query(User).filter() return all_user def editUser(username): user = session.query(User).filter_by(username=username).first() while True:
def doValidation(email): ses = Session() resultset = ses.query(User).filter(User.email==email).all() if len(resultset)> 0: user = resultset[0] return user.password
from rabbitmq import FibonacciConsumer load_dotenv('.env') consumer = FibonacciConsumer(host=os.environ.get('RABBITMQ_HOST', 'localhost'), port=os.environ.get('RABBITMQ_PORT', '5672'), username=os.environ.get('RABBITMQ_USER', 'fibonacci'), password=os.environ.get('RABBITMQ_PASS', 'fibonacci')) def add_fibonacci_to_db(fibonacci_dict): number = fibonacci_dict['number'] fibonacci_number = str(fibonacci_dict['fibonacci_number']) fibonacci = Fibonacci(number=number, fibonacci_number=fibonacci_number) history = FibonacciHistory(date=datetime.datetime.now(), number=number) if not Fibonacci.exists(session=session, number=number): print(f'Fibonacci number {number} exists in db. Ommiting') session.add(fibonacci) session.add(history) session.commit() with Session() as session: consumer.consume_fibonacci_messages(queue=os.environ.get( 'RABBITMQ_QUEUE', 'fibonacci'), on_consume=add_fibonacci_to_db)
def delete_entry(model_class, uid, *, commit=True): session = Session() session.query(model_class).filter_by(uid=uid).delete() if commit: session.commit()
def _createSessionObject(self, request): """Create or update Session object, returning SessionForm/request.""" # Preload necessary data items user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = getUserId(user) # copy SessionForm/ProtoRPC Message into dict data = { field.name: getattr(request, field.name) for field in request.all_fields() } del data['websafeKey'] # get conference key conf = ndb.Key(urlsafe=data['websafeConferenceKey']).get() if not conf: raise endpoints.NotFoundException('No conference found with key: \ %s' % request.websafeConferenceKey) del data['websafeConferenceKey'] if user_id != conf.organizerUserId: raise endpoints.ForbiddenException( 'Only the owner can update the conference.') if not request.name: raise endpoints.BadRequestException( "Session 'name' field required") # add default values for those missing (both data model & outbound # Message) for df in SESS_DEFAULTS: if data[df] in (None, []): data[df] = SESS_DEFAULTS[df] setattr(request, df, SESS_DEFAULTS[df]) # convert dates from strings to Date objects; set month based on # start_date if data['date']: data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d"). \ date() if data['startTime']: try: data['startTime'] = datetime.strptime(data['startTime'], "%I:%M%p").time() except: data['startTime'] = datetime.strptime(data['startTime'], "%H:%M").time() # generate new session key s_id = Session.allocate_ids(size=1, parent=conf.key)[0] s_key = ndb.Key(Session, s_id, parent=conf.key) data['key'] = s_key # create Session, send email to organizer confirming # creation of session & return (modified) SessionForm Session(**data).put() # Check and see if this speaker is now the featured speaker # Use dictionary to count speaker sessions speakerCounts = {} # Track the most number of sessions for a speaker mostSessions = 0 # The speaker with the most number of sessions will be featured speaker featuredSpeaker = "" # Get the sessions for the conference sessions = Session.query(ancestor=conf.key) # For each session, add to the session count for each speaker for sess in sessions: if sess.speaker in speakerCounts: speakerCounts[sess.speaker] += 1 else: speakerCounts[sess.speaker] = 1 # If the speaker for this session now has more sessions than # current featured speaker, make this speaker the featured. If # speakers have the same number of sessions, the most recent # speaker found with that number will be featured. if speakerCounts[sess.speaker] >= mostSessions: mostSessions = speakerCounts[sess.speaker] featuredSpeaker = sess.speaker taskqueue.add(params={ 'conference': conf.name, 'featuredSpeaker': featuredSpeaker }, url='/tasks/set_featured_speaker') return request
def _create_session(node): session = Session("test session") session.node_key = node.node_key session.client_updated_at = datetime.utcnow() return session
def _createSessionObject(self, request): """Create or update a Session object""" user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = getUserId(user) if not request.name: raise endpoints.BadRequestException( "Session 'name' field required") # fetch and check conference conf = ndb.Key(urlsafe=request.websafeConferenceKey).get() # check that conference exists if not conf: raise endpoints.NotFoundException( 'No conference found with key: %s' % request.websafeConferenceKey) # check that user is owner if user_id != conf.organizerUserId: raise endpoints.ForbiddenException( 'Only the owner can update the conference.') data = { field.name: getattr(request, field.name) for field in request.all_fields() } # convert date and time fields to the correct types if data['dateTime']: s_date = datetime.strptime(data['dateTime'], '%Y-%m-%d %H:%M') data['dateTime'] = s_date data['startTime'] = datetime.strftime(s_date, '%H:%M') # set type of session if it's not supplied set it to 'NOT_SPECIFIED' if data['typeOfSession']: data['typeOfSession'] = str(data['typeOfSession']) else: data['typeOfSession'] = 'NOT_SPECIFIED' # delete the websafeConferenceKey it will be the parent and does # not need to be saved as an entity del data['websafeConferenceKey'] # delete speakerDisplayName it is not stored in te database del data['speakerDisplayName'] # add default values for those missing (both data model & outbound Message) for df in SESSION_DEFAULTS: if data[df] in (None, []): data[df] = SESSION_DEFAULTS[df] setattr(request, df, SESSION_DEFAULTS[df]) s_id = Conference.allocate_ids(size=1, parent=conf.key)[0] s_key = ndb.Key(Session, s_id, parent=conf.key) data['key'] = s_key Session(**data).put() # - - - Task 4 - - - - - - - - - - - - - - - - - - - - - - - - - - - - # after adding the data check if the speaker has mre than one session # at the conference. If they do add a Memcache entry for them # first get all sesiions for the conference then filter by speaker # if there is more than one session add to Memcache confSessions = Session.query(ancestor=conf.key) speakerSessions = confSessions.filter( Session.speaker == data['speaker']) # speakerSessions = confSessions sessionCount = speakerSessions.count() if sessionCount > 1: # get the speaker object from id speak = Speaker.get_by_id(data['speaker']) taskqueue.add(params={'speakerName': speak.name}, url='/tasks/add_featured_speaker') return request
def _createSessionObject(self, request): """Create or update Session object, returning SessionForm/request.""" # Get the current user. user = endpoints.get_current_user() # If there isn't one, raise an authorization exception. if not user: raise endpoints.UnauthorizedException('Authorization required') # Set the user id using getUserId from utils.py user_id = getUserId(user) # Make sure a name is provided if not request.name: raise endpoints.BadRequestException( "Session 'name' field required") # Make sure a websafeConferenceKey is provided (for testing) if not request.websafeConferenceKey: raise endpoints.BadRequestException( "Session 'websafeConferenceKey' field required") # Get the websafeConferenceKey conf = ndb.Key(urlsafe=request.websafeConferenceKey).get() # Check that conference exists if not conf: raise endpoints.NotFoundException( 'No conference found with key: %s' % request.websafeConferenceKey) # Check that user is owner if user_id != conf.organizerUserId: raise endpoints.ForbiddenException( 'Only the owner can update the conference.') # Copy SessionForm/ProtoRPC Message into dict data = { field.name: getattr(request, field.name) for field in request.all_fields() } del data['websafeKey'] del data['websafeConferenceKey'] del data['conferenceName'] # Add default values for those missing (both data model & outbound Message) for df in SESSION_DEFAULTS: if data[df] in (None, []): data[df] = SESSION_DEFAULTS[df] setattr(request, df, SESSION_DEFAULTS[df]) # Convert dates from strings to Date objects; set month based on date if data['date']: data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d").date() if data['startTime']: data['startTime'] = datetime.strptime(data['startTime'][:5], "%H:%M").time() # Generate keys for Session. c_key = ndb.Key(urlsafe=request.websafeConferenceKey) s_id = Session.allocate_ids(size=1, parent=c_key)[0] s_key = ndb.Key(Session, s_id, parent=c_key) data['key'] = s_key # create Session, send email to organizer confirming # creation of Session & return (modified) SessionForm Session(**data).put() sessions = Session.query(Session.speaker == data['speaker']).count() if sessions > 1: taskqueue.add(params={'speaker': data['speaker']}, url='/tasks/set_featured_speaker') # send the request over to the form. return self._copySessionToForm(request)
def save_session(user: User): session = Session(user.serialize()) session.save()
def version(self): try: session = Session() return session.query(FetchDataVersion).first() finally: session.close()
def __init__(self, inventory = "my_inventory"): self.inventory = inventory self.session = Session()
def get_sell_stocks_pool_thru_short_trend(self, date): ''' 获得明天需要卖掉的股票 ''' result = [] leave_level = 0.06 leave_level_1 = 0.10 top_level = 0.20 top_level_1 = 0.15 stocks = self.current_stocks() session = Session() block_money = self.get_block_money(date, type='close') for stock in stocks: session.add(stock) max_price = stock.max_price or stock.price price = stock.price ts_code = stock.code today_price = self.get_price(ts_code, date) if today_price is None: continue # 当股价没有涨过0.05就直接跌,那么0.08的跌幅离开 # 当股价涨过了0.05,那么0.10的跌幅离开 l_level = leave_level if ( (max_price - price) / price) <= 0.05 else leave_level_1 # 止损卖出 # 跌了移动平均线的10%,第二天全部卖出 if today_price <= max_price * (1 - l_level): result.append({'ts_code': ts_code, 'count': stock.count}) # 止盈卖出 # 20%的时候,卖出至少3/4 elif ((today_price - stock.price) / stock.price >= top_level ) and stock.count * today_price > block_money * 1 / 4: if (stock.count * 1 / 2) >= 100: result.append({ 'ts_code': ts_code, 'count': self.stock_int(stock.count * 1 / 2) }) else: result.append({'ts_code': ts_code, 'count': stock.count}) # 15%的时候,卖出至少1/2 elif ((today_price - stock.price) / stock.price >= top_level_1 ) and stock.count * today_price > block_money * 1 / 2: if stock.count * 1 / 2 >= 100: result.append({ 'ts_code': ts_code, 'count': self.stock_int(stock.count * 1 / 2) }) else: result.append({'ts_code': ts_code, 'count': stock.count}) # 设置移动最大值,目的移动止损点 if today_price > max_price: stock.max_price = convert_to_py_type(today_price) session.commit() session.expunge_all() session.close() return result
def list_wallets(): session = Session() return session.query(Wallets).all()
from models import Session, Playlist, User session1 = Session() user1 = User(user_id = 1, name = "Vasya", email = "*****@*****.**", password = "******") playlist1 = Playlist(playlist_id = 12, name = "morgenshtern", owner_id = 1, songs = ['du','ca','la','bo','gu']) session1.add(user1) session1.add(playlist1) session1.commit() session1.close() # psql -h localhost -d musiclist -U postgres -p 5432 -a -q -f create_tables.sql # python add_models.py # alembic revision --autogenerate # alembic upgrade head
def get_entry_by_uid(model_class, uid): session = Session() return session.query(model_class).filter_by(uid=uid).one()
def _createSessionObject(self, request): """Create or update Session object, returning SessionForm/request.""" # preload necessary data items user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = getUserId(user) if not request.name: raise endpoints.BadRequestException( "Session 'name' field is required") conf = ndb.Key(urlsafe=request.websafeConferenceKey).get() if not conf: raise endpoints.NotFoundException("no conference found") if user_id != conf.organizerUserId: raise endpoints.ForbiddenException( "Only the owner can update conference.") data = { field.name: getattr(request, field.name) for field in request.all_fields() } wsck = data['websafeConferenceKey'] #generate session key based on Conf c_key = ndb.Key(Conference, request.websafeConferenceKey) s_id = Session.allocate_ids(size=1, parent=c_key)[0] s_key = ndb.Key(Session, s_id, parent=c_key) print data['duration'] if data['startTime']: data['startTime'] = datetime.strptime(data['startTime'], '%H:%M').time() if data['date']: data['date'] = datetime.strptime(data['date'], '%Y-%m-%d').date() if data['typeOfSession'] == None: data['typeOfSession'] = str(TypeOfSession.NOT_SPECIFIED) speaker = data['speaker'] sessions = Session.query(Session.speaker == speaker).fetch() if len(sessions) > 1: taskqueue.add(params={ 'websafeConferenceKey': request.websafeConferenceKey, 'speaker': speaker }, url='/tasks/set_featured_speaker') data['websafeConferenceKey'] = request.websafeConferenceKey #speaker_name = data['speaker'] Session(**data).put() return request
def _createSessionObject(self, request): """Create Session object, returning SessionForm/request.""" # Authenticate user. user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = _getUserId() # Check that the request has a session name. if not request.name: raise endpoints.BadRequestException("Session 'name' field required") # Check that the request has a valid websafeConferenceKey. if not request.websafeConferenceKey: raise endpoints.BadRequestException("Session 'websafeConferenceKey' field required") conference = _entityByKindAndUrlsafeKeyOrNone(Conference, request.websafeConferenceKey) if not conference: raise endpoints.BadRequestException("Session 'websafeConferenceKey' field invalid") # Make sure the user is the conference organizer. if conference.organizerUserId != user_id: raise endpoints.UnauthorizedException('The user is not the conference organizer') # copy SessionForm/ProtoRPC Message into dict data = {field.name: getattr(request, field.name) for field in request.all_fields()} del data['websafeKey'] del data['websafeConferenceKey'] # convert the date and startTime into Date/Time properties if data['date']: data['date'] = datetime.strptime(data['date'], "%Y-%m-%d").date() if data['startTime']: data['startTime'] = datetime.strptime(data['startTime'], "%H:%M").time() # add default values for missing fields for df in SESSION_DEFAULTS: if data[df] in (None, []): data[df] = SESSION_DEFAULTS[df] # perform necessary type conversion data["typeOfSession"] = str(data["typeOfSession"]) data["duration"] = int(data["duration"]) # generate Session ID based on Conference key and get Session key from ID. sessionId = Session.allocate_ids(size=1, parent=conference.key)[0] sessionKey = ndb.Key(Session, sessionId, parent=conference.key) data['key'] = sessionKey # create Session session = Session(**data) session.put() # Check if the speaker should be featured. The current session has been put into Data Store by now. if data['speaker'] != SESSION_DEFAULTS['speaker']: taskqueue.add( params={ 'speaker': data['speaker'], 'websafeConferenceKey': request.websafeConferenceKey, }, url='/tasks/check_featured_speaker' ) # send email to creater confirming creation of Session # TODO return self._copySessionToForm(session)
def connect_db(): g.session = Session() g.age = age
def _createSessionObject(self, request): """Create or update Session object, returning SessionForm/request.""" # Check if user is authorized user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = getUserId(user) # Check if required Form fields have been filled if not request.name: raise endpoints.BadRequestException( "Session 'name' field required") # Retrieve the conference Key and check if it exists websck = request.websafeConferenceKey conf = ndb.Key(urlsafe=websck).get() if not conf: raise endpoints.NotFoundException( 'No conference found with key: %s' % websck) # Check that user is owner of conference if user_id != conf.organizerUserId: raise endpoints.ForbiddenException( 'Only the owner can update the conference.') # Copy SessionForm/ProtoRPC Message into dict data = { field.name: getattr(request, field.name) for field in request.all_fields() } sess = self._copySessionToForm(request) del data['websafeConferenceKey'] del data['websafeSessionKey'] # Add default values for those missing (both data model & outbound Message) for df in SESSION_DEFAULTS: if data[df] in (None, []): data[df] = SESSION_DEFAULTS[df] setattr(request, df, SESSION_DEFAULTS[df]) # Convert dates and times from strings to Date and Time objects; set month based on start_date if data['date']: data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d").date() if data['duration']: data['duration'] = datetime.strptime(data['duration'][:5], "%H:%M").time() if data['startTime']: data['startTime'] = datetime.strptime(data['startTime'][:5], "%H:%M").time() # Generate Session Key from obtained Conference key s_id = Session.allocate_ids( size=1, parent=ndb.Key(urlsafe=request.websafeConferenceKey))[0] s_key = ndb.Key(Session, s_id, parent=ndb.Key(urlsafe=request.websafeConferenceKey)) data['key'] = s_key # Create Session Session(**data).put() # Add to task queue parameters needed to determine featured speaker taskqueue.add(params={ 'speaker': data['speaker'], 'websafeConferenceKey': websck }, url='/tasks/determine_featured_speaker') # Return (modified) SessionForm return sess
def _createSessionObject(self, request): """Create or update Session object, returning SessionForm/request.""" # Fetch current user user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException( 'Authorization required') user_id = getUserId(user) # test for Session name in request if not request.name: raise endpoints.BadRequestException( "Session 'name' field required") # Test for websafeConferenceKey in request if not request.websafeConferenceKey: raise endpoints.BadRequestException( "Session 'websafeConferenceKey' field required") # copy SessionForm/ProtoRPC Message into dict data = {field.name: getattr(request, field.name) \ for field in request.all_fields()} # Fetch conference from request conf = ndb.Key(urlsafe=request.websafeConferenceKey).get() # Check that conference exists if not conf: raise endpoints.NotFoundException( 'No conference found with key: \ %s' % request.websafeConferenceKey) # Check that user is owner if user_id != conf.organizerUserId: raise endpoints.ForbiddenException( 'Only the owner can add sessions.') # Convert dates from strings to Date objects if data['date']: data['date'] = datetime.strptime( data['date'][:10], "%Y-%m-%d").date() # convert time from strings to Time object if data['startTime']: data['startTime'] = datetime.strptime( data['startTime'][:5], "%H:%M").time() # Add speaker to memcache speaker =data['speaker'] websafeConferenceKey =data['websafeConferenceKey'] taskqueue.add( params={ "speaker": speaker, "websafeConferenceKey": websafeConferenceKey}, url="/tasks/set_featured_speaker") # Make Session Key from Conference ID as p_key p_key = ndb.Key(urlsafe=request.websafeConferenceKey) # Allocate new Session ID with p_key as parent s_id = Session.allocate_ids(size=1, parent=p_key)[0] # Make Session key from ID uses p_key # to define parent and s_id as unique id s_key = ndb.Key(Session, s_id, parent=p_key) data['key'] = s_key del data['websafeConferenceKey'] # Create Session Session(**data).put() # Send email to organizer confirming creation of Session taskqueue.add( params={ 'email': user.email(), 'sessionInfo': repr(request)}, url='/tasks/send_confirmation_email2') # Return request return request
def _createSessionObject(self, request): """Create a new session object, and if necessary, a new speaker object""" user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = getUserId(user) if not request.name: raise endpoints.BadRequestException( "Session 'name' field required") # get key of the conference where the session will be held conf_key = ndb.Key(urlsafe=request.websafeConferenceKey) conf = conf_key.get() # check that conference exists if not conf: raise endpoints.NotFoundException( 'No conference found with key: %s' % request.websafeConferenceKey) # check that user is owner if user_id != conf.organizerUserId: raise endpoints.ForbiddenException( 'Only the owner can update the conference.') # copy SessionForm/ProtoRPC Message into dict data = { field.name: getattr(request, field.name) for field in request.all_fields() } # If session creator has provided a speaker key, check that it is valid and retrieve # his/her name if possible # Otherwise create a new speaker (if a speaker name is provided) and assign a a key otherwise continue # building the session without a speaker if data['websafeSpeakerKey'] is not None: try: speaker_key = ndb.Key(urlsafe=request.websafeSpeakerKey) speaker = speaker_key.get() data['speakerName'] = speaker.name data['speakerEmail'] = speaker.mainEmail except ProtocolBufferDecodeError: raise endpoints.NotFoundException( 'No speaker found with websafeSpeakerKey: %s. Create a new speaker or enter the key again' % data['websafeSpeakerKey']) else: # Create a new speaker object if a name is provided in the SessionForm if data['speakerName'] is not None: speaker = Speaker(name=data['speakerName'], mainEmail=data['speakerEmail']) speaker.put() data['websafeSpeakerKey'] = speaker.key.urlsafe() speaker.websafeKey = speaker.key.urlsafe() # add default values for those missing (both data model & outbound Message) for df in SESS_DEFAULTS: if data[df] in (None, []): data[df] = SESS_DEFAULTS[df] setattr(request, df, SESS_DEFAULTS[df]) # convert Date from string to Date object if data['date'] is not None: data['date'] = datetime.datetime.strptime(data['date'][:10], "%Y-%m-%d").date() # convert startTime from string to Time object if data['startTime'] is not None: data['startTime'] = datetime.datetime.strptime( data['startTime'][:], "%H:%M").time() # websafeKey only used for return messages del data['websafeKey'] # Assign the new session a conference parent data['parent'] = conf_key # Create the sesion and put to the database sess = Session(**data) sess_key = sess.put() # update speaker (if necessary) so that this session key will be added to his list of session keys if speaker is not None: speaker.sessionKeys.append(sess_key) speaker.put() # Check the speaker's sessions to see if he/she already has a session at the same conference # If so, set a featured speaker memcache entry to list all of his or her sessions parent_keys = [ sess_key.parent() for sess_key in speaker.sessionKeys ] if sess_key.parent() in parent_keys: featured_sessions = [ sess_key.get() for sess_key in speaker.sessionKeys ] featured_speaker_string = FEATURED_SPEAKER_TPL % ( speaker.name, ', '.join(sess.name for sess in featured_sessions)) memcache.set(MEMCACHE_FEATURED_SPEAKER_KEY, featured_speaker_string) return self._copySessionToForm(sess)
def _createSessionObject(self, request): """Create or update Session object, returning SessionForm/request.""" # preload necessary data items user = endpoints.get_current_user() # make sure user is authenticated if not user: raise endpoints.UnauthorizedException('Authorization required') user_id = getUserId(user) # make sure session name is entered if not request.name: raise endpoints.BadRequestException( "Session name field required") # make sure websafeConferenceKey is entered if not request.websafeConferenceKey: raise endpoints.BadRequestException( "Session 'websafeConferenceKey' field required") conf_key = ndb.Key(urlsafe=request.websafeConferenceKey).get() # check if conference exists given websafeConferenceKey if not conf_key: raise endpoints.NotFoundException( 'No conference found with key: %s' % request.websafeConferenceKey) # Check if user is organizer if user_id != conf_key.organizerUserId: raise endpoints.ForbiddenException( 'Only conference organizer can add sessions.') # since we use SES_POST_REQUEST, which is a container (combination message) # we need to initiate and return SessionForm, as the request and # response are of different type session = self._copySessionToForm(request) # copy SessionForm/ProtoRPC Message into dict data = {field.name: getattr(request, field.name) for field in request.all_fields()} del data['websafeConferenceKey'] # convert dates from strings to Date objects if data['date']: data['date'] = datetime.strptime( data['date'][:10], "%Y-%m-%d").date() # convert time from strings to time object if data['startTime']: data['startTime'] = datetime.strptime( data['startTime'], "%H:%M").time() # generate Conference Key based on Conference ID and # websafeConferenceKey key c_key = ndb.Key(Conference, request.websafeConferenceKey) s_id = Session.allocate_ids(size=1, parent=c_key)[0] s_key = ndb.Key(Session, s_id, parent=c_key) data['key'] = s_key data['organizerUserId'] = user_id # set typeOfSession to lowser case if data['typeOfSession']: data['typeOfSession'] = data['typeOfSession'].lower() # save form data to datastore Session(**data).put() # add a task queue to check if there are multiple sessions by # by this speaker in a conference taskqueue.add( params={'websafeConferenceKey': request.websafeConferenceKey, 'speaker': data['speaker']}, url='/tasks/get_featured_speaker', method='GET', ) # create Session & return (modified) SessionForm return session
def get_current_stocks(self): session = Session() stocks = session.query(self.get_stock_class()).filter_by(status=1).all() session.expunge_all() session.close() return stocks
def _createSessionObject(self, request): """Create or update Session object, returning SessionForm/request.""" # preload necessary data items user = endpoints.get_current_user() if not user: raise endpoints.UnauthorizedException('Authorization required') if not request.name: raise endpoints.BadRequestException( "Session 'name' field required") # copy SessionForm/ProtoRPC Message into dict data = {field.name: getattr(request, field.name) \ for field in request.all_fields()} del data['websafeKey'] del data['websafeConferenceKey'] # add default values for those missing (both data model & outbound Message) for default in SESSION_DEFAULTS: if data[default] in (None, []): data[default] = SESSION_DEFAULTS[default] setattr(request, default, SESSION_DEFAULTS[default]) # convert dates from strings to Date objects; set month based on start_date if data['startTime']: data['startTime'] = datetime.strptime(data['startTime'], "%H:%M").time() if data['date']: data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d").date() if data['typeOfSession']: # Only take string form of type of session enum data['typeOfSession'] = data['typeOfSession'].name if not request.speaker: q = Speaker.query().filter(Speaker.name == 'Undetermined').get() if not q: speaker = Speaker(name='Undetermined').put() data['speaker'] = speaker else: data['speaker'] = q.key else: q = Speaker.query().filter(Speaker.name == request.speaker).get() if not q: speaker = Speaker(name=request.speaker).put() data['speaker'] = speaker else: data['speaker'] = q.key # generate Session Key based on Conference ID conference_key = ndb.Key(urlsafe=request.websafeConferenceKey) # check that conference exists if not conference_key: raise endpoints.NotFoundException( 'No conference found with key: %s' % request.websafeConferenceKey) session_id = Session.allocate_ids(size=1, parent=conference_key)[0] session_key = ndb.Key(Session, session_id, parent=conference_key) data['key'] = session_key request.conferenceId = request.websafeConferenceKey data['conferenceId'] = conference_key # create Session, send email to organizer confirming # creation of Session & return (modified) SessionForm session = Session(**data) session.put() taskqueue.add(params={ 'urlsafeSpeakerKey': data['speaker'].urlsafe(), 'urlsafeConferenceKey': conference_key.urlsafe() }, url='/tasks/feature_speaker') return self._copySessionToForm(session)
import sys, os loc = None try: loc, fn = os.path.split(__file__) except NameError: loc = os.getcwd() sys.path.insert(0, os.path.abspath(os.path.join(loc +"/../artifice"))) from models import usage, resources, tenants, Session, Base # string = 'postgresql://%(username)s:%(password)s@%(host)s:%(port)s/%(database)s' # conn_string = string % {'username':'******', 'host':'localhost', 'port':5433, 'password':'******', 'database':'artifice'} from sqlalchemy import MetaData, create_engine import os engine = create_engine( os.environ["DATABASE_URL"] ) Session.configure(bind=engine) s = Session() Base.metadata.create_all(engine)
def __init__(self): self.session = Session() self.start_date = datetime.datetime.now() - datetime.timedelta(days=80)
class TestSQLiteMemory(unittest.TestCase): # Database definition (in memory sqlite) engine = create_engine('sqlite:///:memory:') Session.configure(bind=engine) session = Session() def setUp(self): Base.metadata.create_all(self.engine) def tearDown(self): self.session.rollback() Base.metadata.drop_all(self.engine) def testCRUD(self): # Insert user user1 = User(name='user1', fullname='USER1', password='******') self.session.add(user1) self.session.commit() # Check if inserted user = self.session.query(User).filter_by(name='user1').first() self.assertEquals(user.name, user1.name) # Check for non insertion user = self.session.query(User).filter_by(name='userFake').first() self.assertTrue(user is None) # Check Update user = self.session.query(User).filter_by(name='user1').first() user.password = '******' self.session.commit() userTst = self.session.query(User).filter_by(name='user1').first() self.assertEquals(userTst.password, 'pwdChg') # Check printout (to see this you have to run nosetest --nocapture user = self.session.query(User).filter_by(name='user1').first() print('User = %s' % user) # Insert a second record and check insertion user2 = User(name='user2', fullname='USER2', password='******') self.session.add(user2) self.session.commit() user = self.session.query(User).filter_by(name='user2').first() self.assertEquals(user.name, user2.name) # Rollback test user3 = User(name='user3', fullname='USER3', password='******') self.session.add(user3) self.session.rollback() user = self.session.query(User).filter_by(name='user3').first() self.assertTrue(user is None) # Delete record user = self.session.query(User).filter_by(name='user2').first() self.session.delete(user) self.session.commit() self.assertTrue( self.session.query(User).filter_by(name='user2').count() == 0) # Json format of Data (not working) user = self.session.query(User).filter_by(name='user1').first()
def save_current_user(self, user): session = Session(self.application.session_store) session.data = user.fields() session.save() self.set_secure_cookie("sid", session.session_id)