<jupyter_start><jupyter_text>Homework 5 Due Date:  Tuesday, October 3rd at 11:59 PM  Problem 1We discussed documentation and testing in lecture and also briefly touched on code coverage.  You must write tests for your code for your final project (and in life).  There is a nice way to automate the testing process called continuous integration (CI).This problem will walk you through the basics of CI and show you how to get up and running with some CI software.  Continuous IntegrationThe idea behind continuous integration is to automate away the testing of your code.We will be using it for our projects.The basic workflow goes something like this:1. You work on your part of the code in your own branch or fork2. On every commit you make and push to GitHub, your code is automatically tested on a fresh machine on Travis CI. This ensures that there are no specific dependencies on the structure of your machine that your code needs to run and also ensures that your changes are sane3. Now you submit a pull request to `master` in the main repo (the one you're hoping to contribute to). The repo manager creates a branch off `master`. 4. This branch is also set to run tests on Travis. If all tests pass, then the pull request is accepted and your code becomes part of master.We use GitHub to integrate our roots library with Travis CI and Coveralls. Note that this is not the only workflow people use. Google git..github..workflow and feel free to choose another one for your group.  Part 1:  Create a repoCreate a public GitHub repo called `cs207test` and clone it to your local machine.**Note:** No need to do this in Jupyter.  Part 2:  Create a roots libraryUse the example from lecture 7 to create a file called `roots.py`, which contains the `quad_roots` and `linear_roots` functions (along with their documentation).Also create a file called `test_roots.py`, which contains the tests from lecture.All of these files should be in your newly created `cs207test` repo.  **Don't push yet!!!**  Part 3:  Create an account on Travis CI and Start Building Part A:Create an account on Travis CI and set your `cs207test` repo up for continuous integration once this repo can be seen on Travis. Part B:Create an instruction to Travis to make sure that1. python is installed2. its python 3.53. pytest is installedThe file should be called `.travis.yml` and should have the contents:```ymllanguage: pythonpython:    - "3.5"before_install:    - pip install pytest pytest-covscript:    - pytest```You should also create a configuration file called `setup.cfg`:```cfg[tool:pytest]addopts = --doctest-modules --cov-report term-missing --cov roots``` Part C:Push the new changes to your `cs207test` repo.At this point you should be able to see your build on Travis and if and how your tests pass.  Part 4:  Coveralls IntegrationIn class, we also discussed code coverage.  Just like Travis CI runs tests automatically for you, Coveralls automatically checks your code coverage.  One minor drawback of Coveralls is that it can only work with public GitHub accounts.  However, this isn't too big of a problem since your projects will be public. Part A:Create an account on [`Coveralls`](https://coveralls.zendesk.com/hc/en-us), connect your GitHub, and turn Coveralls integration on. Part B:Update your the `.travis.yml` file as follows:```ymllanguage: pythonpython:    - "3.5"before_install:    - pip install pytest pytest-cov    - pip install coverallsscript:    - py.testafter_success:    - coveralls```Be sure to push the latest changes to your new repo.  Part 5:  Update README.md in repoYou can have your GitHub repo reflect the build status on Travis CI and the code coverage status from Coveralls.  To do this, you should modify the `README.md` file in your repo to include some badges.  Put the following at the top of your `README.md` file:```[![Build Status](https://travis-ci.org/dsondak/cs207testing.svg?branch=master)](https://travis-ci.org/dsondak/cs207testing.svg?branch=master)[![Coverage Status](https://coveralls.io/repos/github/dsondak/cs207testing/badge.svg?branch=master)](https://coveralls.io/github/dsondak/cs207testing?branch=master)```Of course, you need to make sure that the links are to your repo and not mine.  You can find embed code on the Coveralls and Travis CI sites. --- Problem 2Write a Python module for reaction rate coefficients.  Your module should include functions for constant reaction rate coefficients, Arrhenius reaction rate coefficients, and modified Arrhenius reaction rate coefficients.  Here are their mathematical forms:\begin{align}  &k_{\textrm{const}}   = k \tag{constant} \\  &k_{\textrm{arr}}     = A \exp\left(-\frac{E}{RT}\right) \tag{Arrhenius} \\  &k_{\textrm{mod arr}} = A T^{b} \exp\left(-\frac{E}{RT}\right) \tag{Modified Arrhenius}\end{align}Test your functions with the following paramters:  $A = 10^7$, $b=0.5$, $E=10^3$.  Use $T=10^2$.A few additional comments / suggestions:* The Arrhenius prefactor $A$ is strictly positive* The modified Arrhenius parameter $b$ must be real * $R = 8.314$ is the ideal gas constant.  It should never be changed (except to convert units)* The temperature $T$ must be positive (assuming a Kelvin scale)* You may assume that units are consistent* Document each function!* You might want to check for overflows and underflows**Recall:** A Python module is a `.py` file which is not part of the main execution script.  The module contains several functions which may be related to each other (like in this problem).  Your module will be importable via the execution script.  For example, suppose you have called your module `reaction_coeffs.py` and your execution script `kinetics.py`.  Inside of `kinetics.py` you will write something like:```pythonimport reaction_coeffs Some code to do some things : : : Time to use a reaction rate coefficient:reaction_coeffs.const()  Need appropriate arguments, etc Continue on... : : :```Be sure to include your module in the same directory as your execution script.<jupyter_code>%%file reaction_coeffs.py
import numpy as np
R=8.314
def const(k):
    return k

def arr(A, E, T):
        #Check that A,T,E  are numbers
        if ((type(A) != int and type(A) != float) or 
            (type(T) != int and type(T) != float) or
            (type(E) != int and type(E) != float)):
            raise TypeError("All arguments must be numbers!")
            
        elif (T<0 or A<0): # A & T must be positive
            raise ValueError("Temperature and Arrhenius prefactor must be positive!")
            
        else:
            #Calculate karr
            karr = A*(np.exp(-E/(R*T)))
            return karr
        
def mod_arr(A,E,b,T):
            #Check that A,T,E  are numbers
        if ((type(A) != int and type(A) != float) or 
            (type(b) != int and type(b) != float) or
            (type(E) != int and type(E) != float) or
            (type(T) != int and type(T) != float)):
            raise TypeError("All arguments must be numbers!")
            
        elif (T<0 or A<0): # A & T must be positive
            raise ValueError("Temperature and Arrhenius prefactor must be positive!")
            
        else:
            #Calculate karr
            karr = A*(T**b)*(np.exp(-E/(R*T)))
            return karr
%%file kinetics.py
import reaction_coeffs

# Time to use a reaction rate coefficient:
reaction_coeffs.const(107)
reaction_coeffs.arr(107,103,102)
reaction_coeffs.mod_arr(107,103,0.5,102)
%%file kinetics_tests.py
import reaction_coeffs
#Test k_const
def test_const():
    assert reaction_coeffs.const(107) == 107
    
#Test k_arr
def test_arr():
    assert reaction_coeffs.arr(107,103,102) == 94.762198593430469

def test_arr_values1():
    try:
        reaction_coeffs.arr(-1,103,102)
    except ValueError as err:
        assert(type(err) == ValueError)
        
def test_arr_values2():
    try:
        reaction_coeffs.arr(107,103,-2)
    except ValueError as err:
        assert(type(err) == ValueError)

def test_arr_types1():
    try:
        reaction_coeffs.arr('107',103,102)
    except TypeError as err:
        assert(type(err) == TypeError)
        
def test_arr_types2():
    try:
        reaction_coeffs.arr(107,'103',102)
    except TypeError as err:
        assert(type(err) == TypeError)

def test_arr_types3():
    try:
        reaction_coeffs.arr(107,103,[102])
    except TypeError as err:
        assert(type(err) == TypeError)  
        
#Test mod_arr
def test_mod_arr():
    assert reaction_coeffs.mod_arr(107,103,0.5,102) == 957.05129266439894
    
def test_mod_arr_values1():
    try:
        reaction_coeffs.mod_arr(-1,103,0.5,102)
    except ValueError as err:
        assert(type(err) == ValueError)

def test_mod_arr_values2():
    try:
        reaction_coeffs.mod_arr(107,103,0.5,-2)
    except ValueError as err:
        assert(type(err) == ValueError)
        
def test_mod_arr_types1():
    try:
        reaction_coeffs.mod_arr('107',103,0.5,102)
    except TypeError as err:
        assert(type(err) == TypeError)
        
def test_mod_arr_types2():
    try:
        reaction_coeffs.mod_arr(107,'103',0.5,102)
    except TypeError as err:
        assert(type(err) == TypeError)

def test_mod_arr_types3():
    try:
        reaction_coeffs.mod_arr(107,103,[0.5],102)
    except TypeError as err:
        assert(type(err) == TypeError)

def test_mod_arr_types4():
    try:
        reaction_coeffs.mod_arr(107,103,0.5,False)
    except TypeError as err:
        assert(type(err) == TypeError)
    

test_const()
test_mod_arr()
test_arr()
test_arr_values1()
test_arr_values2()
test_arr_types1()
test_arr_types2()
test_arr_types3()
test_mod_arr_values1()
test_mod_arr_values2()
test_mod_arr_types1()
test_mod_arr_types2()
test_mod_arr_types3()
test_mod_arr_types4()<jupyter_output>Overwriting kinetics_tests.py<jupyter_text>--- Problem 3Write a function that returns the **progress rate** for a reaction of the following form:\begin{align}  \nu_{A} A + \nu_{B} B \longrightarrow \nu_{C} C.\end{align}Order your concentration vector so that \begin{align}  \mathbf{x} =   \begin{bmatrix}    \left[A\right] \\    \left[B\right] \\    \left[C\right]  \end{bmatrix}\end{align}Test your function with\begin{align}  \nu_{i}^{\prime} =   \begin{bmatrix}    2.0 \\    1.0 \\    0.0  \end{bmatrix}  \qquad   \mathbf{x} =   \begin{bmatrix}    1.0 \\     2.0 \\     3.0  \end{bmatrix}  \qquad   k = 10.\end{align}You must document your function and write some tests in addition to the one suggested.  You choose the additional tests, but you must have at least one doctest in addition to a suite of unit tests.<jupyter_code>def progress_rate(v1,x,k):
    """Returns the progress rate of a reaction of the form: v1A + v2B -> v3C.
    
    INPUTS
    =======
    v1: list, 
       stoichiometric coefficient of reactants in a reaction(s)
    x: float,
       Concentration of A, B, C
    k: float, 
       reaction rate coefficient
    
    RETURNS
    ========
    progress rate: a list of the progress rate of each reaction
    
    EXAMPLES
    =========
    >>> progress_rate([2.0,1.0,0.0],[1.0,2.0,3.0],10)
    [20.0]
    """
    #Check that x and v1 are lists
    if (type(v1) != list or type(x) != list):
        raise TypeError("v' & x must be passed in as a list")
    #Check that x,and k are numbers/list of numbers
    if (any(type(i) != int and type(i) != float for i in x)):
        raise TypeError("All elements in x must be numbers!")
    elif (type(k) != int and type(k) != float and type(k) != list):
        raise TypeError("k must be a numbers!")
    else:
        progress_rates = []
        #check for multiple reactions
        if(type(v1[0]) == list):
            for v in v1:
                for reactant in v:
                    if(type(reactant) != int and type(reactant) != float):
                        raise TypeError("All elements in v1 must be numbers!")
            #Calculate the progress rate of each reaction
            reactions = len(v1[0])
            for j in range(reactions):
                if (type(k)== list):
                    progress_rate = k[j]
                else:
                    progress_rate = k
                for i in range(len(v1)):
                    progress_rate = progress_rate*(x[i]**v1[i][j])
                progress_rates.append(progress_rate) 
        else:
            #Check types of V1
            if (any(type(i) != int and type(i) != float  for i in v1)):
                raise TypeError("All elements in v1 must be numbers!")
            #Calculate the progress rate of each reaction
            progress_rate = k
            for i in range(len(v1)):
                progress_rate = progress_rate*(x[i]**v1[i])
            progress_rates.append(progress_rate)
        return progress_rates
progress_rate([2.0,1.0,0.0],[1.0,2.0,3.0],10)<jupyter_output><empty_output><jupyter_text>--- Problem 4Write a function that returns the **progress rate** for a system of reactions of the following form:\begin{align}  \nu_{11}^{\prime} A + \nu_{21}^{\prime} B \longrightarrow \nu_{31}^{\prime\prime} C \\  \nu_{12}^{\prime} A + \nu_{32}^{\prime} C \longrightarrow \nu_{22}^{\prime\prime} B + \nu_{32}^{\prime\prime} C\end{align}Note that $\nu_{ij}^{\prime}$ represents the stoichiometric coefficient of reactant $i$ in reaction $j$ and $\nu_{ij}^{\prime\prime}$ represents the stoichiometric coefficient of product $i$ in reaction $j$.  Therefore, in this convention, I have ordered my vector of concentrations as \begin{align}  \mathbf{x} =   \begin{bmatrix}    \left[A\right] \\    \left[B\right] \\    \left[C\right]  \end{bmatrix}.\end{align}Test your function with \begin{align}  \nu_{ij}^{\prime} =   \begin{bmatrix}    1.0 & 2.0 \\    2.0 & 0.0 \\    0.0 & 2.0  \end{bmatrix}  \qquad  \nu_{ij}^{\prime\prime} =   \begin{bmatrix}    0.0 & 0.0 \\    0.0 & 1.0 \\    2.0 & 1.0  \end{bmatrix}  \qquad  \mathbf{x} =   \begin{bmatrix}    1.0 \\    2.0 \\    1.0  \end{bmatrix}  \qquad  k_{j} = 10, \quad j=1,2.\end{align}You must document your function and write some tests in addition to the one suggested.  You choose the additional tests, but you must have at least one doctest in addition to a suite of unit tests.<jupyter_code>progress_rate([[1.0,2.0],[2.0,0.0],[0.0,2.0]],[1.0,2.0,1.0],10)<jupyter_output><empty_output><jupyter_text>--- Problem 5Write a function that returns the **reaction rate** of a system of irreversible reactions of the form:\begin{align}  \nu_{11}^{\prime} A + \nu_{21}^{\prime} B &\longrightarrow \nu_{31}^{\prime\prime} C \\  \nu_{32}^{\prime} C &\longrightarrow \nu_{12}^{\prime\prime} A + \nu_{22}^{\prime\prime} B\end{align}Once again $\nu_{ij}^{\prime}$ represents the stoichiometric coefficient of reactant $i$ in reaction $j$ and $\nu_{ij}^{\prime\prime}$ represents the stoichiometric coefficient of product $i$ in reaction $j$.  In this convention, I have ordered my vector of concentrations as  \begin{align}  \mathbf{x} =   \begin{bmatrix}    \left[A\right] \\    \left[B\right] \\    \left[C\right]  \end{bmatrix}\end{align}Test your function with \begin{align}  \nu_{ij}^{\prime} =   \begin{bmatrix}    1.0 & 0.0 \\    2.0 & 0.0 \\    0.0 & 2.0  \end{bmatrix}  \qquad  \nu_{ij}^{\prime\prime} =   \begin{bmatrix}    0.0 & 1.0 \\    0.0 & 2.0 \\    1.0 & 0.0  \end{bmatrix}  \qquad  \mathbf{x} =   \begin{bmatrix}    1.0 \\    2.0 \\    1.0  \end{bmatrix}  \qquad  k_{j} = 10, \quad j = 1,2.\end{align}You must document your function and write some tests in addition to the one suggested.  You choose the additional tests, but you must have at least one doctest in addition to a suite of unit tests.<jupyter_code>def reaction_rate(v1,v2,x,k):
    """Returns the reaction rate of a reaction of the form: v1A + v2B -> v3C.
    
    INPUTS
    =======
    v1: 2D list, 
       stoichiometric coefficient of reactants in a reaction(s)
    v2: 2D list, optional, default value is 2
       stoichiometric coefficient of products in a reaction(s)
    x: float,
       Concentration of A, B, C
    k: float, 
       reaction rate coefficient
    
    RETURNS
    ========
    reaction rate: a list of the reaction rate of each reactant
    
    EXAMPLES
    =========
    >>> reaction_rate([[1.0,0.0],[2.0,0.0],[0.0,2.0]],[[0.0,1.0],[0.0,2.0],[1.0,0.0]],[1.0,2.0,1.0],10)
    [-30.0, -60.0, 20.0]
    """
    w = progress_rate(v1,x,k)
    #Check that x,v2 and v1 are lists
    if (type(v2) != list or type(x) != list or type(v1)!= list):
        raise TypeError("v' & x must be passed in as a list")
    if (any(type(i) != int and type(i) != float for i in x)):
        raise TypeError("All arguments must be numbers!")
    elif (type(k) != int and type(k) != float and type(k) !=list):
        raise TypeError("All arguments must be numbers!")
    else:
        reaction_rates = []
        for i in (range(len(v2))):
            reaction_rate = 0
            for j in (range(len(v2[0]))):
                reaction_rate = reaction_rate + (v2[i][j]-v1[i][j])*w[j]
            reaction_rates.append(reaction_rate)
        return reaction_rates
reaction_rate([[1.0,0.0],[2.0,0.0],[0.0,2.0]],[[0.0,1.0],[0.0,2.0],[1.0,0.0]],[1.0,2.0,1.0],10)<jupyter_output><empty_output><jupyter_text>--- Problem 6Put parts 3, 4, and 5 in a module called `chemkin`.Next, pretend you're a client who needs to compute the reaction rates at three different temperatures ($T = \left\{750, 1500, 2500\right\}$) of the following system of irreversible reactions:\begin{align}  2H_{2} + O_{2} \longrightarrow 2OH + H_{2} \\  OH + HO_{2} \longrightarrow H_{2}O + O_{2} \\  H_{2}O + O_{2} \longrightarrow HO_{2} + OH\end{align}The client also happens to know that reaction 1 is a modified Arrhenius reaction with $A_{1} = 10^{8}$, $b_{1} = 0.5$, $E_{1} = 5\times 10^{4}$, reaction 2 has a constant reaction rate parameter $k = 10^{4}$, and reaction 3 is an Arrhenius reaction with $A_{3} = 10^{7}$ and $E_{3} = 10^{4}$.You should write a script that imports your `chemkin` module and returns the reaction rates of the species at each temperature of interest given the following species concentrations:\begin{align}  \mathbf{x} =   \begin{bmatrix}    H_{2}  \\    O_{2}  \\    OH     \\    HO_{2} \\    H_{2}O  \end{bmatrix} =   \begin{bmatrix}    2.0 \\    1.0 \\    0.5 \\    1.0 \\    1.0  \end{bmatrix}\end{align}You may assume that these are elementary reactions.<jupyter_code>%%file chemkin.py

def progress_rate(v1,x,k):
    """Returns the progress rate of a reaction of the form: v1A + v2B -> v3C.
    
    INPUTS
    =======
    v1: list, 
       stoichiometric coefficient of reactants in a reaction(s)
    x: float,
       Concentration of A, B, C
    k: float, 
       reaction rate coefficient
    
    RETURNS
    ========
    progress rate: a list of the progress rate of each reaction
    
    EXAMPLES
    =========
    >>> progress_rate([2.0,1.0,0.0],[1.0,2.0,3.0],10)
    [20.0]
    """
    #Check that x and v1 are lists
    if (type(v1) != list or type(x) != list):
        raise TypeError("v' & x must be passed in as a list")
    #Check that x,and k are numbers/list of numbers
    if (any(type(i) != int and type(i) != float for i in x)):
        raise TypeError("All elements in x must be numbers!")
    elif (type(k) != int and type(k) != float and type(k) != list):
        raise TypeError("k must be a numbers or list!")
    else:
        progress_rates = []
        #check for multiple reactions
        if(type(v1[0]) == list):
            for v in v1:
                for reactant in v:
                    if(type(reactant) != int and type(reactant) != float):
                        raise TypeError("All elements in v1 must be numbers!")
            #Calculate the progress rate of each reaction
            reactions = len(v1[0])
            for j in range(reactions):
                if (type(k) == list):
                    progress_rate = k[j]
                else:
                    progress_rate = k
                for i in range(len(v1)):
                    progress_rate = progress_rate*(x[i]**v1[i][j])
                progress_rates.append(progress_rate) 
        else:
            #Check types of V1
            if (any(type(i) != int and type(i) != float  for i in v1)):
                raise TypeError("All elements in v1 must be numbers!")
            #Calculate the progress rate of each reaction
            progress_rate = k
            for i in range(len(v1)):
                progress_rate = progress_rate*(x[i]**v1[i])
            progress_rates.append(progress_rate)
        return progress_rates
    
def reaction_rate(v1,v2,x,k):
    """Returns the reaction rate of a reaction of the form: v1A + v2B -> v3C.
    
    INPUTS
    =======
    v1: 2D list, 
       stoichiometric coefficient of reactants in a reaction(s)
    v2: 2D list, optional, default value is 2
       stoichiometric coefficient of products in a reaction(s)
    x: float,
       Concentration of A, B, C
    k: float, 
       reaction rate coefficient
    
    RETURNS
    ========
    reaction rate: a list of the reaction rate of each reactant
    
    EXAMPLES
    =========
    >>> reaction_rate([[1.0,0.0],[2.0,0.0],[0.0,2.0]],[[0.0,1.0],[0.0,2.0],[1.0,0.0]],[1.0,2.0,1.0],10)
    [-30.0, -60.0, 20.0]
    """
    w = progress_rate(v1,x,k)
    #Check that x,v2 and v1 are lists
    if (type(v2) != list or type(x) != list or type(v1)!= list):
        raise TypeError("v' & x must be passed in as a list")
    if (any(type(i) != int and type(i) != float for i in x)):
        raise TypeError("All arguments must be numbers!")
    elif (type(k) != int and type(k) != float and type(k) !=list):
        raise TypeError("All arguments must be numbers!")
    else:
        reaction_rates = []
        for i in (range(len(v2))):
            reaction_rate = 0
            for j in (range(len(v2[0]))):
                reaction_rate = reaction_rate + (v2[i][j]-v1[i][j])*w[j]
            reaction_rates.append(reaction_rate)
        return reaction_rates
import chemkin
import reaction_coeffs

v1 = [[2.0,0.0,0.0],[1.0,0.0,1.0],[0.0,1.0,0.0],[0.0,1.0,0.0],[0.0,0.0,1.0]]
v2 = [[1.0,0.0,0.0],[0.0,1.0,0.0],[2.0,0.0,1.0],[0.0,0.0,1.0],[0.0,1.0,0.0]]
x = [2.0,1.0,0.5,1.0,1.0]

k1T1 = reaction_coeffs.mod_arr((10**7),(5*(10**4)),0.5,750)
k2T1 = reaction_coeffs.const(10**4)
k3T1 = reaction_coeffs.arr((10**8),(10**4),750)
k1 = [k1T1,k2T1,k3T1]

k2T2 = reaction_coeffs.const(10**4)
k3T2 = reaction_coeffs.arr((10**7),(10**4),1500)
k1T2 = reaction_coeffs.mod_arr((10**8),(5*(10**4)),0.5,1500)
k2 = [k1T2,k2T2,k3T2]

k2T3 = reaction_coeffs.const(10**4)
k3T3 = reaction_coeffs.arr((10**7),(10**4),2500)
k1T3 = reaction_coeffs.mod_arr((10**8),(5*(10**4)),0.5,2500)
k3 = [k1T3,k2T3,k3T3]

print([chemkin.reaction_rate(v1,v2,x,k1),chemkin.reaction_rate(v1,v2,x,k2), chemkin.reaction_rate(v1,v2,x,k3)])
%%file test.py
import chemkin
def test_progress_rate():
    assert chemkin.progress_rate([3.0,1.0,1.0],[1.0,2.0,3.0],10) == [60.0]
test_progress_rate()

def test_reaction_rate():
    assert chemkin.reaction_rate([[3.0,1.0,1.0]],[[1.0,2.0,1.0]],[1.0,2.0,3.0],10) == [-10.0]
test_reaction_rate()
!pytest --doctest-modules --cov-report term-missing --cov<jupyter_output>[1m============================= test session starts ==============================[0m
platform darwin -- Python 3.6.1, pytest-3.2.1, py-1.4.33, pluggy-0.4.0
rootdir: /Users/riddhishah/Documents/cs207/cs207_riddhi_shah/homeworks/HW5, inifile:
plugins: cov-2.3.1
collected 0 items                                                               [0m[1m[1m


---------- coverage: platform darwin, python 3.6.1-final-0 -----------
Name                 Stmts   Miss  Cover   Missing
--------------------------------------------------
chemkin.py              43      9    79%   5, 8, 10, 18, 23, 32, 44, 46, 48
kinetics.py              4      0   100%
kinetics_tests.py       76      0   100%
reaction_coeffs.py      18      0   100%
test.py                  7      0   100%
--------------------------------------------------
TOTAL                  148      9    94%

[33m[1m========================= no tests ran in 2.02 seconds =========================[0m<jupyter_text>--- Problem 7Get together with your project team, form a GitHub organization (with a descriptive team name), and give the teaching staff access.  You can have has many repositories as you like within your organization.  However, we will grade the repository called **`cs207-FinalProject`**.Within the `cs207-FinalProject` repo, you must set up Travis CI and Coveralls.  Make sure your `README.md` file includes badges indicating how many tests are passing and the coverage of your code.<jupyter_code>'''Done by Hongxiang in our group!'''<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.13708010859435146, 'fraction_numerical': 0.04262733498115807, 'mean_word_length': 2.880503144654088, 'pattern_counts': {'":': 0, '<': 27, '<?xml version=': 0, '>': 39, 'https://': 5, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 4, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '6', 'dir': 'jupyter-structured-clean-dedup', 'id': '306327', 'license': 'MIT', 'n_tokens_mistral': 8502, 'n_tokens_neox': 7924, 'n_words': 2590, 'path': 'homeworks/HW5/HW5-Final.ipynb', 'repo_name': 'HeyItsRiddhi/cs207_riddhi_shah', 'size': '24679'}