Python: Function takes 1 argument for 2 given

Question

I have looked on this website for something similar, and attempted to debug using previous answers, and failed.

I'm testing (I did not write this module) a module that changes the grade value of a course's grades from a B- to say a B, but never going across base grade levels (ie, B+ to an A-).

The original module is called transcript.py I'm testing it in my own testtranscript.py

I'm testing that module by importing it: 'import transcript' and 'import cornelltest' I have ensured that all files are in the same folder/directory.

There is the function raise_grade present in transcript.py (there are multiple definitions in this module, but raise_grade is the only one giving me any trouble). ti is in the form ('class name', 'gradvalue')

There's already another definition converting floats to strings and back (ie 3.0--> B).

def raise_grade(ti):
""""Raise gradeval of transcript line ti by a non-noticeable amount.


"""
# value of the base letter grade, e.g., 4 (or 4.0) for a 4.3
bval = int(ti.gradeval)
print 'bval is:"' + str(bval) + '"'

# part after decimal point in raised grade, e.g., 3 (or 3.0) for a 4.3
newdec = min(int((ti.gradeval + .3)*10) % 10, 3)
print 'newdec is:"' + str(newdec) + '"'

# get result by add the two values together, after shifting  newdec  one
# decimal place
newval = bval + round(newdec/10.0, 1)
ti.gradeval = newval
print 'newval is:"' + str(newval) + '"'

I will probably get rid of the print later.

When I run testtranscript, which imports transcript:

def test_raise():
"""test raise_grade"""
testobj = transcript.Titem('CS1110','B-')
transcript.raise_grade('CS1110','B-')
cornelltest.assert_floats_equal(3.0,transcript.lettergrade_to_val("B-"))

I get this from the cmd shell: TypeError: raise_grade takes exactly 1 argument (2 given)

Edit1: So now I see that I am giving it two parameters when raise_grade(ti) is just one, but perhaps it would shed more light if I just put out the rest of the code. I'm still stuck as to why I get a ['str' object has no gradeval error]

LETTER_LIST = ['B', 'A']

# List of valid modifiers to base letter grades.
MODIFIER_LIST = ['-','+']

def lettergrade_to_val(lg):
"""Returns: numerical value of letter grade lg.

The usual numerical scheme is assumed: A+ -> 4.3, A -> 4.0, A- -> 3.7, etc.

Precondition: lg is a 1 or 2-character string consisting of a "base" letter
in LETTER_LIST optionally followed by a modifier in MODIFIER_LIST."""

# if LETTER_LIST or MODIFIER_LIST change, the implementation of
# this function must change.

# get value of base letter. Trick: index in LETTER_LIST is shifted from value
bv = LETTER_LIST.index(lg[0]) + 3
# Trick with indexing in MODIFIER_LIST to get the modifier value
return bv + ((MODIFIER_LIST.index(lg[1]) - .5)*.3/.5 if (len(lg) == 2) else 0)


class Titem(object):
"""A Titem is an 'item' on a transcript, like "CS1110 A+"

Instance variables:
    course [string]: course name.  Always at least 1 character long.

    gradeval [float]: the numerical equivalent of the letter grade.
                      Valid letter grades are 1 or 2 chars long, and consist
                      of a "base" letter in LETTER_LIST optionally followed
                      by a modifier in MODIFIER_LIST.
                      We store values instead of letter grades to facilitate
                      calculations of GPA later.

                      (In "real" life, one would write a function that,
                      when displaying a Titem, would display the letter
                      grade even though the underlying representation is
                      numerical, but we're keeping things simple for this
                      lab.)
"""

def __init__(self, n, lg):
    """Initializer: A new transcript line with course (name) n, gradeval
       the numerical equivalent of letter grade lg.

       Preconditions: n is a non-empty string.
       lg is a string consisting of a "base" letter in LETTER_LIST
       optionally followed by modifier in MODIFIER_LIST.
       """
    # assert statements that cause an error when preconditions are violated
    assert type(n) == str and type(lg) == str, 'argument type error'
    assert (len(n) >= 1 and  0 < len(lg) <= 2 and lg[0] in LETTER_LIST and
            (len(lg) == 1 or lg[1] in MODIFIER_LIST)), 'argument value error'

    self.course = n
    self.gradeval = lettergrade_to_val(lg)

Edit2: I understand the original problem... but it seems that the original writer screwed up the code, since raise_grade doesn't work properly for grade values at 3.7 ---> 4.0, since bval takes the original float and makes it an int, which doesn't work in this case.

Answer 1

You are calling the function incorrectly, you should be passing the testobj:

def test_raise():
    """test raise_grade"""
    testobj = transcript.Titem('CS1110','B-')
    transcript.raise_grade(testobj)
    ...

The raise_grade function is expecting a single argument ti which has a gradeval attribute, i.e. a Titem instance.