Exemple #1
0
def getAssignments(courseURL, daSession):

    id_resp = daSession.get(courseURL)
    parsed_id_resp = BeautifulSoup(id_resp.text, 'html.parser')

    # find table
    tableOfAssignment = parsed_id_resp.find(
        "table", {"id": "assignments-student-table"})
    # print("\nPrinting table")
    #  print(tableOfAssignment)

    # find all assignemnts
    assignmentList = tableOfAssignment.find_all("tr", {"role": "row"})
    #  print("\nPrinting assignment list")
    # for assign in assignmentList:
    #     print(assign)

    listOfAssignments = []

    # for each assignment, find its title, due date, due time
    for assignment in assignmentList:
        # find title
        allText = assignment.text

        print("printing assignment")
        print(allText)

        title = "Filler"

        if (allText.find('Submitted') >= 0):
            submitIndex = allText.find('Submitted')
            title = allText[0:submitIndex]
        elif (allText.find("No Submission") >= 0):
            noSubmitIndex = allText.find('No Submission')
            title = allText[0:noSubmitIndex]
        else:
            slashIndex = allText.find('/')
            title = allText[0:slashIndex - 1]

        # find due date/time
        if (allText.find('Due Date') < 0):
            continue
        indexOfDueDate = allText.find('Due Date') + 10
        time = allText[indexOfDueDate:indexOfDueDate + 17]

        listOfAssignments.append(Assignment(title, time))
        hi = Assignment(title, time)

    # for hi in listOfAssignments:
    #   print(hi.title + " " + hi.dueDateTime)
    return listOfAssignments
Exemple #2
0
    def generate_column_drops(root, player_mark, opposite_player_mark, board):

        temp_board = deepcopy(board)

        if root.assignment is not None:
            if root.assignment.is_winning_move:
                return

        for column in range(COLUMN_COUNT):

            # column has already been filled
            if temp_board.is_invalid_move(column):
                continue

            board = deepcopy(temp_board)

            row = board.next_free_row_for_column(column)

            board.drop_coin(column, player_mark)

            assignment_id = Helper.next_node_name_from(None)

            assignment = \
                Assignment(
                    assignment_id=Helper.next_node_name_from(assignment_id),
                    board=board,
                    row=row,
                    col=column,
                    player_mark=player_mark,
                    opposite_player_mark=opposite_player_mark,
                    is_winning_move=board.is_winning_move(row, column, player_mark)
                )

            node = Node(assignment_id, root, assignment=assignment)
Exemple #3
0
def main():
    a = Assignment()
    a.prompt()

    print()

    a.display()
Exemple #4
0
    def add_assignment(self, name, expression):
        """Add an assigmnet statement to our program"""

        # add to our list of assignments
        self.assignments.append(Assignment(name, expression))

        # add to our list of possible variables when for building an
        # expression tree
        self.variables.add(name)
Exemple #5
0
    def test_assignment_starts_with_empty_state(self):
        # Arrange
        assignment = Assignment()

        # Act
        count = assignment.count()

        # Assert
        self.assertEqual(0, count)
Exemple #6
0
    def test_unset_variable_name_is_none(self):
        # Arrange
        assignment = Assignment()

        # Act
        value = assignment.get('UNSET')

        # Assert
        self.assertIsNone(value)
 def read_repo(self):
     open_file = open(self.file_n, 'r')
     line = open_file.readline().strip()
     while len(line) > 0:
         line_items = line.split("-")
         file_assignment = Assignment(line_items[1], line_items[2],
                                      int(line_items[0]))
         self.assignments.append(file_assignment)
         line = open_file.readline().strip()
     open_file.close()
    def test_not_violated_if_variable_not_set(self):
        # Arrange
        variable = Variable('1', Domain([1]))
        constraint = EqualConstraint(variable, 1)
        assignment = Assignment()

        # Act
        result = constraint.is_violated(assignment)

        # Assert
        self.assertFalse(result)
