## ZapFinder

0 likes • Jan 23, 2021
Python

## More Python Posts

```"""Assignment 6
The goal is to make a graph ofwho bit who and who was bitten.There should be 10 nodes and 15 edges.3 arrows of biting each other and3 arrows of someone biting themselves.Networkx can not do self bitingarrows, but it is in the code."""
from graphviz import Digraph as DDotGraphfrom graphviz import Graph as UDotGraphimport networkx as nxfrom networkx.algorithms.dag import transitive_closureimport graphviz as gvimport matplotlib.pyplot as pltimport numpy as npfrom numpy.linalg import matrix_power
"""class DGraph:    def __init__(self):        self.d = dict()
def clear(self):        self.d = dict()
def add_node(self,n):        if not self.d.get(n):            self.d[n] = set()
def edges(self):        for f in self.d:            for t in self.d[f]:                yield (f,t)
def number_of_nodes(self):        return len(self.d)
def __repr__(self):        return self.d.__repr__()
def show(self):        dot = gv.Digraph()        for e in self.edges():            #print(e)            f, t = e            dot.edge(str(f), str(t), label='')        #print(dot.source)        show(dot)
# displays graph with graphvizdef show(dot, show=True, file_name='graph.gv'):    dot.render(file_name, view=show)

def showGraph(g,label="",directed=True):    if directed:        dot = gv.Digraph()    else:        dot = gv.Graph()
for e in g.edges():        print(e)        f, t = e        dot.edge(str(f), str(t), label=label)    print(dot.source)    show(dot)

bit()
#bitten()
T = transitive_closure(D)
for e in D.edges(): print(e)for n in D.nodes(): print(n)
# M = nx.adjacency_matrix(D)# MT = nx.adjacency_matrix(T)M = nx.to_numpy_matrix(D)MT = nx.to_numpy_matrix(T)M2 = [email protected]
def mPower(M, k): #M is numpy matrix    assert k >= 1    P = M    for _ in range(k):       P = P @ M    return P
def tc(M):    #compute transitive closure    pass
D1 = nx.DiGraph(M)D2 = nx.DiGraph(M2)
print('Matrix for Original\n', M)N = nx.to_numpy_array(D,dtype=int)print('np_array for Original\n', N)print('\nMatrix for Transitive Closure\n', MT)N2 = nx.to_numpy_array(T,dtype=int)print('np_array for Transitive Closure\n', N2)
show(D) #can use D, T, and numpy matrix power operationshow(T)show(T)```
```import pandas as pd

print(x)```
```def to_roman_numeral(num):  lookup = [    (1000, 'M'),    (900, 'CM'),    (500, 'D'),    (400, 'CD'),    (100, 'C'),    (90, 'XC'),    (50, 'L'),    (40, 'XL'),    (10, 'X'),    (9, 'IX'),    (5, 'V'),    (4, 'IV'),    (1, 'I'),  ]  res = ''  for (n, roman) in lookup:    (d, num) = divmod(num, n)    res += roman * d  return res
to_roman_numeral(3) # 'III'to_roman_numeral(11) # 'XI'to_roman_numeral(1998) # 'MCMXCVIII'```
```# Python code to find the URL from an input string# Using the regular expressionimport re
def Find(string):
# findall() has been used	# with valid conditions for urls in string	regex = r"(?i)\b((?:https?://|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\[\]{};:'\".,<>?«»“”‘’]))"	url = re.findall(regex,string)		return [x[0] for x in url]	# Driver Codestring = 'My Profile: https://codecatch.net'print("Urls: ", Find(string))```
```import os, json, boto3, requestsfrom flask import Flask, request, jsonifyfrom flask_cors import CORS, cross_originfrom random import shuffle
dynamodb = boto3.resource("dynamodb", region_name="us-east-1")
app.url_map.strict_slashes = FalseSECRET_KEY = os.environ.get("SECRET_KEY")

@app.route("/teks")def teks_request():    teks_file = open("teks.json", "r")    data = json.load(teks_file)    return jsonify(data)

@app.route("/teks/find/113.41.<int:teks_id>.<string:section_id>")def teks_find_request(teks_id, section_id):    teks_file = open("teks.json", "r")    data = json.load(teks_file)    for item in data:        if item["id"] == teks_id:            for child in item["children"]:                if child["id"] == section_id:                    return {"tek": item, "content": child["content"]}    return jsonify(        [            f"Something went wrong. TEKS section id of {section_id} cannot be found within TEKS section {teks_id}."        ]    )
@app.route("/lessonplan/read/<id>")def read_lesson_plan(id):    lesson_table = dynamodb.Table("Lesson_Plans")    items = lesson_table.scan()['Items']    for lesson in items:        if (lesson["uuid"] == id):            return jsonify(lesson)    return {"error": "id does not exist", "section": id}
@app.route("/teks/<int:teks_id>")def teks_id_request(teks_id):    teks_file = open("teks.json", "r")    data = json.load(teks_file)    for item in data:        if item["id"] == teks_id:            return jsonify(item)    return jsonify([f"Something went wrong. TEKS id of {teks_id} cannot be found."])

@app.route("/assessment/write", methods=["GET", "POST"])def assessment_write():    assessment_json = request.json    assessment_data = dict(assessment_json)    assessment_table = dynamodb.Table("Assessments")    assessment_table.put_item(Item=assessment_data)
if assessment_data == get_assessment(assessment_data["id"]):        return "Success"    else:        return "Failure"

@app.route("/assessment/submit/<id>", methods=["POST"])def submit_assessment(id):    assessments_table = dynamodb.Table("Assessments")    assessment = assessments_table.get_item(Key={"id": id})
if not assessment.get("Item"):        return {"error": "id does not exist", "section": id}
responses = {        question["id"]: question["response"]        for question in request.json.get("questions")    }
for response in responses:        # print(        #     (        #         responses[response],        #         find_question(assessment.get("Item").get("questions"), response).get(        #             "correctAnswer"        #         ),        #     )        # )        if responses[response] == find_question(            assessment.get("Item").get("questions"), response        ).get("correctAnswer"):
users_table = dynamodb.Table("Students")
users_table.update_item(        Key={"uuid": request.json.get("student_id")},        UpdateExpression="SET completedAssessments = list_append(completedAssessments, :i)",        ExpressionAttributeValues={            ":i": [                {                    "id": id,                    "score": round(score * 100),                }            ]        },    )
message = None    if round(score * 100) > 70:        message = f"Congratulations! You passed your assessment with a {round(score * 100)}%."    else:        message = f"You failed your assessment with a {round(score * 100)}%."
sns = boto3.client("sns", region_name="us-east-1")    number = "+15125967383"    sns.publish(PhoneNumber=number, Message=message)
return {"score": score, "message": message}

def find_question(all, id):    #print("id to find: ", id)    for question in all:        if question["id"] == id:            #print(question)            return question

def get_assessment(id):    assessment_table = dynamodb.Table("Assessments")    results = assessment_table.get_item(Key={"id": id})
if results.get("Item") is None:        return {"error": "id does not exist", "section": id}    else:        quiz = results.get("Item")        return {            "title": quiz.get("title"),            "id": quiz.get("id"),            "questions": [                {                    "id": question.get("id"),                    "title": question.get("title"),                    "options": random_answers(                        question.get("incorrectAnswers")                        + [question.get("correctAnswer")]                    ),                }                for question in quiz.get("questions")            ],        }
def get_students(id):    students_table = dynamodb.Table('Students')    results = students_table.get_item(Key = {        "uuid": id    })
if(results.get("Item") is None):        return {'error': 'id does not exist', 'section': id}    else:        student = results.get("Item")        return student
def lesson_plans_read():    student_table = dynamodb.Table("Lesson_Plans")    items = student_table.scan()['Items']    return jsonify(items)
```import mysql.connector