def _process_items_of(self, client_cart):
ticket = Ticket()
for book, book_quantity in client_cart.list_content().items():
ticket.add_item(book, book_quantity, self._price_list[book])
return ticket
def test_basicDeactivate(self):
ticket = Ticket(0, None, None, None)
pic = PIC("210c-spare", "tel-210c-c3560cx-01:01-Gi1/0/10", "tel-210c-c3560cx-01:01-Gi1/0/10", "Deactivate", None)
pic.applyCurrentConfig(None, "128.210.148.000/24 Public Subnet (1998)", "100/1000T-SW-A")
ticket.addPic(pic)
config = Config.Config(ticket)
config.run()
def getTickets(conn):
cursor = conn.cursor()
cursor.execute("SELECT * FROM tickets")
ticketList = []
row = cursor.fetchone()
while row:
temp_ticket = Ticket(row[0],row[1],row[2],row[3],row[4],row[5],row[6])
ticketList.append(temp_ticket)
row = cursor.fetchone()
for temp_ticket in ticketList:
cursor.execute("SELECT name FROM venues WHERE id='%s'"%(temp_ticket.getVenueID()))
row2 = cursor.fetchone()
temp_ticket.VenueName = row2[0]
return ticketList
def test_basicModify(self):
ticket = Ticket(0, None, None, None)
pic = PIC("210c-SPARE", "tel-210c-c3560cx-01:01-Gi1/0/10", "tel-210c-c3560cx-01:01-Gi1/0/10", "Modify", None)
pic.applyCurrentConfig(None, "128.210.148.000/24 Public Subnet (1998)", "10/100/1000T-SW-A")
pic.applyNewConfig(None, "128.210.148.000/24 Public Subnet (1998)", "10/100/1000T-SW-A")
ticket.addPic(pic)
config = Config.Config(ticket)
config.run()
def test_trunkDeactivate(self):
ticket = Ticket(0, None, None, None)
pic = PIC("trunk-test", "tel-210c-c3560cx-01:01-Gi1/0/10", "tel-210c-c3560cx-01:01-Gi1/0/10", "Deactivate", None)
pic.applyCurrentConfig(None, ["128.210.148.000/24 Public Subnet (2)", "128.210.148.000/24 Public Subnet (3)",
"128.210.148.000/24 Public Subnet (4)"], "100/1000T-SW-A")
ticket.addPic(pic)
config = Config.Config(ticket)
config.run()
def test_trunkActivate(self):
ticket = Ticket(0, None, None, None)
pic = PIC("trunk-test", "tel-210c-c3560cx-01:01-Gi1/0/10", "tel-210c-c3560cx-01:01-Gi1/0/10", "Activate", None)
pic.applyNewConfig(None, "128.210.148.000/24 Public Subnet (2)", "10/100/1000T-SW-A")
pic.addTaggedVlans(["128.210.148.000/24 Public Subnet (3)", "128.210.148.000/24 Public Subnet (5)"])
ticket.addPic(pic)
config = Config.Config(ticket)
config.run()
def Button_9_onCommand(className, widgetName):
start = Fun.GetText(className, "Entry_3")
to = Fun.GetText(className, "Entry_5")
date = Fun.GetText(className, "Entry_8")
listBox = Fun.GetElement(className, "ListBox_10")
ticket = Ticket()
ticket.set_FromStation(start)
ticket.set_ToStation(to)
ticket.set_TicketDate(date)
ticket.curlData(listBox)
def create(event, is_lambda):
try:
ticket = Ticket(event, is_lambda)
print 'Creating new ticket'
ticket.create()
print 'created ticket with data: {0}'.format(vars(ticket))
return ticket.to_hash()
# TODO update_pager_duty_with_ticket_info()
except Exception as e:
print 'Error: {0}'.format(e)
def changed_tickets(bgr_image, ticket_mask, classifier, ticket_settings,
ticket_data):
hsv_image = cv2.cvtColor(bgr_image, cv2.COLOR_BGR2HSV)
_, contours, _ = cv2.findContours(ticket_mask.copy(), cv2.RETR_EXTERNAL,
cv2.CHAIN_APPROX_NONE)
contours = sorted(contours, key=cv2.contourArea, reverse=True)
tickets = {}
for i in range(len(contours)):
_, _, width, height = cv2.boundingRect(contours[i])
if (cv2.contourArea(contours[i]) *
int(ticket_settings["min_ticket_scale"]) > hsv_image.shape[0] *
hsv_image.shape[1]) and width < hsv_image.shape[
1] / 3 and height < hsv_image.shape[0] / 3:
ticket_mask = np.zeros_like(ticket_mask)
hulls = []
hulls.append(cv2.convexHull(contours[i], False))
cv2.drawContours(ticket_mask, hulls, 0, color=255, thickness=-1)
area = cv2.contourArea(contours[i])
rect = cv2.boundingRect(contours[i])
x, y, width, height = rect
ticket_area = bgr_image[y:y + height, x:x + width]
thresholded_ticket, colored_ticket = cluster(ticket_area)
thresholded_digits, colored_digits = digit_area(
thresholded_ticket, colored_ticket, ticket_settings)
ticket_number = find_numbers_in_mask(thresholded_digits,
colored_digits, classifier,
ticket_settings["Digits"])
if len(difflib.get_close_matches(ticket_number,
ticket_data.keys())) > 0:
ticket_number = difflib.get_close_matches(
ticket_number, ticket_data.keys())[0]
tickets[ticket_number] = Ticket(
ticket_mask,
ticket_number, [area, width, height, rect],
desc=ticket_data[ticket_number]["description"])
else:
tickets[ticket_number] = Ticket(ticket_mask, ticket_number,
[area, width, height, rect])
else:
break
return tickets
def bookTikets():
"""Description: this function let the user to chose
tickets count then print the total price
:return total price
"""
while True:
# Ticket type menu
try:
# Prompt the user to enter Adult Ticket number :
adultTicket = int(input("\nHow many Adult ticket do you want:"))
except:
assert False, 'Please try again and enter an Integer number.'
# Check if the ticket number is valid
if adultTicket > 10:
print("\n The maximum Tikcket you can buy is 10")
continue
try:
# Prompt the user to enter Child Ticket number :
childTicket = int(input("\nHow many child ticket do you want:"))
except:
assert False, 'Please try again and enter an Integer number.'
# Check if the ticket number is valid
if childTicket > 10:
print("\n The maximum Tikcket you can buy is 10")
continue
try:
# Prompt the user to enter Senior Ticket number :
seniorTicket = int(input("\nHow many Senior ticket do you want:"))
except:
assert False, 'Please try again and enter an Integer number.'
# Check if the ticket number is valid
if seniorTicket > 10:
print("\n The maximum Tikcket you can buy is 10")
continue
# call the Ticket class
ticket = Ticket(adultTicket, childTicket, seniorTicket)
total = ticket.getTotalCost()
print("-" * 50)
print("\n Total Ticket price is {:,.2f}".format(total))
break
return total
def main(event, is_lambda=True):
messages = event['messages']
for message in messages:
try:
message_data = message['data']
if PagerDuty.is_triggered_alert(
message_data) and not Ticket.exists(message_data):
ticket = Ticket(message_data, is_lambda)
ticket.create()
# TODO update_pager_duty_with_ticket_info()
except Exception as e:
print 'Error: {0}'.format(e)
def transfer_ticket(self, tid, old_owner, new_owner, price):
# Find the previous transaction involving this ticket id.
prev_ticket = self.find_prev_ticket(tid)
# If this previous transaction is not found, return an error.
if prev_ticket is None or prev_ticket.owner != old_owner:
return "-1"
# If it is found, do the transfer.
else:
new_ticket = Ticket(old_owner, new_owner, price)
new_ticket.tid = tid
new_ticket.resale_count = prev_ticket.resale_count + 1
self.pool.append(new_ticket)
return "1"
def getEntity(self, paramDict):
res_ticket = Ticket()
query = 'SELECT TicketId, PIB, Passport, Place, RaceId, Price ' \
'FROM Ticket ' \
'WHERE '
equal_substr = '{attr_name} = ?'
counter = len(paramDict)
args = []
for param in paramDict:
query += equal_substr.format(attr_name=param)
args.append(paramDict[param])
if counter == 1:
query += ';'
else:
query += ' AND '
counter -= 1
connection = sqlite3.connect(self._dbname)
result = connection.execute(query, args).fetchone()
connection.close()
res_ticket.ticketId = result[0]
res_ticket.pib = result[1]
res_ticket.passport = result[2]
res_ticket.place = result[3]
res_ticket.raceId = result[4]
res_ticket.price = result[5]
return res_ticket
def Update_Ticket_List(self):
Ticket_List_Temp = []
self.cursor.execute("SELECT * FROM TICKETS")
for row in self.cursor.fetchall():
Tick1 = Ticket(row[0], row[1], row[2], row[3], row[4])
Ticket_List_Temp.append(Tick1)
self.Tickets_List = Update_Ticket_List
def load(self):
pickled = []
with open(self.datafile, 'rb') as f:
pickled = pickle.load(f)
print("Found %s tickets" % len(pickled))
for p in pickled:
self.past_tickets.append(Ticket(p))
def car_input(self, car_name):
if len(self.ticket_list) <= self.maximum_number_of_cars-1:
ticket = Ticket(car_name, datetime.now())
self.ticket_list.append(ticket)
else:
print("{} is full, the car({}) did not enter.".format(self.name, car_name))
def parse_text(self, text) -> Optional[Ticket]:
ticket_name = self.parse_entry("Ticket Name", text)
if not ticket_name:
return None
ticket_number = self.parse_entry("Ticket Number", text)
if not ticket_number:
return None
ticket_number = int(ticket_number)
email_address = self.parse_entry("Email", text)
if not email_address:
return None
status = self.parse_entry("Status", text)
if not status:
return None
entered_on = self.parse_entry("Entered on", text)
if not entered_on:
return None
date = entered_on.split()[0]
time = entered_on.split()[2]
return Ticket(ticket_name, ticket_number, email_address, status, date,
time)
def generate(self):
nums = random.sample(range(self.max_num), self.num_count)
new_ticket = Ticket(tuple(nums))
for old_ticket in self.past_tickets:
if old_ticket.is_match(new_ticket, self.compare_to_threshold):
print("%s matches %s" % (new_ticket, old_ticket))
return self.generate()
return new_ticket
def __init__(self):
super(Manager, self).__init__()
self._crew = Crew()
self._plane = Plane()
self._planeType = PlaneType()
self._position = Position()
self._race = Race()
self._ticket = Ticket()
self._worker = Worker()
def addTicket(this):
'''
Asks the user questions, then fills out a ticket
'''
ID = input("\nTicket ID: ")
name = input("Ticker holder's name: ")
eMail = input("Ticket holder's eMail: ")
tManager.addTicket(Ticket(ID, name, eMail))
hasChanged = True
def __init__(self):
""" Se asignara una lista los valores que se obtengan de la clase anterios TICKET"""
self.vehiculo = Ticket()
self.opciones = {
"1": self.agregar_vehiculo,
"2": self.buscar_vehiculo,
"3": self.salida_cliente,
"4": self.mostrar_reporte,
"5": self.salir
}
def Generator(self):
shuffle = list(range(1,self.seed))
random.shuffle(shuffle)
raw=permutations(shuffle,self.size)
if self.all:
self.tickes=list(raw)
return
rawTickes=[next(raw) for _ in range(self.maxTickes)]
self.tickes=[Ticket(value=v)for v in rawTickes]
def ticket_is_new(self, ticket: Ticket) -> bool:
ret = self._execute_ret(
"SELECT * FROM tickets where ticket_number=%d;" % ticket.number)
if len(ret) == 0:
return True
ret = ret[0]
db_ticket = Ticket(ret[3], ret[0], ret[4], ret[5], ret[1], ret[2])
if ticket.status_rank > db_ticket.status_rank:
return True
else:
return False
def extractTicket(path):
workbook = xlrd.open_workbook(path)
sheet = workbook.sheet_by_name('Tickets')
tickets = []
tickets_matrix = []
for i in range(sheet.nrows):
if i != 0:
data = sheet.row_values(i)
ticket = Ticket(data[0], data[1], data[2], data[3], data[4],
data[5])
tickets.append(ticket)
tickets_matrix.append(data)
return tickets, tickets_matrix
def generateTickets(self):
#nextStops = self.route.stops[self.curr_stop+1:]
#probability of selecting NextStop
#probNextStop = np.ones(len(nextStops))
#Select the no Of passengers to board on current Stop
noOfPassengers = random.randint(0, 10)
NoOfPassengersFromCurStop = 0
while (NoOfPassengersFromCurStop < noOfPassengers):
currentTicketPassengers = 0
# passengers boarding from current stop
noOfAdultMales = random.randint(0, 2)
noOfAdultFemales = random.randint(0, 2)
noOfMaleStudents = random.randint(0, 3)
noOfFemaleStudents = random.randint(0, 2)
noOfChildren = random.randint(0, 2)
startStop = self.route.stops[self.curr_stop]
endStopNo = random.randint(self.curr_stop + 1,
len(self.route.stops) - 1)
endStop = self.route.stops[endStopNo]
# create a Ticket
t = Ticket(noOfAdultMales, noOfAdultFemales, noOfMaleStudents,
noOfFemaleStudents, noOfChildren, startStop, endStop)
self.tickets.append(t)
t.showTicket()
#No of passengers boarding on current Stop
currentTicketPassengers += noOfAdultMales + noOfAdultFemales + noOfMaleStudents + noOfFemaleStudents + noOfChildren
NoOfPassengersFromCurStop += currentTicketPassengers
#Recording how many passengers will deboard at upcoming stops
self.alightingPassengers[endStopNo] += currentTicketPassengers
self.totalPassengers += NoOfPassengersFromCurStop
self.boardingPassengers[self.curr_stop] = NoOfPassengersFromCurStop
def getAll(self):
tickets = []
query = 'SELECT TicketId, PIB, Passport, Place, RaceId, Price ' \
'FROM Ticket'
connection = sqlite3.connect(self._dbname)
result = connection.execute(query).fetchall()
for ticket in result:
ticket = Ticket()
ticket.ticketId = user_data[0]
ticket.pib = user_data[1]
ticket.passport = user_data[2]
ticket.place = user_data[3]
ticket.raceId = user_data[4]
ticket.price = user_data[5]
tickets.append(ticket)
connection.close()
return tickets
def readInfo():
count = 0
separator = ";"
f = open(
"C:/Users/FauxL/AppData/Roaming/MetaQuotes/Terminal/2E8DC23981084565FA3E19C061F586B2/MQL4/Files/MarketInfo.csv","r")
n = f.readlines()
SymbolArray = []
for i in n:
result = i.split(separator)
symbol = result[1]
price = result[2]
ticket = Ticket(symbol, price)
SymbolArray.append(ticket.__dict__)
return SymbolArray
def parkThePark(self, slotId, registrationNumber, age):
'''
To park the car in the position
'''
for i in range(self.__slotCount):
if self.__slots[i].getSlotId() == slotId:
slotindex = i
break
if len(self.__Tickts) != self.__slotCount:
self.__Tickts.append(Ticket(slotId, registrationNumber, age))
else:
self.__Tickts[slotindex].setRegistratonNumber(registrationNumber)
self.__Tickts[slotindex].setAge(age)
self.__slots[slotindex].parkCar()
if self.__slots[slotindex].checkIfCarParked() == True:
print("Car with vehicle registration", registrationNumber,
"has been parked at slot number ", slotId)
def Book_Ticket(self, Source, Destination, UserID, TrainNo):
PNRNO = "PNR" + str(format(random.randint(int(UserID), 500), '05d'))
sql = "INSERT INTO TICKETS (Source, Destination, PNR, UserID, TrainNo) VALUES (%s, %s, %s, %s, %s)"
val = (str(Source), str(Destination), PNRNO, str(UserID), str(TrainNo))
self.cursor.execute(sql, val)
self.DB.db.commit()
self.Tickets_List.append(
Ticket(Source, Destination, PNRNO, UserID, TrainNo))
sql = "SELECT * FROM Trains WHERE TrainID = %s"
val = (str(TrainNo))
self.cursor.execute(sql, val)
Seats = int(self.cursor.fetchall()[0][3])
sql = "UPDATE Trains SET SeatsNormal = %s WHERE TrainID = %s"
val = (str(Seats - 1), TrainNo)
self.cursor.execute(sql, val)
self.DB.db.commit()
print("TrainBooked successfully")
print("Your PNR NO: " + PNRNO)
return PNRNO
def ticket(self):
self.ticket = Ticket(self.length, self.differ, self.order)
def draw(self):
self.draw = Ticket(self.length, self.differ, self.order)
ticket.numbers[2],
ticket.numbers[3],
ticket.numbers[4],
ticket.powerball))
# Run lottery, talley, selection and remaining numbers.
def runLottery(self):
self.printTickets()
self.tallyTickets()
self.topNumbers()
self.fillIn()
self.pickPowerball()
if __name__ == '__main__':
lotto = Lottery()
t1 = Ticket()
t1.addNumber(10)
t1.addNumber(12)
t1.addNumber(13)
t1.addNumber(14)
t1.addNumber(15)
t1.addNumber(16)
t1.addPowerball(18)
lotto.addTickets(t1)
t1 = Ticket()
t1.addNumber(10)
t1.addNumber(12)
t1.addNumber(23)
t1.addNumber(54)
t1.addNumber(62)
t1.addNumber(16)