Exemple #9
0
 def __make_assignment__(self, student, ind_status, by):
     assignment = Assignment(
         student_id=student.id,
         school_id=self.school_id,
         unique_school_id=self.unique_id,
         order_of_preference=student.get_preference_order_for_school(
             self.unique_id),
         voorkeur=student.get_preference_for_school(self.unique_id),
         assigned_by=by,
         ind_status=ind_status)
     return assignment
    def test_consistent_for_empty_assignment(self):
        # Arrange
        variables = [Variable('1', Domain([1, 2, 3]))]
        constraints = [EqualConstraint(variables[0], 2)]
        csp = ConstraintSatisfactionProblem(variables, constraints)
        assignment = Assignment()

        # Act
        consistent = csp.consistent(assignment)

        # Assert
        self.assertTrue(consistent)
Exemple #11
0
 def test_missingFile_keepGoing(self):
     out = self._get_stdout_as_StringIO()
     try:
         collector = Collector(OUTFILE)
         Assignment(sandbox.dir('issue28.json')).accept(collector.visit)
         self.assertTrue(len(collector.get_lines()) == 5)
         output = out.getvalue().strip()
         self.assertRegex(output,
                          'Not found: .*student2/file1.txt',
                          msg=output)
     finally:
         self._restore_stdout()
Exemple #12
0
 def test_unit(self: TestClause):
     clause = Clause([-6, 5, -4, 3, -2, 1])
     a1 = Assignment(set([1, 2, 3, 4, 5, 6]))
     a1.add_assignment(0, 6, 1, None)
     clause.assign(a1)
     a1.add_assignment(1, 5, 0, None)
     a1.add_assignment(2, 3, 0, None)
     a1.add_assignment(2, 4, 1, None)
     a1.add_assignment(2, 1, 0, None)
     clause.assign(a1)
     self.assertEqual(clause.get_state(a1), (Clause.UNIT, 2, 2))
     self.assertEqual(clause.get_assigned_vars(a1), [6, 5, 4, 3, 1])
Exemple #13
0
    def test_set_adds_assignment(self):
        # Arrange
        assignment = Assignment()
        variable_name = 'A'
        variable_value = 10

        # Act
        assignment.set(variable_name, variable_value)

        # Assert
        self.assertEqual(1, assignment.count())
        self.assertTrue(assignment.is_set(variable_name))
        self.assertEqual(variable_value, assignment.get(variable_name))
Exemple #14
0
    def test_unset_removes_assignment(self):
        # Arrange
        variable_name = 'A'
        assignment = Assignment()
        assignment.set(variable_name, 10)

        # Act
        assignment.unset(variable_name)

        # Assert
        self.assertEqual(0, assignment.count())
        self.assertFalse(assignment.is_set(variable_name))
        self.assertIsNone(assignment.get(variable_name))
    def test_not_violated_if_variable_equal(self):
        # Arrange
        expected_value = 1
        variable = Variable('1', Domain([expected_value]))
        constraint = EqualConstraint(variable, expected_value)
        assignment = Assignment()
        assignment.set(variable.name, expected_value)

        # Act
        result = constraint.is_violated(assignment)

        # Assert
        self.assertFalse(result)
Exemple #16
0
    def __init__(self):
        # 建立 cplex 模型
        self.A = Assignment()
        self.M = cplex.Cplex()
        self.M.objective.set_sense(self.M.objective.sense.minimize)

        # 这儿是随机选取的指派问题结果的第一组值
        self.my_obj = self.A.costs_all()[0]
        # print(my_obj)
        self.my_rhs = [1.0] * self.A.one.customer_num + [
            self.A.one.truck_cap + self.A.one.trailer_cap
        ] * self.A.trailer_num + [self.A.one.truck_cap
                                  ] * (self.A.truck_num - self.A.trailer_num)
    def test_not_violated_if_variables_not_set(self):
        # Arrange
        variables = [
            Variable(str(i), Domain(list(range(1, 10)))) for i in range(9)
        ]
        constraint = AllDiffConstraint(variables)
        assignment = Assignment()

        # Act
        result = constraint.is_violated(assignment)

        # Assert
        self.assertFalse(result)
    def test_order_domain_values_returns_all_domain_values(self):
        expected_values = set([1, 2, 3])
        variables = [Variable('1', Domain(list(expected_values)))]
        constraints = []
        csp = ConstraintSatisfactionProblem(variables, constraints)
        assignment = Assignment()
        values = set()

        # Act
        for value in csp.order_domain_values(variables[0], assignment):
            values.add(value)

        # Assert
        self.assertEqual(expected_values, values)
