Added danielmq

Author: cooper-mj

.DS_Store

@@ -0,0 +1,130 @@
+'''
+    NeedlemanWunsch.py
+    This file implements the Needleman-Wunsch sequence alignment algorithm. The code
+    is not mine, the credit goes completely to:
+        https://wilkelab.org/classes/SDS348/2018_spring/labs/lab13-solution.html
+'''
+
+# Use these values to calculate scores
+gap_penalty = -1
+match_award = 1
+mismatch_penalty = -2
+
+# A function for making a matrix of zeroes
+
+
+def zeros(rows, cols):
+    # Define an empty list
+    retval = []
+    # Set up the rows of the matrix
+    for x in range(rows):
+        # For each row, add an empty list
+        retval.append([])
+        # Set up the columns in each row
+        for y in range(cols):
+            # Add a zero to each column in each row
+            retval[-1].append(0)
+    # Return the matrix of zeros
+    return retval
+
+# A function for determining the score between any two bases in alignment
+
+
+def match_score(alpha, beta):
+    if alpha == beta:
+        return match_award
+    elif alpha == '-' or beta == '-':
+        return gap_penalty
+    else:
+        return mismatch_penalty
+
+# The function that actually fills out a matrix of scores
+
+
+def needleman_wunsch(seq1, seq2):
+
+    # Store length of two sequences
+    n = len(seq1)
+    m = len(seq2)
+
+    # Generate matrix of zeros to store scores
+    score = zeros(m + 1, n + 1)
+
+    # Calculate score table
+
+    # Fill out first column
+    for i in range(0, m + 1):
+        score[i][0] = gap_penalty * i
+
+    # Fill out first row
+    for j in range(0, n + 1):
+        score[0][j] = gap_penalty * j
+
+    # Fill out all other values in the score matrix
+    for i in range(1, m + 1):
+        for j in range(1, n + 1):
+            # Calculate the score by checking the top, left, and diagonal cells
+            match = score[i - 1][j - 1] + match_score(seq1[j - 1], seq2[i - 1])
+            delete = score[i - 1][j] + gap_penalty
+            insert = score[i][j - 1] + gap_penalty
+            # Record the maximum score from the three possible scores
+            # calculated above
+            score[i][j] = max(match, delete, insert)
+
+    # Traceback and compute the alignment
+
+    # Create variables to store alignment
+    align1 = ""
+    align2 = ""
+
+    # Start from the bottom right cell in matrix
+    i = m
+    j = n
+
+    similarity = 0
+
+    # We'll use i and j to keep track of where we are in the matrix, just like
+    # above
+    while i > 0 and j > 0:  # end touching the top or the left edge
+        score_current = score[i][j]
+        similarity += score_current
+        score_diagonal = score[i - 1][j - 1]
+        score_up = score[i][j - 1]
+        score_left = score[i - 1][j]
+
+        # Check to figure out which cell the current score was calculated from,
+        # then update i and j to correspond to that cell.
+        if score_current == score_diagonal + \
+                match_score(seq1[j - 1], seq2[i - 1]):
+            align1 += seq1[j - 1]
+            align2 += seq2[i - 1]
+            i -= 1
+            j -= 1
+        elif score_current == score_up + gap_penalty:
+            align1 += seq1[j - 1]
+            align2 += '-'
+            j -= 1
+        elif score_current == score_left + gap_penalty:
+            align1 += '-'
+            align2 += seq2[i - 1]
+            i -= 1
+
+    # Finish tracing up to the top left cell
+    while j > 0:
+        align1 += seq1[j - 1]
+        align2 += '-'
+        j -= 1
+    while i > 0:
+        align1 += '-'
+        align2 += seq2[i - 1]
+        i -= 1
+
+    # Since we traversed the score matrix from the bottom right, our two sequences will be reversed.
+    # These two lines reverse the order of the characters in each sequence.
+    align1 = align1[::-1]
+    align2 = align2[::-1]
+
+    min = mismatch_penalty * len(seq1)
+    rangeValues = match_award * len(seq1) - min
+
+    return(align1, align2, similarity)

danielmq/NeedlemanWunsch.py

