def __init__(self):
ListenableModel.__init__(self)
self.currentSong = None
# le repertoire ou se trouvent les musiques
self.directory = None
self.primaryQueue = Queue()
self.secondaryQueue = Queue()
def __init__(self):
self.queue = Queue()
self.file_load = File_Load()
try:
self.transactions = self.file_load.Read_json(
"Transaction_Queue.json")
for i in self.transactions:
self.queue.enqueue(i)
except FileNotFoundError:
print("File Not Found..")
def __init__(self):
"""
Reading old transaction from transaction json file and maintain in queue
"""
self.queue = Queue()
with open("Transaction_queue.json") as data:
try:
temp = json.load(data)
except Exception:
pass
else:
for i in temp:
self.queue.enqueue(i)
class PrimeAnagramWithQueue:
def __init__(self):
"""
Creating object of queue for maintain and store data
"""
self.queue = Queue()
def prime_anagram_with_queue(self, rng):
"""
:param rng: take one parameter range for calculating prime anagram from 1 to range
print prime anagram number on console
"""
prime_number = Utility.get_prime_number(rng)
anagram_number = Utility.get_anagram(prime_number)
for i in anagram_number:
self.queue.enqueue(i)
for i in range(self.queue.size()):
print(self.queue.dequeue(), end=" ")
def Show_Cal_Queue(self, year, month):
queue = Queue() # Queue class object
d = 1
m = month
y = year
if IsLeap(year): # check if leap year
self.month_days[1] = 29 # than update month days value
y0 = y - (14 - m) // 12
x = y0 + y0 // 4 - y0 // 100 + y0 // 400
m0 = m + 12 * ((14 - m) // 12) - 2
start_day = (d + x + 31 * m0 // 12) % 7 # calculate start day
print("\n-------------", self.month_name[month - 1], "-", year,
"--------------\n") # print heading
for i in range(7): # print week days
print(self.day[i], end=' ')
print()
date = 1
for i in range(6): # store the dates in queue
for j in range(7):
if date <= self.month_days[
m - 1]: # check the date less than the month days
if i == 0 and j < start_day: # check if i==0 and j < start day
queue.enqueue(0)
continue
queue.enqueue(
date) # else store than date in Queue position
date += 1 # update the date
try:
for i in range(6): # print the calender in formatted output
for j in range(7):
if queue.Size() >= 0:
x = int(queue.dequeue())
print(str(x).ljust(2), end=' ')
print()
except:
print()
class TransactionQueue:
def __init__(self):
"""
Reading old transaction from transaction json file and maintain in queue
"""
self.queue = Queue()
with open("Transaction_queue.json") as data:
try:
temp = json.load(data)
except Exception:
pass
else:
for i in temp:
self.queue.enqueue(i)
def transaction_queue(self, transaction, customer_name, company_name,
no_of_share, cost, time):
"""
Taking all data about stock account transaction and maintain in queue
:param transaction: it is transaction like sell or buy
:param customer_name: it is customer name
:param company_name: it is company name
:param no_of_share: it is no of share
:param cost: total cost of share
:param time: it is time of transaction
"""
new_transaction = {
"transaction": transaction,
"customer_name": customer_name,
"company_name": company_name,
"no_of_share": no_of_share,
"cost": cost,
"time": time
}
self.queue.enqueue(new_transaction)
def save_transaction(self):
"""
update transaction json file by queue
"""
temp1 = []
size = self.queue.size()
for i in range(size):
temp1.append(self.queue.dequeue())
with open("Transaction_queue.json", 'w') as data:
json.dump(temp1, data)
class Board(ListenableModel):
'''
Classe representant le panneau de gestions d'ordonnancement des musiques
'''
def __init__(self):
ListenableModel.__init__(self)
self.currentSong = None
# le repertoire ou se trouvent les musiques
self.directory = None
self.primaryQueue = Queue()
self.secondaryQueue = Queue()
def getDirectory(self):
return self.directory
def setDirectory(self, directory):
'''
change le repertoire contenant les musiques
:param directory: le nouveau repertoire dans lequel lire les musiques
:type directory: str
'''
# on vide les listes d'attentes et la musique courrante
self.clearSongs()
# on set le repertoire et on ajoute toutes les musiques qui sont presentes
self.directory = directory
self.addSongOfDirectory(directory)
# on melange et on prend la premiere musique de la liste pour que la musique courante
# soit differente de None
self.shuffle(10)
self.nextSong()
def addSongOfDirectory(self, directory):
'''
ajoute toutes les musiques du repertoire donne au format mp3 dans la liste d'attente
:param directory: le repertoire dans lequel trouver les musiques
:type directory: str
'''
listFiles = listFile(directory)
for file in listFiles:
song = Song(directory, file)
if song.getFormat() == "mp3":
# set les infos de la musique (auteur et duree) puis ajout de celle-ci
audio = MP3(song.getFullFilename())
song.setDuration(int(audio.info.length * 1000))
song.setAuthor(audio.tags["TPE1"].text[0])
self.secondaryQueue.add(song)
self.firechange()
def getCurrentSong(self):
return self.currentSong
def getPrimaryQueue(self):
return self.primaryQueue
def getSecondaryQueue(self):
return self.secondaryQueue
def getOrderListFilterSong(self, filterName):
''' donne la liste des musiques filtrees ou non dans l'ordre alphabetique '''
listSong = []
# si le filtre correspond au nom ou auteur d'une musique de la liste prioritaire
for song in self.getPrimaryQueue().getListElements():
if filterName in song.getName().lower(
) or filterName in song.getAuthor().lower():
listSong.append(song)
# si le filtre correspond au nom ou auteur d'une musique de la liste secondaire
for song in self.getSecondaryQueue().getListElements():
if filterName in song.getName().lower(
) or filterName in song.getAuthor().lower():
listSong.append(song)
# si le filtre correspond au nom ou auteur de la musique courrante
if self.currentSong and (
filterName in self.currentSong.getName().lower()
or filterName in self.currentSong.getAuthor().lower()):
listSong.append(self.currentSong)
listSong.sort()
return listSong
def getSongAt(self, queue, index):
'''
donne la musique dans la liste d'attente donnee a la position donnee
:param queue: la liste d'attente dans laquelle on veut la position
:type queue: util.Queue
:param index: la position de la musique que l'ont souhaite
:type index: int
:return: la musique a la position donnee ou None si la position n'est pas dans l'interval de la liste d'attente
:rtype: model.Song
'''
return queue.getElementAt(index)
def getSongPrimaryAt(self, index):
''' donne la musique de la liste d'attente prioritaire a l'index donnee '''
return self.getSongAt(self.primaryQueue, index)
def getSongSecondaryAt(self, index):
''' donne la musique de la liste d'attente secondaire a l'index donnee '''
return self.getSongAt(self.secondaryQueue, index)
def getSumDuration(self, queue):
duration = 0
for song in queue:
duration += song.getDuration()
return duration
def nextSong(self):
''' fait passer a la musique suivante '''
if self.currentSong:
self.secondaryQueue.add(self.currentSong)
if not self.primaryQueue.isEmpty():
# si la liste d'attente principale n'est pas vide on prend la prochaine musique
# dans celle si
self.currentSong = self.primaryQueue.remove()
else:
# sinon on prend dans la liste d'attente secondaire
self.currentSong = self.secondaryQueue.remove()
self.firechange()
return self.currentSong
def precedentSong(self):
''' fait passer a la musique precedente '''
song = self.secondaryQueue.getLast()
if song:
if not self.primaryQueue.isEmpty():
# si la liste prioritaire n'est pas vide on met la musique courrante
# en debut de celle-ci
self.primaryQueue.addHead(self.currentSong)
else:
# sinon on la met au debut de la liste secondaire
self.secondaryQueue.addHead(self.currentSong)
# on retire la musique qui se trouvait avant la musique courrante de la liste
# d'attente et on la met comme musique courante
self.secondaryQueue.removeElement(song)
self.currentSong = song
self.firechange()
def moveSongOfQueue(self, startQueue, destQueue, indexStart):
'''
deplace une musique d'une liste d'attente et a l'index donnees vers une autre liste d'attente
:param startQueue: la liste d'attente de depart
:type startQueue: util.Queue
:param destQueue: la liste d'attente d'arrivee
:type destQueue: util.Queue
:param indexStart: la position de la musique dans la liste d'attente de depart a deplacer
:type indexStart: int
'''
song = startQueue.remove(indexStart)
if song:
# si l'index est coherent par rapport aux dimensions de la liste
destQueue.add(song)
self.firechange()
def moveSongOfIndexToPrimary(self, index):
self.moveSongOfQueue(self.secondaryQueue, self.primaryQueue, index)
def moveSongOfIndexToSecondary(self, index):
self.moveSongOfQueue(self.primaryQueue, self.secondaryQueue, index)
def moveSongToPrimary(self, song):
'''
deplace la musique donnee dans la liste d'attente prioritaire
:param song: la musique a deplacer
:type song: model.Song
'''
if song in self.secondaryQueue:
self.secondaryQueue.removeElement(song)
self.primaryQueue.add(song)
self.firechange()
def switchSong(self, queue, firstIndex, secondIndex):
'''
echange la position entre deux musique dans une liste d'attente
:param queue: la liste d'attente dans laquelle faire l'echange
:type queue: util.Queue
:param firstIndex: la position de la premiere musique a echanger
:type firstIndex: int
:param secondIndex: la position de la deuxieme musique a echanger
:type secondIndex: int
'''
queue.switchElements(firstIndex, secondIndex)
self.firechange()
def shuffle(self, nb=1):
''' melange la liste d'attente secondaire '''
self.secondaryQueue.shuffle(nb)
self.firechange()
def clearSongs(self):
''' vide les liste d'attentes et retire la musique courrante '''
self.currentSong = None
self.primaryQueue = Queue()
self.secondaryQueue = Queue()
def __repr__(self):
return "Board :\ncurrent=" + str(
self.currentSong) + "\nprimary : \n" + str(
self.primaryQueue) + "\n\nsecondary : \n" + str(
self.secondaryQueue)
def clearSongs(self):
''' vide les liste d'attentes et retire la musique courrante '''
self.currentSong = None
self.primaryQueue = Queue()
self.secondaryQueue = Queue()
class TransactionQueue:
def __init__(self):
self.queue = Queue()
self.file_load = File_Load()
try:
self.transactions = self.file_load.Read_json(
"Transaction_Queue.json")
for i in self.transactions:
self.queue.enqueue(i)
except FileNotFoundError:
print("File Not Found..")
"""
AddTransaction Method Takes 5 params
tr_type : Type Of Transaction BUY Or SELL
company_name : Name Of The Company
customer_name : Name Of The Customer
shares : Number Share That Has Been Sell Or Buy
total_amount : total Amount Of The Transaction
"""
def AddTransaction(self, tr_type, company_name, customer_name, shares,
total_amount):
cr_date = dt.datetime.now(
) # Create DateTime Object To Store Transaction Time And Date
cr_date = cr_date.strftime(
"%d/%m/%Y, %H:%M:%S") # Format The Date And Time
try:
# Create newtransation Object And Assign Values
newtransaction = {
"transaction_type": tr_type,
"company_name": company_name,
"customer_name": customer_name,
"no_of_share": shares,
"total_amount": total_amount,
"date_time": cr_date
}
# Add To The Queue
self.queue.enqueue(newtransaction)
except:
print("Undefined Error..")
"""
Save Transaction Simply Save The Transaction
In Json File
"""
def SaveTransaction(self):
try:
temp = [] # Declare One temp List
size = self.queue.Size() # Get The Size Of The Queue
for i in range(size + 1): # Loop Through The size Of Queue
temp.append(
self.queue.dequeue()) # Append All Queue Data To The List
self.file_load.Write_json(
temp, "Transaction_Queue.json") # Save List Data To The json
except:
print("Undefined Error..")
from Week1.Util import get_anagram, get_prime
from util.Queue import Queue
queue = Queue()
primearray = get_prime() # Prime Numbers Array
anagrams = get_anagram(primearray) # Anagram Numbers Array
for i in anagrams: # Add Elements Of Anagram Array In Queue
queue.enqueue(i)
q_size = queue.Size() # Calculate Size Of Queue
for i in range(q_size): # Print Elements Of Queue
print(queue.dequeue(), '', end='')
def __init__(self):
"""
Creating object of queue for maintain and store data
"""
self.queue = Queue()