Exemple #19
0
    def __init__(self, players, roles, include_ai=0):
        if len(roles) != len(players) + 3 + (include_ai):
            raise Exception('you done fd up. %s != %s' % (players, roles))

        self.roles = [Role(r) for r in roles]
        self.players = [
            Player(p.name, inform=p.inform, ask=p.ask) for p in players
        ] + [Center(i) for i in range(3)]
        for i in range(include_ai):
            self.players.append(
                AIPlayer('AI_' + str(i), self.roles, self.players))
        self.assignment = Assignment({}, roles)
        self.assign()
        self.inform_players()
        print self.assignment
    def test_not_violated_if_all_variables_different(self):
        # Arrange
        assignment = Assignment()
        variables = []
        for i in range(9):
            variable = Variable(str(i), Domain(list(range(1, 10))))
            variables.append(variable)
            assignment.set(variable.name, i + 1)
        constraint = AllDiffConstraint(variables)

        # Act
        result = constraint.is_violated(assignment)

        # Assert
        self.assertFalse(result)
 def __init__(self):
     parser = argparse.ArgumentParser()
     parser.add_argument('config', help='JSON configuration file')
     parser.add_argument(
         '-v', '--verbose',
         help='increase output verbosity',
         action='store_true'
         )
     args = parser.parse_args()
     Command.set_default_verbosity(args.verbose)
     self._a2pdf = Command(
         'a2pdf --noperl-syntax --noline-numbers "{ins}" -o "{ins}.pdf"')
     self._pdfcat = Command('pdftk "{ins}" cat output "{outs}"')
     self._create_log = Command('git log > log.txt')
     self._rm = Command('rm "{ins}"')
     Assignment(args.config).accept(self.process_submission)
    def test_not_consistent_if_assignment_violates_constraint(self):
        # Arrange
        variables = [
            Variable('1', Domain([1, 2, 3])),
            Variable('2', Domain([1, 2]))
        ]
        constraints = [EqualConstraint(variables[0], 2)]
        csp = ConstraintSatisfactionProblem(variables, constraints)
        assignment = Assignment()
        assignment.set(variables[0].name, 3)

        # Act
        consistent = csp.consistent(assignment)

        # Assert
        self.assertFalse(consistent)
 def read_repo(self):
     try:
         open_file = open(self.file_n, "rb")
         save_assignments_lists = pickle.load(open_file)
         for assignment_list in save_assignments_lists:
             # we created a assignment
             file_assignment = Assignment(assignment_list[1],
                                          assignment_list[2],
                                          assignment_list[0])
             self.assignments.append(
                 file_assignment)  # we got him in the list
         open_file.close()
     except EOFError:  # pickle will give an error if the file is empty
         pass
     except IOError as error:  # if it's an input error
         raise error
