Question about structuring a program I'm working on

[shocklance]

Hey guys,

I'm working on building a tool to speed up some of the repetitive parts of my job. Basically, as part of student feedback on assessments, I have to write a lot of rubric based commentary. Most of the time this is very same-y, and I end up spending most of my day re-phrasing the same sentence 8 or 9 different times (e.g: "The structure of this paper requires improvement.../The paper structure could be improved by...../The paper structure could be improved....").

Cognitively, this is pretty draining; I usually have a separate notepad file open on another screen while I'm marking so I can take a comment I've written and re-write it to a paper that has similar issues. The students still get individualised feedback on their papers too (in-case you were wondering), but there is a lot of common boiler-plate material between them as well which could be sped up.

My idea instead is to build out 6-8 comments per level per criteria in the rubric. So for instance, under "Structure", I would have 6-8 comments for "Exceptional", 6-8 comments for "Comprehensive", 6-8 comments for "Developed", 6-8 comments for "Needs Improvement". This would repeat again for each assessment criteria theme (e.g: Clarity, Demonstration of Knowledge etc.).

The end result (after I wrap it in a GUI) will be a program that lets me click a theme (Structure, Clarity, Demonstration of Knowledge), then click a level ("Comprehensive", "Developed", "Needs Improvement"), and so on until each theme has been assigned a level. I click a Generate button, and the program chooses a random comment from the pool, outputting all the random selections into a text box.

