Directory Structure

                                    ├── Driver.py
                                    ├── Enums.py
                                    ├── Graph.py
                                    ├── LinkedList.py
                                    ├── Objects.py
                                    ├── Revenue.py
                                    ├── Simulator.py
                                    ├── Solution.py
                                    ├── Traversals.py
                                    ├── Utility.py
                                    ├── test cases/
                                    │   ├── input1.txt
                                        ├── input1.txt-info
                                        

You are given ten coding files. Out of these, you can safely ignore Enums.py and LinkedList.py. These files are merely required to do some processing in the background. For example, Enums.py is used in conjunction with the file I/O code. LinkedList.py is an implementation of a linked list in Python since there is no standard one.

Driver.py takes the input file, parses it using Utility.py and calls your Solution.py class' output_paths() method on data structures it creates. The $i-c$ paths your code outputs (along with, depending on the question, the updated bandwidths and packet priorities) are passed into the routing simulator inside Simulator.py, which processes them and determines the routing delay faced by each client. Finally, these delays are passed into the revenue calculation function inside Revenue.py. It then prints the revenue you gathered based on your routing decisions. You only need to update the Solution.py file. You may write your own helper methods and data structures in it.

The Solution class contains four data structures.

• problem, which simply contains the problem number of the current template as a member variable on the Solution class. You DO NOT need to worry about this variable.
• isp which is the ID of the ISP node. Note that this is the same as content provider or $i$ as mentioned in the problem description.
• graph which is the input graph $G$ in the adjacency list representation that you are familiar with. The key is a node ID (not client, there are nodes that may not be clients) and the value is the list of nodes it is connected to.
• info which is a mapping between a string representing the various input parameters and the corresponding data structure. For example, info["bandwidths"] lets you access the mapping between node IDs and their bandwidths. More details on info below.

As outlined in the problem descriptions, there are various additional input parameters provided to you besides the graph, which you can use to influence the routing. These are available through the info data structure available as a member variable of the Solution class. The parameters are listed as follows:

1. list_clients [list of client IDs] is a list of all clients in $C$
2. bandwidths [dict: node IDs (int) -> bandwidth (int)] maps $u\in V$ to $b_u$
3. alphas [dict: client IDs (int) -> alphas (float)] maps $c\in C$ to $\alpha_c$
4. payments [dict: client IDs (int) -> payments (float)] maps $c\in C$ to $\text{pmt}_c$
5. betas [dict: client IDs (int) -> betas (float)] maps $c\in C$ to $\beta_c$
6. is_rural [dict: client IDs (int) -> is_rural ({0, 1})] if is_rural[$c$]= 0, then $c\not\in R$ and if =1, then $c\in R$
7. is_fcc [dict: client IDs (int) -> is_fcc ({0, 1})] if is_fcc[$c$] =0, then $c\not\in S$ and if =1, then $c\in S$.
8. rho1 [float] same as $\rho_{\text{lawsuit}}$
9. rho2 [float] same as $\rho_{\text{fcc}}$
10. lawsuit [float] same as $A$
11. fcc_fine [float] same as $B$
12. cost_bandwidth [float] same as $Z$

Your method is expected to return a dictionary indexed by client IDs with their $i$-$c$ path as the value. For problems 3, 4, 5 you also need to return a dictionary indexed by node IDs with their updated bandwidth as the value. For problems 4 and 5 you further need to return a dictionary indexed by client IDs with their priorities as the value. As a reminder if you return an object you are not supposed to, for example, priorities in problem 2, it will be ignored by the grader.

Executing from command line:

Assuming you are in the same directory level as Driver.py and you want to run your code on the input1.txt. Run python Driver.py test cases/input1.txt.

Submission

You only need to submit Solution.py to Autolab.

    def run(self, graph, isp, list_clients, paths, bandwidths, priorities, is_rural):
        """
        Runs the simulation based on the paths provided by the student
        """

    def get_delays(self, list_clients):
        """
        Returns the delay experienced by each client after the simulation has
        run its course
        """

    def revenue(self, client_list, alphas, betas, optimal_dict, payments, lawsuit, rho_lawsuit, fcc_fine, rho_fcc, is_fcc,
                pen_1, pen_2, updated_bandwidths, original_bandwidths, update_cost):
        """
        determines overall revenue
         
        :param client_list: list of client objects
        :param alphas: mapping of clients to their alpha values
        :param betas: mapping of clients to their beta values
        :param optimal_dict: mapping of clients to their optimal delays
        :param payments: mapping of clients to their payment values
        :param lawsuit: lawsuit cost
        :param rho_lawsuit: lawsuit factor
        :param rho_fcc: fcc factor
        :param is_fcc: mapping of nodes to either 0 or 1
        :param fcc_fine: fcc penalty
        :param pen_1: if the lawsuit should be taken into account
        :param pen_2: if the fcc should be taken into account
        :param updated_bandwidths mapping of nodes to new bandwidths as set by the solution
        :param original_bandwidths mapping of nodes to original bandwidths as provided by the problem
        :param cost to upgrade the bandwidth by 1

        :return: the total revenue
        """
                                            

Problem 1

Method you need to write:

                                    def output_paths(self):
                                        """
                                        This method must be filled in by you. You may add other methods and subclasses as you see fit,
                                        but they must remain within the Solution class.
                                        """
                                        paths, bandwidths, priorities = {}, {}, {}

                                        return (paths, bandwidths, priorities)
                                

Problem 2

Method you need to write:

                                    def output_paths(self):
                                        """
                                        This method must be filled in by you. You may add other methods and subclasses as you see fit,
                                        but they must remain within the Solution class.
                                        """
                                        paths, bandwidths, priorities = {}, {}, {}

                                        return (paths, bandwidths, priorities)
                                

Problem 3

Method you need to write:

                                    def output_paths(self):

                                        """
                                        This method must be filled in by you. You may add other methods and subclasses as you see fit,
                                        but they must remain within the Solution class.
                                        """
                                        paths, bandwidths, priorities = {}, {}, {}

                                        return (paths, bandwidths, priorities)
                                

Problem 4

Method you need to write:

                                    def output_paths(self):
                                        """
                                        This method must be filled in by you. You may add other methods and subclasses as you see fit,
                                        but they must remain within the Solution class.
                                        """

                                        paths, bandwidths, priorities = {}, {}, {}

                                        return (paths, bandwidths, priorities)
                                

Problem 5

Method you need to write:

    def output_paths(self):
        """
        This method must be filled in by you. You may add other methods and subclasses as you see fit,
        but they must remain within the Solution class.
        """
        paths, bandwidths, priorities = {}, {}, {}
        return (paths, bandwidths, priorities)