@@ -0,0 +1,38 @@
+
+# OpenDNA
+@author:  Daniel Martin Marin Quiroz
+@version: Mar 12,  2020
+@class: CS41
+
+### Description
+
+Hi there! This project is an attempt to build an interface that lets a user interact with a database of human profiles, each of which is consisted on the name of the human, her/his age and a part of her/his DNA sequence.
+
+The user enters this information and the program compares his/her DNA against the current database of registered user profiles. After the algorithm computes the results, the user is shown the profiles of the people whose DNA is the most similar to his/hers. Also, by using the Needleman-Wunsch sequence alignment algorithm, the user is shown the best possible alignment of two DNA sequences.
+
+The results are ranked by the similarity of the DNA sequences of each profile with the DNA of the user, and the alignments are highlighted by the program, indicating matches, mismatches and gaps in each alignment. Finally, the user is able to save her/his information in the database so that future users are able to compare their DNA sequences with her/him.
+
+### How to run
+
+This project was designed to run both locally and also using the website template posted on Piazza. To run locally, simply type `python openDNA.py`. This will create a radomly generated user profile, compare his/her DNA against a randomly generated user database of (by default) 100 users and display the matchings, rankings and results.
+
+The program can be run with the following command-line arguments:  `python openDNA.py --randomDatabase` and `python openDNA.py --localDatabase`.
+Both options let the user enter his/her information (name, age and DNA sequence). The first compares his/her DNA with a randomly generated database and the latter compares it with an actual file in the `data/` folder named `userDatabase.json`, and it lets the user save his/her profile in the database if he/she wishes to do so.
+
+To run on the web, run `python app.py`. This will create a local server that can be accessed on a web browser. On this website, the user is able to enter his/her name, age and DNA sequence. The server will receive the request and confirm that the data entered is in the correct format. If it is the case, then the user will be able to see the rankings, best matchings and similarities of the profiles in the database at `data/userDatabase.json`, and her/his information will be added (or updated) to such database.
+
+### Code design
+
+Basically all the relevant code is on the `openDNA.py` file. My approach was to use Python's classes to create a `Person` class that holds the user's information and a `DNAComparison` class that is instantiated with two `Person` objects and holds data such as the best alignment of the two person's sequences, percent similarity and their relative Needleman-Wunsch similarity scores.
+
+I also created functions that would be in charge of loading/saving into the user database, create random DNA sequences, create random user-profiles, verify the validity of the information entered by the user, process the online requests, run the comparison of one profile against the whole database of user, format the results and interact with the user when run locally.
+
+### Credits
+I have used the implementation of the Needleman-Wunsch algorithm coded by the Wilke Computational Evolutionary Biology Lab, from the class of Spring 2018 available at [this](https://wilkelab.org/classes/SDS348/2018_spring/labs/lab13-solution.html) link.
+
+### Publishing
+Feel free to publish/use anything from this project!
+
+### Video
+You can find the walkthrough video here: https://drive.google.com/open?id=1ukpae3Zmj4ylQvm3LzWjqdfVz7DG1zLc
+

danielmq/README.md

@@ -0,0 +1,105 @@
+"""
+A lightweight Flask app that renders a form for a user to fill out and then
+processes the form data with a student-specified function.
+
+Authors
+-------
+TODO :)
+"""
+from flask import Flask, render_template, request
+from werkzeug.utils import secure_filename
+from utils import FormInputs
+import utils
+import process
+import os
+
+app = Flask(__name__)
+app.config['UPLOAD_FOLDER'] = 'uploads/'
+
+"""
+Use these global variables to configure the application parameters.
+"""
+APP_TITLE = 'OpenDNA'            # Appears at the top of the page.
+AUTHORS = 'Daniel Marin'              # Appears underneath the title
+FORM_DESCRIPTION = """Welcome to OpenDNA. This program lets you compare your DNA with other users in the database. We'll tell you whose DNA is more similar to yours and add you to our database!!""" # Appears before the form, to explain the form
+
+"""
+Use this variable to design the form that you'd like to present the user with.
+This dictionary should be of the form:
+    {
+        'field_name': ('Field Label', field_type)
+    }
+
+The field type is one of the following options:
+    FormInputs.STRING   -- A string input area.
+    FormInputs.TEXTAREA -- A textarea for large string inputs.
+    FormInputs.NUMERIC  -- A numeric input area.
+    FormInputs.FILE     -- A file upload input.
+or an iterable of valid inputs that will be provided to the user to choose
+between.
+
+For example, if you were predicting housing prices, this form might look like:
+    {
+        'age': ('Age', FormInputs.NUMERIC),
+        'living_area': ('Size (in square feet)', FormInputs.NUMERIC)
+    }
+
+If you'd like to provide a set of valid inputs, you can do that as you'd expect:
+    {
+        'location': ('Location', ('Palo Alto', 'Stanford', 'Redwood City'))
+    }
+"""
+FORM_SPECIFICATION = {
+    'name': ('Enter your name: ', FormInputs.STRING),
+    'age':  ('Age', FormInputs.NUMERIC),
+    'dna':  ('DNA', FormInputs.STRING),
+    'save': ('Save into database?', ('Yes', 'No'))
+}
+
+
+"""
+--------------------------------------------------------------------------------
+       You don't need to modify anything below this line, although you're        
+                    welcome (and encouraged) to take a look!                    
+--------------------------------------------------------------------------------
+"""
+@app.context_processor
+def inject_globals():
+    return {
+        'title': APP_TITLE,
+        'authors': AUTHORS
+    }
+
+@app.route('/', methods=['GET', 'POST'])
+def main():
+    form_defaults = dict(request.form)
+
+    # Handle file save
+    FILE_FIELDS = [k for k, v in FORM_SPECIFICATION.items() \
+                     if v[1] is FormInputs.FILE]
+    for field_name in FILE_FIELDS:
+        if field_name in request.files \
+           and (file := request.files[field_name]).filename:
+            # Save the file
+            filename = secure_filename(file.filename)
+            save_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+            file.save(save_path)
+
+            # Update the form values
+            form_defaults.update({field_name: save_path})
+
+    msg = None
+    if any(form_defaults.values()):
+        msg = process.process(**form_defaults)
+        
+    print(msg)
+
+    form = utils.Form(FORM_SPECIFICATION, defaults=form_defaults)
+
+    return render_template('index.html', 
+                           form=form,
+                           desc=FORM_DESCRIPTION,
+                           msg=msg)
+
+if __name__ == '__main__':
+    app.run()

danielmq/app.py

@@ -0,0 +1 @@
+ATGGTGCTCTCTGGGGAAGACAAAAGCAACATCAAGGCTGCCTGGGGGAAGATTGGTGGCCATGGTGCTGAATATGGAGCTGAAGCCCTGGAAAGGATGTTTGCTAGCTTCCCCACCACCAAGACCTACTTTCCTCACTTTGATGTAAGCCACGGCTCTCATTCTAAATGGTGCTGAGCAAAGTT