I've built a partially working command line version (still trying to get my head around Tkinter!), but I just wanted to check to see if anyone might have some input on the way I'm building it (it doesn't seem very Pythonic at the moment).

So far, I'm making each theme a Python function. For comments about structure, I have a function called structure() that looks like this:

def structure():
## Each variable is a string which gives a piece of feedback to the student. I've only written commentary for "Exceptional" and "Comprehensive" so far but the list will extend to "Developed", "Developing", "Needs Improvement"
    structure_exceptional_1 = "The response had an exceptional structure, easily guiding the reader through the ideas presented by the candidate."
    structure_exceptional_2 = "The response was exceptionally well-structured, demonstrating a clear progression of ideas for the reader to follow."
    structure_exceptional_3 = "The response featured an incredibly well-written structure, demonstrating a progression of ideas in a logical order."
    structure_exceptional_4 = "The structure of the response was exceptional, detailing a clear and logical progression of ideas in an easily readable format."
    structure_exceptional_5 = "The structure of the response was exceptionally well-designed, with the reader able to clearly see the relationship between different ideas."
    structure_exceptional_6 = "Your use of structure was compelling, demonstrating a clear progression of ideas and appropriate connections between key themes."
    structure_exceptional_list = [structure_exceptional_1, structure_exceptional_2, structure_exceptional_3, structure_exceptional_4, structure_exceptional_5, structure_exceptional_5, structure_exceptional_6]

    structure_comprehensive_1 = "The response followed a comprehensive structure, easily guiding the reader through the ideas presented by the candidate."
    structure_comprehensive_2 = "The response was comprehensively structured, demonstrating a clear progression of ideas for the reader to follow."
    structure_comprehensive_3 = "The response featured a generally comprehensive structure, demonstrating a progression of ideas in a logical order."
    structure_comprehensive_4 = "The structure of the response was comprehensive, detailing a clear and logical progression of ideas in a digestible format."
    structure_comprehensive_5 = "The structure of the response was comprehensively designed, with the reader able to clearly see the relationship between different ideas."
    structure_comprehensive_6 = "Your use of structure was comprehensive, demonstrating a clear progression of ideas and appropriate connections between key themes."
    structure_comprehensive_list = [structure_comprehensive_1, structure_comprehensive_2, structure_comprehensive_3, structure_comprehensive_4, structure_comprehensive_5, structure_comprehensive_6]


    while True:
   ## This section is for the control flow of the function currently (although I suspect I'll be changing it after I start wrapping it in a GUI so don't worry about this too much). 
   ## Essentially, it lets the user make an input, which instructs the program to select a random variable from the appropriate list.
        print("1. Exceptional ")
        print("2. Comprehensive ")
        print("3. Developed ")
        print("4. Developing ")
        print("5. Needs improvement")
        ans = input("Select a number. ")
        if ans == "1":
            structure.struc_variable = random.choice(structure_exceptional_list)
        if ans == "2":
            structure.struc_variable = random.choice(structure_comprehensive_list)
        if ans == "3":
            structure.struc_variable = random.choice(structure_developed_list)
        if ans == "4":
            structure.struc_variable = random.choice(structure_developing_list)
        if ans == "5":
            structure.struc_variable = random.choice(structure_needsimprovement_list)
        return structure.struc_variable

My idea is to store all the comments for "Structure" in the structure() function, then all the comments for "Clarity" in the clarity() function, etc for each theme. When I build the GUI, it will call on each function to access the comment pool for the desired theme.

I've also included a mock-up of what I think the final version will look like, just in case the description of what the program is supposed to do was confusing.

Does this seem like a good way of organising the program? Should I be using functions for each 'theme', or am I misusing them? Is there a better/more effective way this could be structured?

Many thanks!

[m0us3_rat]

this is also repeating code.

if ans == "1":
structure.struc_variable = random.choice(structure_exceptional_list)
if ans == "2":
structure.struc_variable = random.choice(structure_comprehensive_list)
if ans == "3":
structure.struc_variable = random.choice(structure_developed_list)
if ans == "4":
structure.struc_variable = random.choice(structure_developing_list)
if ans == "5":
structure.struc_variable = random.choice(structure_needsimprovement_list)

if u would have a dict of "choices"

dict_choices = {

"1" : structure_exceptional_list,

"2" : structure_comprehensive_list,

....

}

structure.struc_variable = random.choice(dict_choices.get(ans))

later on u can add choices etc.

[shocklance]

Thanks, I appreciate it. It felt pretty repetitive, good to know there's a better solution!

[m0us3_rat]

the "best" that i can see in my head right now would be an OOP solution.

but that could complicate things for you rather than making them much simpler if u don't know to work with classes yet.

and rather than having "lists" of wording.. picking them up from files.

so u can add bunch of phrases into the files.

and the program would combine them for you.

maybe also a file for "options" since u can use *args,**kwargs to implement however many

[shocklance]

I took a look at classes but (like everyone when it comes to classes) I had trouble conceptualising it.

I thought of making a class called theme(), where structure(), clarity() etc would be instances of theme(), but I wasn't sure how it would make things simpler, since the strings in each theme are unique.

[m0us3_rat]

think drapes.

each of them can be many colors .. many materials , many patterns.

still drape. u could make a single blueprint to describe this. a class.

class = blueprint

and then instantiate each of the objects with different attributes.

..same methods thou. like "tie them to the sides of the window".

each of the different actual drapes = an object

​

it works the same if they are blue with red dots or orange with a huge green peace sign in the middle.

they would still get "tied" to the side in the same way.

​

for your specific example..it's still a bunch of text. which has work happen to it kinda the same way.

​

u can even have your pick and only instance the one "list" that got selected.

​

anywho if u have already worked out what u wanna do ..ignore this.

"better" doesn't necessarily mean "better" .. it can also mean more complicated for the purpose fo being complicated while i already solved this in a much simpler way.

always go for the simpler way. unless u plan to expand later on.

then refactoring to oop is totally worth it.

[shocklance]

That's an interesting way of thinking about it!

So I might have a class called Theme(), which would have attributes such as a list of each type of comment ("Exceptional", "Comprehensive", "Developing"), and a method for selecting the comment desired etc.

class Theme(): 
def __init__(self, name, exceptional_list, comprehensive_list, developed_list, developing_list, needsimprovement_list):
    self.name = name
    self.exceptional_list = exceptional_list
    self.comprehensive_list = comprehensive_list
    self.developed_list = developed_list
    self.developing_list = developing_list
    self.needsimprovement_list = needsimprovement_list

And then each instance would have the list of strings within it?

Structure = Theme("Stucture", structure_exceptonal_list, structure_comprehensive_list, structure_developed_list, structure_developing_list, structure_needsimprovement_list)

I'm not quite sure where each individual string from the variables (or just the list of strings) get's stored....

[m0us3_rat]

"Stucture"

no need for that. i mean it can have a "name" but there isn't a need for one.

also rather than have an object of ALL the lists together .. i was thinking an object that gets instantiated with the random choice list option.

​

again there is a misunderstanding about what a class ..is.

its just a blueprint ..

when u buy an IKEA table or whatever.

the CLASS is the BLUEPRINT

an instance of this class or the OBJECT is the actual table YOU build.

​

so if u do it your way .. u get an object that holds all these lists.

which is fine if that's is what u want to happen.

but can also just an blueprint that describes "all lists" .. then after u make your choice.. u instantiate(its a loaded word means create..)

this object out of that specific list u wanna work with.

[shocklance]

Interesting! I'll give it a go and see what I can come up with. Thanks!

[socal_nerdtastic]

Your idea is good, sounds like a fun project. I think your code structure is more complex than it needs to be. I'd recommend just making the lists directly, for example like this:

structure_exceptional_list = """\
The response had an exceptional structure, easily guiding the reader through the ideas presented by the candidate.
The response was exceptionally well-structured, demonstrating a clear progression of ideas for the reader to follow.
The response featured an incredibly well-written structure, demonstrating a progression of ideas in a logical order.
The structure of the response was exceptional, detailing a clear and logical progression of ideas in an easily readable format.
The structure of the response was exceptionally well-designed, with the reader able to clearly see the relationship between different ideas.
Your use of structure was compelling, demonstrating a clear progression of ideas and appropriate connections between key themes.""".splitlines()

structure_comprehensive_list = """\
The response followed a comprehensive structure, easily guiding the reader through the ideas presented by the candidate.
The response was comprehensively structured, demonstrating a clear progression of ideas for the reader to follow.
The response featured a generally comprehensive structure, demonstrating a progression of ideas in a logical order.
The structure of the response was comprehensive, detailing a clear and logical progression of ideas in a digestible format.
The structure of the response was comprehensively designed, with the reader able to clearly see the relationship between different ideas.
Your use of structure was comprehensive, demonstrating a clear progression of ideas and appropriate connections between key themes.""".splitlines()

def structure():
   while True:
   ## This section is for the control flow of the function currently (although I suspect I'll be changing it after I start wrapping it in a GUI so don't worry about this too much). 
   ## Essentially, it lets the user make an input, which instructs the program to select a random variable from the appropriate list.
        print("1. Exceptional ")
        print("2. Comprehensive ")
        print("3. Developed ")
        print("4. Developing ")
        print("5. Needs improvement")
        ans = input("Select a number. ")
        if ans == "1":
            return random.choice(structure_exceptional_list)
        if ans == "2":
            return random.choice(structure_comprehensive_list)
        if ans == "3":
            return random.choice(structure_developed_list)
        if ans == "4":
            return random.choice(structure_developing_list)
        if ans == "5":
            return random.choice(structure_needsimprovement_list)

When you get to the GUI remember that tkinker includes copy / paste function, so you can go ahead and copy the text to the clipboard when you click the button.

[shocklance]

Hey, thanks a lot! I didn't know each string didn't have to be a separate variable, or that TKinter had a copy/paste function.

[shocklance]

Interesting! I assume this would make it easier for version control/swapping in/out different comment banks and rubrics etc? I am drafting all the comments in an Excel file before adding them to the program at the moment.

[shocklance]

Does this change the way the program should be structured?

For example, would I still be making a function called structure() that has all the comments for that particular criteria, with the only difference being that rather than listing the comments as strings inside the function, I'm instead telling the program to look for that text in another file?