ContinuumIO / topik

        return es_getitem(key,self.corpus_type,self.instance,self.index,

                          self.query)

class VectorizedElasticCorpora(BaseElasticCorpora):

    def __setitem__(self, key, value):

        #id_term_map

        es_setitem(key,value.id_term_map.items(),"term",self.instance,self.index)

        #document_term_counts

        es_setitem(key,value.document_term_counts.items(),"document_term_count",self.instance,self.index)

        #doc_lengths

        es_setitem(key,value.doc_lengths.items(),"document_length",self.instance,self.index)

        #global term_frequency

        es_setitem(key,value.term_frequency.items(),"term_frequency",self.instance,self.index)

        #vectors

        es_setitem(key,value.vectors.items(),"vector",self.instance,self.index)

        # could either upload vectors explicitly here (above) or using Super (below)

        #super(VectorizedElasticCorpora, self).__setitem__(key, value)

    def __getitem__(self, key):

        # TODO: each of these should be retrieved from a query.  Populate the VectorizerOutput object

        # and return it.  These things can be iterators instead of dicts; VectorizerOutput should

        # not care.

        # TODO: this is the id->term map for the full set of unique terms across all docs

        id_term_map = {int(term_id): term for term_id, term in es_getitem(key,"term",self.instance,self.index,self.query)}

        # 15

        # TODO: this is the count of terms associated with each document

        document_term_count = {int(doc_id): doc_term_count for doc_id, doc_term_count in es_getitem(key,"document_term_count",self.instance,self.index,self.query)}

        # {"doc1": 3, "doc2": 5}

        doc_lengths = {int(doc_id): doc_length for doc_id, doc_length in es_getitem(key,"document_length",self.instance,self.index,self.query)}

        term_frequency = {int(term_id): global_frequency for term_id, global_frequency in es_getitem(key,"term_frequency",self.instance,self.index,self.query)}

        # TODO: this is the vectorized representation of each document

        vectors = {int(doc_id): {int(term_id): term_weight for term_id, term_weight in doc_term_weights.items()} for doc_id, doc_term_weights in es_getitem(key,"vector",self.instance,self.index,self.query)}

        #vectors = {int(doc_id): {doc_term_weights for doc_id, doc_term_weights in es_getitem(key,"vector",self.instance,self.index,self.query)}

        #vectors = list(es_getitem(key,"vector",self.instance,self.index,self.query))

        #  {"doc1": {1: 3, 2: 1}  # word id is key, word count is value (for bag of words model)

        return VectorizerOutput(id_term_map=id_term_map,

                                document_term_counts=document_term_count,

                                doc_lengths=doc_lengths,

                                term_frequency=term_frequency,

                                vectors=vectors)

class ModeledElasticCorpora(BaseElasticCorpora):

    def __setitem__(self, key, value):

                                term_frequency=term_frequency,

                                vectors=vectors)

class ModeledElasticCorpora(BaseElasticCorpora):

    def __setitem__(self, key, value):

        es_setitem(key,value.vocab.items(),"term",self.instance,self.index)

        es_setitem(key,value.term_frequency.items(),"term_frequency",self.instance,self.index)

        es_setitem(key,value.topic_term_matrix.items(),"topic_term_dist",self.instance,self.index)

        es_setitem(key,value.doc_lengths.items(),"doc_length",self.instance,self.index)

        es_setitem(key,value.doc_topic_matrix.items(),"doc_topic_dist",self.instance,self.index)

    def __lt__(self, y):

        return super(ModeledElasticCorpora, self).__lt__(y)

    def __getitem__(self, key):

        vocab = {int(term_id): term for term_id, term in \

                 es_getitem(key,"term",self.instance,self.index,self.query)}

        term_frequency = {int(term_id): tf for term_id, tf in \

                          es_getitem(key,"term_frequency",self.instance,self.index,self.query)}

        topic_term_matrix = {topic_id: topic_term_dist for topic_id, topic_term_dist in \

                             es_getitem(key,"topic_term_dist",self.instance,self.index,self.query)}

        doc_lengths = {topic_id: doc_length for topic_id, doc_length in \

                       es_getitem(key,"doc_length",self.instance,self.index,self.query)}

        doc_topic_matrix = {int(doc_id): doc_topic_dist for doc_id, doc_topic_dist in \

                             es_getitem(key,"doc_topic_dist",self.instance,self.index,self.query)}

        return ModelOutput(vocab=vocab, term_frequency=term_frequency,

                           topic_term_matrix=topic_term_matrix,

                           doc_lengths=doc_lengths,

                           doc_topic_matrix=doc_topic_matrix)

@register_output

class ElasticSearchOutput(OutputInterface):