challenges package

Submodules

challenges.challenge module

Core module of challenges

This module holds the base class of all challenges.

class challenges.challenge.Challenge

Base class of all challenges

Idea of this class is the Template Method Design Pattern (GOF).

The main() method controls the overall workflow by calling the worker methods read(), build(), calc() and format() in that order. Typically the main() method is not changed.

The workers need to be extended or implemented by the inheriting challenge implementations.

• read(): This method is typically not changed.
• build(): Abstract method that needs implementation.
• calc(): Abstract method. The implementation holds or calls the algorithm

of the challenge. * format(): Needs implementation for advanced challenges.

The other functions are library methods to support the implementation of the workers. Most of them support extraction of data from the input lines or formatting the output.

br = '\n'

Line breaks as expected by the most graders.

build()

Set up the model from the input lines.

This method must be implemented. Reads from self.lines. Fills self.model.

calc()

Main algorithm of the challenge.

This method must be implemented. Here the interesting stuff happens. Best practice is to delegate to functions, that are named by the algorithms used or even to other classes that implement the algorithm.

Reads from self.model. Fills self.result.

edge_pattern = '^(\\d+)->(\\d+)(:(\\d+))?$'

Regex to exctract graph edges.

A default setting used by methods that extract edges from input lines. May need adjustment for differnt kind of edge input formats.

format()

Foramt the output string.

In simple cases this method can be used as is. In other cases it needs to be reimplemented.

Reads from self.result. Fills self.output.

static format_list_of_integers(integers, joint=', ')

format_path(integers, backwards=False)

line(number)

line_break = '\n'

Line breaks as expected by the most graders.

line_to_edge(nr)

line_to_floats(line_nr)

line_to_integers(line_nr)

lines()

A list of lines that will be filled by the method read().

main()

Control the workflow of the challenge.

This method usually doesn’t need a different implementation. This workflow is the common character of all challenges.

The methods share data via instance variables. The overall input is injected into self.sample. The overall output is read from self.result.

model = None

The imported data model.

A flexible namespace object to take up any kind of data. In simple cases this may be completely overwritten, i.e by a list or dict.

output = None

The output string.

The string representation of the resulting model as expected by the grader.

read()

Extract the input string self.sample into self.lines.

Typically this method can be used as is.

read_edges(first=0, last=None)

result = None

The resulting data model.

A flexible namespace object to take up any kind of data. In simple cases this may be completely overwritten, i.e by a list or dict.

sample = 'sample'

Holds a minimal example of the input.

This variable should always be overwritten in the derived class by a smallest example of the challenges input. It is expected by the challenge runner (–klass option) as well as by unit tests to be present.

split_pattern = '\\s+|\\s?,\\s?'

Regex pattern to split input lines.

Used by some of the input parsing functions. By default it splits by whitespace and/or comma. If the input is separated differently like colons or semicolons it needs adjustment in the inheriting class.

challenges.conf module

class challenges.conf.Conf

get_challenge()

get_challenge_class()

get_challenge_dir()

get_challenge_file()

get_challenges()

static get_class(class_)

get_full_qualified_challenge_class()

get_full_qualified_unittest_class()

get_input_file()

get_latest_at_root()

get_latest_file()

get_result_file()

get_sample_file()

get_unittest()

get_unittest_file()

parse_arguments()

print_help()

challenges.main module

challenges.main.main()

challenges.runner module

class challenges.runner.Runner(conf)

list_challenges()

main()

read_file()

run_challenge()

run_unittest()

set_sample(challenge)

write(challenge)

challenges.scaffold module

class challenges.scaffold.Scaffold(conf)

get_class_content()

get_unittest_content()

scaffold()

Module contents