Skip to main content

Rock paper scissors

0 likes • Nov 19, 2022
Python
Loading...
Download

More Python Posts

Copy file to destination

AustinLeath
0 likes • Nov 18, 2022
Python
# importing the modules
import os
import shutil
# getting the current working directory
src_dir = os.getcwd()
# printing current directory
print(src_dir)
# copying the files
shutil.copyfile('test.txt', 'test.txt.copy2') #copy src to dst
# printing the list of new files
print(os.listdir())

Goobla Academy Flask API

AustinLeath
0 likes • Nov 18, 2022
Python
import os, json, boto3, requests
from flask import Flask, request, jsonify
from flask_cors import CORS, cross_origin
from random import shuffle
app = Flask(__name__)
cors = CORS(app)
dynamodb = boto3.resource("dynamodb", region_name="us-east-1")
app.url_map.strict_slashes = False
SECRET_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("/students/read/<id>")
def students_read(id):
return jsonify(get_students(id))
@app.route("/students/read")
def all_students_read():
student_table = dynamodb.Table("Students")
items = student_table.scan()['Items']
return jsonify(items)
@app.route("/assessment/read/<id>")
def assessment_read(id):
return jsonify(get_assessment(id))
@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")
}
correct_answers = 0
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"):
correct_answers += 1
score = correct_answers / len(request.json.get("questions"))
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)
def random_answers(answers):
shuffle(answers)
return answers
@app.route("/recommendations/<uuid>")
def get_recommendation(uuid):
student_info_table = dynamodb.Table('Students')
lesson_plans_table = dynamodb.Table('Lesson_Plans')
student = get_students(uuid)
tek = student.get("struggleTeks")[0]
lesson_plans = lesson_plans_table.scan( Select='ALL_ATTRIBUTES', FilterExpression='tek = :s', ExpressionAttributeValues={ ":s": tek })
#print(lesson_plans)
return jsonify({"student": student, "lesson_plans": lesson_plans.get("Items")})
if __name__ == "__main__":
app.run(host="0.0.0.0", debug=True)

clamp number

CodeCatch
0 likes • Nov 19, 2022
Python
def clamp_number(num, a, b):
return max(min(num, max(a, b)), min(a, b))
clamp_number(2, 3, 5) # 3
clamp_number(1, -1, -5) # -1

Currency Converter

CodeCatch
0 likes • Nov 19, 2022
Python
""" Currency Converter
----------------------------------------
"""
import urllib.request
import json
def currency_converter(currency_from, currency_to, currency_input):
yql_base_url = "https://query.yahooapis.com/v1/public/yql"
yql_query = 'select%20*%20from%20yahoo.finance.xchange%20where%20pair' \
'%20in%20("'+currency_from+currency_to+'")'
yql_query_url = yql_base_url + "?q=" + yql_query + "&format=json&env=store%3A%2F%2Fdatatables.org%2Falltableswithkeys"
try:
yql_response = urllib.request.urlopen(yql_query_url)
try:
json_string = str(yql_response.read())
json_string = json_string[2:
json_string = json_string[:-1]
print(json_string)
yql_json = json.loads(json_string)
last_rate = yql_json['query']['results']['rate']['Rate']
currency_output = currency_input * float(last_rate)
return currency_output
except (ValueError, KeyError, TypeError):
print(yql_query_url)
return "JSON format error"
except IOError as e:
print(str(e))
currency_input = 1
#currency codes : http://en.wikipedia.org/wiki/ISO_4217
currency_from = "USD"
currency_to = "TRY"
rate = currency_converter(currency_from, currency_to, currency_input)
print(rate)

curry function

CodeCatch
0 likes • Nov 19, 2022
Python
from functools import partial
def curry(fn, *args):
return partial(fn, *args)
add = lambda x, y: x + y
add10 = curry(add, 10)
add10(20) # 30

bruteforce password cracker

AustinLeath
0 likes • Nov 18, 2022
Python
import itertools
import string
import time
def guess_password(real):
chars = string.ascii_lowercase + string.ascii_uppercase + string.digits + string.punctuation
attempts = 0
for password_length in range(1, 9):
for guess in itertools.product(chars, repeat=password_length):
startTime = time.time()
attempts += 1
guess = ''.join(guess)
if guess == real:
return 'password is {}. found in {} guesses.'.format(guess, attempts)
loopTime = (time.time() - startTime);
print(guess, attempts, loopTime)
print("\nIt will take A REALLY LONG TIME to crack a long password. Try this out with a 3 or 4 letter password and see how this program works.\n")
val = input("Enter a password you want to crack that is 9 characters or below: ")
print(guess_password(val.lower()))