def main():

    print(
        "\n\n" + '\033[1m' +
        "A csipet-csapat megérkezik a Codecoolba és jó szokásukhoz híven, a konyha felé veszik az irányt."
        + '\033[0m' + "\n")

    pakko = Kitchen()
    pakko.who_is_in_the_kitchen()
    print(
        "\n" + pakko.student_in_kitchen +
        " neki áll vedelni a mogyorós kávét liter számra... Csak mert nem ő vette..."
    )
    pakko.coffee_left(3)
    pakko.fridge_space_left(60)
    pakko.pakkos_phrases()

    print(
        "\n\n" + '\033[1m' +
        "És eljött vala az idő, hogy megtekintsük, mikor lesz a következő meeting és, hogy mi lesz a téma!"
        + '\033[0m' + "\n")

    peba = Meeting()
    peba.next_meeting()
    peba.topic_generator()
    print(
        "\n\n" + '\033[1m' +
        "Miután lement a meeting, a mentoroknak eszükbe jutott, hogy fogytán a motiváció.\nMost átgondolják, hogy mikor fogja lehúzni róluk a nadrágot a sok della súlya újra. "
        + '\033[0m' + "\n")

    atesz = Salary(1)
    atesz.days_until_payday()
    atesz.warning_messages()

    print(
        "\n\n" + '\033[1m' +
        "Most, hogy a motiváció a tetőfokára hágott, a kiadandó feladatokat is megbeszélik a mentorok."
        + '\033[0m' + "\n")

    imi = Assignment("Imre")
    imi.grading_assignment("Vajnorák Zsolt")
    imi.making_assignment()
    print("")
    pakko.pakkos_phrases()

    print("\n\n" + '\033[1m' +
          "Itt a móka vége mára, induljunk hát a kocsmába.\n")
    def test_not_violated_if_some_variables_not_set(self):
        # Arrange
        assignment = Assignment()
        variables = []
        for i in range(9):
            variable = Variable(str(i), Domain(list(range(1, 10))))
            variables.append(variable)
            if i < 4:
                # Only assign some of the values
                assignment.set(variable.name, i + 1)
        constraint = AllDiffConstraint(variables)

        # Act
        result = constraint.is_violated(assignment)

        # Assert
        self.assertFalse(result)
    def test_select_unassigned_variable_returns_valid_variable(self):
        # Arrange
        variables = [
            Variable('1', Domain([1, 2, 3])),
            Variable('2', Domain([1, 2]))
        ]
        constraints = [EqualConstraint(variables[0], 2)]
        csp = ConstraintSatisfactionProblem(variables, constraints)
        assignment = Assignment()
        assignment.set(variables[0].name, 2)

        # Act
        variable = csp.select_unassigned_variable(assignment)

        # Assert
        self.assertIsNotNone(variable)
        self.assertEqual(variables[1].name, variable.name)
    def test_violated_if_at_least_one_variable_not_different(self):
        # Arrange
        assignment = Assignment()
        variables = []
        for i in range(8):
            variable = Variable(str(i), Domain(list(range(1, 10))))
            variables.append(variable)
            assignment.set(variable.name, i + 1)
        non_unique_variable = Variable('8', Domain(list(range(1, 10))))
        variables.append(non_unique_variable)
        assignment.set(non_unique_variable.name, 1)
        constraint = AllDiffConstraint(variables)

        # Act
        result = constraint.is_violated(assignment)

        # Assert
        self.assertTrue(result)
    def test_select_unassigned_variable_raises_exception_if_variable_not_available(
            self):
        # Arrange
        exception_thrown = False
        variables = [Variable('1', Domain([1]))]
        constraints = []
        csp = ConstraintSatisfactionProblem(variables, constraints)
        assignment = Assignment()
        assignment.set(variables[0].name, 1)

        # Act
        try:
            csp.select_unassigned_variable(assignment)
        except:
            exception_thrown = True

        # Assert
        self.assertTrue(exception_thrown)
    def test_consistent_and_complete_for_full_assignment(self):
        # Arrange
        variables = [
            Variable('1', Domain([1, 2, 3])),
            Variable('2', Domain([1, 2]))
        ]
        constraints = [EqualConstraint(variables[0], 2)]
        csp = ConstraintSatisfactionProblem(variables, constraints)
        assignment = Assignment()
        assignment.set(variables[0].name, 2)
        assignment.set(variables[1].name, 1)

        # Act
        consistent = csp.consistent(assignment)
        complete = csp.complete(assignment)

        # Assert
        self.assertTrue(consistent)
        self.assertTrue(complete)
Exemple #30
0
 def test_backtrack(self: TestClause):
     clause = Clause([-6, 5, -4, 3, -2, 1])
     a1 = Assignment(set([1, 2, 3, 4, 5, 6]))
     a1.add_assignment(0, 5, 0, None)
     a1.add_assignment(1, 3, 0, None)
     clause.assign(a1)
     a1.add_assignment(1, 6, 1, None)
     a1.add_assignment(1, 4, 1, None)
     a1.add_assignment(2, 1, 0, None)
     a1.add_assignment(2, 2, 1, None)
     clause.assign(a1)
     self.assertEqual(clause.get_state(a1), (Clause.UNSATISFIED, 1, 1))
     self.assertEqual(clause.get_assigned_vars(a1), [6, 5, 4, 3, 2, 1])
     clause.backtrack(1)
     a1.backtrack(1)
     self.assertEqual(clause.get_state(a1), (Clause.UNRESOLVED, 2, 1))
     self.assertEqual(clause.get_assigned_vars(a1), [6, 5, 4, 3])
     clause.backtrack(0)
     a1.backtrack(0)
     self.assertEqual(clause.get_state(a1), (Clause.UNRESOLVED, 6, 1))
     self.assertEqual(clause.get_assigned_vars(a1), [5])