Sono curioso di ciò che ti fa pensare che questo sia inutilmente eccessivo. Sembra perfettamente ragionevole per me, tuttavia, sono sicuro che ci sono modi per rifattenerlo in uno stato più pulito.
Sto giocando con un'implementazione molto semplice di questo in questo momento per provare e farmi un'idea e alcune domande che mi sto trovando a chiedere sono:
"La conversazione deve contenere l'argomento o il messaggio contenere l'argomento? Ci sono operazioni in una conversazione? (Penso di sì, se non altro per la logica di mantenere una cache dei messaggi recenti.)"
"È importante memorizzare nella cache un elenco più piccolo di messaggi inviati e recv l'ultima volta? Può essere fatto con il filtro / slicing del log?"
"I messaggi meritano il loro stesso oggetto? (Ci sono operazioni sui messaggi?) Posso farcela con una tupla o una namedtuple?"
"La Conversazione è responsabile dell'interazione effettiva con l'I / O di rete e l'invio e la ricezione di messaggi in diretta o interagisce con qualche oggetto di rete? Se interagisce con qualche altro oggetto, come si interfacciano tra loro?"
Finora il mio parco giochi per riflettere su questo problema si presenta così:
from collections import deque
class Message():
def __init__(self, sender, contents):
self.sender = sender
self.contents = contents
def find_appropriate_response(topic, message_contents):
black_magic(topic, message_contents)
available_topics = ['software_engineering', 'indie_film', 'naval_history']
class Conversation:
log = []
lastsent = deque()
lastrecv = deque()
def __init__(self, peer, message):
self.peer = peer
(sender, contents) = message.split(":")
self.add_message(Message(sender, contents))
self.topic = discern_message_topic(contents)
if self.topic in available_topics:
response = find_appropriate_response(self.topic, contents)
reply_with(response)
else:
reply_with("I'm sorry, I don't know this topic.")
def recieved_message(self, message):
self.log.append(message)
self.lastrecv.append(message)
if len(self.lastrecv) > 10:
self.lastrecv.popleft()
def sent_message(self, message)
self.log.append(message)
self.lastsent.append(message)
if len(self.lastsent) > 10:
self.lastsent.popleft()
def discern_message_topic(self, message_contents):
return black_magic(message_contents)
Spero che questo sia in qualche modo simile al tuo modello di dati e al tuo modo di pensare.
In termini di ciò che hai effettivamente chiesto, che è ... "C'è un modo più semplice o semplice per tenere traccia della nozione di conversazione?" Dipende dalla tua definizione di semplice, e da un insieme ben definito di requisiti, gli darò una coltellata.
Message = namedtuple('Message', ['direction', 'contents'])
conversations = {}
conversations['someuser'] = []
conversations['someuser'].append(Message('recieved', 'Back in 1714 the people of ...'))
conversations['someuser'].append(Message('sent', "I don't know about history"))
Questo è praticamente un meccanismo di archiviazione senza logica, ma questo è tutto ciò che penso tu abbia bisogno per "l'idea di una conversazione", contiene dettagli su chi è la conversazione, chi è responsabile della creazione del messaggio contenuti, qual è il contenuto del messaggio e l'ordine dei messaggi. Penso che si stia avvicinando di più a ciò che è la mia idea di "semplice".
La natura di un elenco python li manterrà nell'ordine appropriato e, se desideri più ordine o più informazioni sul tempo, potresti aggiungere un campo alla tupla e fornirgli un valore datetime.
Devo supporre che tu abbia qualche metodo per determinare l'argomento in base al contenuto di un messaggio che potresti chiamare mentre li passi, e se quel metodo è per qualche motivo costoso, potresti anche aggiungerlo come campo alla tupla.