Python AttributeError / NameError with confirmed imports - python-3.x

Question

I have two files, InvertedIndex.py and gui.py for an Inverted Index program I'm working on.
Both files work correctly on their own and have the correct imports. When I run python InvertedIndex.py things function properly and return the values to the interface, but when I run python gui.py, enter my search term and click search I am met with this:
C:\Users\MTXIII\Documents\Dev\Python\Projects\InvIndex\gui\InvInd\Test>python gui.py
Exception in Tkinter callback
Traceback (most recent call last):
File "C:\Users\MTXIII\Anaconda3\lib\tkinter\__init__.py", line 1705, in __call__
return self.func(*args)
File "C:\Users\MTXIII\Documents\Dev\Python\Projects\InvIndex\gui\InvInd\Test\gui.py", line 17, in open
for line in bck.index_lookup_query(Term.get()):
AttributeError: module 'InvertedIndex' has no attribute 'index_lookup_query'
Furthermore, when I run these checks I get NameError: name 'bck' is not defined (bck is the alias given in file for InvertedIndex.py)
>>> import gui
>>> print(bck)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'bck' is not defined
>>> print(dir(bck))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'bck' is not defined
>>> for line in bck.index_lookup_query(Term.get()):
...
I have also confirmed that index_lookup_query is within the namespace of InvertedIndex.
>>> import InvertedIndex >>> print(dir(InvertedIndex)) ['Appearance', 'Database', 'InvertedIndex', 'builtins', 'cached', 'doc', 'file', 'loader', 'name', 'package', 'spec', 'g', 'index_documents', 'index_lookup_query', 'main', 're'] >>>
My Code is below:
gui.py:
```
from tkinter import *
import InvertedIndex as bck
# from InvertedIndex import index_lookup_query
LARGE_FONT = ("Verdana", 12)
NORM_FONT = ("Verdana", 10)
SMALL_FONT = ("Verdana", 8)
def open():
top = Toplevel()
searching = 'Occurences of the term: ' + Term.get()
lbl = Label(top, text=searching, width = 60, font = LARGE_FONT).pack()
listbox = Listbox(top)
listbox.pack()
# for line in bck.index_lookup_query(Term.get()):
for line in bck.index_lookup_query(Term.get()):
listbox.insert(END, line)
#create the tkinter window.
root = Tk()
root.geometry('300x85')
# frame = Frame(root, width=100, height=15, bg='white')
# frame.pack()
# to rename the title of the root
root.title("Term Search")
#Label for entry box.
# Label(root, text = "Enter the term you would like to search for:").grid(row = 0)
# Entry box.
Term = Entry(root, width=30)
Term.pack(side = TOP)
Term.insert(0,"Enter the term to search for:")
# Term.grid(row = 0, column = 0)
# Search button.
search_for = "Searching for " + Term.get()
b1 = Button(root, text = "Search!", bg = 'grey', fg = "red", width = 30, command = open)
b1.pack()
# b1.grid(row = 1, column = 0) #'fg or foreground' is for coloring the contents (buttons)
mainloop()
```
InvertedIndex.py:
```
import re
import gui as g
class Appearance:
"""
Represents the appearance of a term in a given document, along with the
frequency of appearances in the same one.
"""
def __init__(self, docId, frequency):
self.docId = docId
self.frequency = frequency
def __repr__(self):
"""
String representation of the Appearance object
"""
return str(self.__dict__)
class Database:
"""
In memory database representing the already indexed documents.
"""
def __init__(self):
self.db = dict()
def __repr__(self):
"""
String representation of the Database object
"""
return str(self.__dict__)
def get(self, id):
return self.db.get(id, None)
def add(self, document):
"""
Adds a document to the DB.
"""
return self.db.update({document['id']: document})
def remove(self, document):
"""
Removes document from DB.
"""
return self.db.pop(document['id'], None)
class InvertedIndex:
"""
Inverted Index class.
"""
def __init__(self, db):
self.index = dict()
self.db = db
def __repr__(self):
"""
String representation of the Database object
"""
return str(self.index)
def index_document(self, document):
"""
Process a given document, save it to the DB and update the index.
"""
# Remove punctuation from the text.
clean_text = re.sub(r'[^\w\s]','', document['text'])
terms = clean_text.split(' ')
appearances_dict = dict()
# Dictionary with each term and the frequency it appears in the text.
for term in terms:
term_frequency = appearances_dict[term].frequency if term in appearances_dict else 0
appearances_dict[term] = Appearance(document['id'], term_frequency + 1)
# Update the inverted index
update_dict = { key: [appearance]
if key not in self.index
else self.index[key] + [appearance]
for (key, appearance) in appearances_dict.items() }
self.index.update(update_dict)
# Add the document into the database
self.db.add(document)
return document
def lookup_query(self, query):
"""
Returns the dictionary of terms with their correspondent Appearances.
This is a very naive search since it will just split the terms and show
the documents where they appear.
"""
return { term: self.index[term] for term in query.split(' ') if term in self.index }
def index_documents(index):
document1 = {
'id': '1',
'text': 'It resides in a cavern on the moon.'
}
document2 = {
'id': '2',
'text': 'The lunar brew expedition.'
}
document3 = {
'id': '3',
'text': 'beer beer beer!'
}
document4 = {
'id': '4',
'text': 'Space travel has changed to way we consume beer.'
}
document5 = {
'id': '5',
'text': 'Over the moon brew.'
}
document6 = {
'id': '6',
'text': 'Deep in the caverns of the moon, beer.'
}
index.index_document(document1)
index.index_document(document2)
index.index_document(document3)
index.index_document(document4)
index.index_document(document5)
index.index_document(document6)
def index_lookup_query(search_term):
db = Database()
index = InvertedIndex(db)
index_documents(index)
result = index.lookup_query(search_term)
for key, value in result.items():
for appearance in value:
yield '{}, {}'.format(appearance.docId, appearance.frequency)
def main():
search_term = input('Enter term to search for: ')
#
# result = index.lookup_query(search_term)
for line in index_lookup_query(search_term):
print(line)
print("-----------------------------")
if __name__ == "__main__":
main()
```

Answer 1

You have a case of circular dependency.
module1.py
import module2
module2.func()
module2.py
import module1
def func():
print("hello")
Now if you run
python module1.py
You will run into module 'module2' has no attribute 'func' error.
The reason this happens is that the line module2.func() isn't executed when you think it will be executed. Here is how the program flows:
import module2 at line1, module1 (program now goes to module2)
import mudule1 at line1, module2 (program now goes to module1 again)
import module2 at line1, module1 (program doesn't go to module2 again because module2 has been imported before.)
module2.func() at line2, module1. (throws an error because we have never reached to the func definition at line2, module2. So, module2 doesn't yet have func
The easiest way to solve this problem is to get rid of the circular import. In your case, remove import gui as g from the InvertedIndex.py since it seems unnecessary.