├── week6
    ├── lines
    │   ├── test.py
    │   └── lines.py
    ├── shirt
    │   ├── after.jpg
    │   ├── before1.jpg
    │   ├── before2.jpg
    │   ├── before3.jpg
    │   ├── muppets.zip
    │   ├── shirt.png
    │   └── shirt.py
    ├── pizza
    │   ├── sicilian.csv
    │   ├── regular.csv
    │   └── pizza.py
    └── scourgify
    │   ├── scourgify.py
    │   ├── after.csv
    │   └── before.csv
├── week0
    ├── playback
    │   └── playback.py
    ├── einstein
    │   └── einstein.py
    ├── indoor
    │   └── indoor.py
    ├── faces
    │   └── faces.py
    └── tip
    │   └── tip.py
├── Final project
    ├── logout_icon.png
    ├── spotify_logo.png
    ├── requirements.txt
    ├── test_project.py
    ├── README.md
    └── project.py
├── week8
    ├── shirtificate
    │   ├── shirtificate.pdf
    │   ├── shirtificate.png
    │   └── shirtificate.py
    ├── seasons
    │   ├── test_seasons.py
    │   └── seasons.py
    └── jar
    │   ├── jar.py
    │   └── test_jar.py
├── week4
    ├── emojize
    │   └── emojize.py
    ├── game
    │   └── game.py
    ├── bitcoin
    │   └── bitcoin.py
    ├── figlet
    │   └── figlet.py
    ├── adieu
    │   └── adieu.py
    └── professor
    │   └── professor.py
├── week7
    ├── um
    │   ├── test_um.py
    │   └── um.py
    ├── response
    │   └── response.py
    ├── numb3rs
    │   ├── test_numb3rs.py
    │   └── numb3rs.py
    ├── watch
    │   └── watch.py
    └── working
    │   ├── test_working.py
    │   └── working.py
├── week2
    ├── camel
    │   └── camel.py
    ├── twttr
    │   └── twttr.py
    ├── coke
    │   └── coke.py
    ├── nutrition
    │   └── nutrition.py
    └── plates
    │   └── plates.py
├── week1
    ├── bank
    │   └── bank.py
    ├── deep
    │   └── deep.py
    ├── interpreter
    │   └── interpreter.py
    ├── extensions
    │   └── extensions.py
    └── meal
    │   └── meal.py
├── week5
    ├── test_twttr
    │   ├── test_twttr.py
    │   └── twttr.py
    ├── test_bank
    │   ├── bank.py
    │   └── test_bank.py
    ├── test_plates
    │   ├── test_plates.py
    │   └── plates.py
    └── test_fuel
    │   ├── test_fuel.py
    │   └── fuel.py
├── week3
    ├── grocery
    │   └── grocery.py
    ├── fuel
    │   └── fuel.py
    ├── taqueria
    │   └── taqueria.py
    └── outdated
    │   └── outdated.py
├── LICENSE
└── README.md


/week6/lines/test.py:
--------------------------------------------------------------------------------
1 | 
2 | 
3 | 
4 | 
5 | 
6 |                 
7 | 
8 | print()


--------------------------------------------------------------------------------
/week0/playback/playback.py:
--------------------------------------------------------------------------------
1 | print(input("Enter some text \n").replace(" ","..."))


--------------------------------------------------------------------------------
/week6/shirt/after.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/aryanranderiya/cs50-python/HEAD/week6/shirt/after.jpg


--------------------------------------------------------------------------------
/week6/shirt/before1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/aryanranderiya/cs50-python/HEAD/week6/shirt/before1.jpg


--------------------------------------------------------------------------------
/week6/shirt/before2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/aryanranderiya/cs50-python/HEAD/week6/shirt/before2.jpg


--------------------------------------------------------------------------------
/week6/shirt/before3.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/aryanranderiya/cs50-python/HEAD/week6/shirt/before3.jpg


--------------------------------------------------------------------------------
/week6/shirt/muppets.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/aryanranderiya/cs50-python/HEAD/week6/shirt/muppets.zip


--------------------------------------------------------------------------------
/week6/shirt/shirt.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/aryanranderiya/cs50-python/HEAD/week6/shirt/shirt.png


--------------------------------------------------------------------------------
/week0/einstein/einstein.py:
--------------------------------------------------------------------------------
1 | m = int(input("Enter mass: "))
2 | c = 300000000
3 | print ("E is", m * pow(c, 2))
4 | 


--------------------------------------------------------------------------------
/Final project/logout_icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/aryanranderiya/cs50-python/HEAD/Final project/logout_icon.png


--------------------------------------------------------------------------------
/Final project/spotify_logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/aryanranderiya/cs50-python/HEAD/Final project/spotify_logo.png


--------------------------------------------------------------------------------
/Final project/requirements.txt:
--------------------------------------------------------------------------------
1 | cachetools==4.2.2
2 | Pillow==8.3.2
3 | requests==2.26.0
4 | spotipy==2.18.0
5 | tk==0.1.0
6 | 


--------------------------------------------------------------------------------
/week8/shirtificate/shirtificate.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/aryanranderiya/cs50-python/HEAD/week8/shirtificate/shirtificate.pdf


--------------------------------------------------------------------------------
/week8/shirtificate/shirtificate.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/aryanranderiya/cs50-python/HEAD/week8/shirtificate/shirtificate.png


--------------------------------------------------------------------------------
/week4/emojize/emojize.py:
--------------------------------------------------------------------------------
1 | import emoji
2 | 
3 | inputstring = input("Input: ")
4 | print("Output: ", emoji.emojize(inputstring, language='alias'))
5 | 
6 | 


--------------------------------------------------------------------------------
/week7/um/test_um.py:
--------------------------------------------------------------------------------
1 | from um import count
2 | 
3 | def test() :
4 |     assert count("yummy") == 0
5 |     assert count("hi um hi") == 1
6 |     assert count("UM.... HI") == 1


--------------------------------------------------------------------------------
/week7/response/response.py:
--------------------------------------------------------------------------------
1 | import validators
2 | 
3 | if validators.email(input("What's your email address?")) :
4 |     print("Valid")
5 | else :
6 |     print("Invalid")
7 | 


--------------------------------------------------------------------------------
/week6/pizza/sicilian.csv:
--------------------------------------------------------------------------------
1 | Sicilian Pizza,Small,Large
2 | Cheese,$25.50,$39.95
3 | 1 item,$27.50,$41.95
4 | 2 items,$29.50,$43.95
5 | 3 items,$31.50,$45.95
6 | Special,$33.50,$47.95
7 | 


--------------------------------------------------------------------------------
/week6/pizza/regular.csv:
--------------------------------------------------------------------------------
1 | Regular Pizza,Small,Large
2 | Cheese,$13.50,$18.95
3 | 1 topping,$14.75,$20.95
4 | 2 toppings,$15.95,$22.95
5 | 3 toppings,$16.95,$24.95
6 | Special,$18.50,$26.95
7 | 


--------------------------------------------------------------------------------
/week2/camel/camel.py:
--------------------------------------------------------------------------------
 1 | name = input("Enter your name: ")
 2 | 
 3 | for letter in name:
 4 | 
 5 |     if letter.isupper() : letter = "_" + letter
 6 | 
 7 |     print (letter.lower(), end="")
 8 | 
 9 | print()
10 | 
11 | 


--------------------------------------------------------------------------------
/week7/um/um.py:
--------------------------------------------------------------------------------
 1 | import re
 2 | import sys
 3 | 
 4 | 
 5 | def main():
 6 |     print(count(input("Text: ")))
 7 | 
 8 | 
 9 | def count(s):
10 |     return len(re.findall(r"\bum\b",s.lower()))
11 | 
12 | if __name__ == "__main__":
13 |     main()


--------------------------------------------------------------------------------
/week1/bank/bank.py:
--------------------------------------------------------------------------------
1 | greeting = input("Input a Greeting for $$$:")
2 | 
3 | if greeting.lower().strip().startswith("hello"):
4 |     print("$0")
5 | elif greeting.lower().strip().startswith("h"):
6 |     print("$20")
7 | else:
8 |     print("$100")
9 | 


--------------------------------------------------------------------------------
/week5/test_twttr/test_twttr.py:
--------------------------------------------------------------------------------
1 | from twttr import shorten
2 | 
3 | 
4 | def test():
5 |     assert shorten("aryan") == "ryn"
6 |     assert shorten("cs50") == "cs50"
7 |     assert shorten("AryAn") == "ryn"
8 |     assert shorten("test.test") == "tst.tst"


--------------------------------------------------------------------------------
/week0/indoor/indoor.py:
--------------------------------------------------------------------------------
1 | # Fetch input from the user and store in string variable 'text'
2 | text = input("Type some UPPERCASE text to use your indoor voice! \n")
3 | 
4 | # Convert uppercase characters to lowercase and print output
5 | print (text.lower())


--------------------------------------------------------------------------------
/week0/faces/faces.py:
--------------------------------------------------------------------------------
 1 | def convert(a):
 2 |     a = a.replace(":)","🙂")
 3 |     a = a.replace(":(","🙁")
 4 |     print (a)
 5 | 
 6 | def main():
 7 |     text = input("Input some text with emoticons: ")
 8 |     convert(text)
 9 | 
10 | main()
11 | 
12 | 
13 | 


--------------------------------------------------------------------------------
/week2/twttr/twttr.py:
--------------------------------------------------------------------------------
 1 | text = input("Input:")
 2 | 
 3 | vowel_list = ["a", "e", "i", "o", "u"]
 4 | 
 5 | for l in text:
 6 |     for _ in vowel_list:
 7 |         if l.lower() == _:
 8 |             l = ""
 9 | 
10 |     print(l, end="")
11 | 
12 | print()
13 | 


--------------------------------------------------------------------------------
/week1/deep/deep.py:
--------------------------------------------------------------------------------
1 | answer = input("What is the Answer to the Great Question of Life, the Universe, and Everything?").strip().lower()
2 | 
3 | if answer == "42" or answer == "forty-two" or answer == "forty two":
4 |     print("Yes")
5 | else:
6 |     print("No")
7 | 


--------------------------------------------------------------------------------
/week7/numb3rs/test_numb3rs.py:
--------------------------------------------------------------------------------
1 | from numb3rs import validate
2 | 
3 | def test() :
4 |     assert validate("127.0.0.1") == True
5 |     assert validate("255.255.255.255") == True
6 |     assert validate("1.2.3.1000") == False
7 |     assert validate("cat") == False
8 |     assert validate("1.999.999.999") == False
9 |     assert validate("512.512.512.512") == False


--------------------------------------------------------------------------------
/week2/coke/coke.py:
--------------------------------------------------------------------------------
 1 | amount = 50
 2 | print("Amount due: ", amount)
 3 | 
 4 | while True:
 5 | 
 6 |     money = int(input("Insert Coin: "))
 7 | 
 8 |     if money == 25 or money==10 or money==5:
 9 |         amount = amount - money
10 | 
11 |     if amount <= 0:
12 |             print("Change Owed:", abs(amount))
13 |             break
14 | 
15 |     print("Amount Due:", amount)


--------------------------------------------------------------------------------
/week1/interpreter/interpreter.py:
--------------------------------------------------------------------------------
 1 | expression = input ("Expression:")
 2 | 
 3 | num1, op, num2 = expression.split(" ")
 4 | 
 5 | if op == "+":
 6 |     print (float(num1) + float(num2))
 7 | 
 8 | if op == "-":
 9 |     print (float(num1) - float(num2))
10 | 
11 | if op == "*":
12 |     print (float(num1) * float(num2))
13 | 
14 | if op == "/":
15 |     print (float(num1) / float(num2))


--------------------------------------------------------------------------------
/week5/test_bank/bank.py:
--------------------------------------------------------------------------------
 1 | def main():
 2 |     print("$",value(input("Input a Greeting for $$$:")))
 3 | 
 4 | 
 5 | def value(greeting):
 6 |     if greeting.lower().strip().startswith("hello"):
 7 |         return 0
 8 |     elif greeting.lower().strip().startswith("h"):
 9 |         return 20
10 |     else:
11 |         return 100
12 | 
13 | 
14 | if __name__ == "__main__":
15 |     main()
16 | 


--------------------------------------------------------------------------------
/week7/watch/watch.py:
--------------------------------------------------------------------------------
 1 | import re
 2 | import sys
 3 | 
 4 | def main():
 5 |     print(parse(input("HTML: ")))
 6 | 
 7 | 
 8 | def parse(s):
 9 | 
10 |     if match := re.search(r"<iframe src=\"(?:https?://)?(?:www.)?youtube\.com/embed/(xvFZjo5PgG0)\"",s) :
11 |         return "https://youtu.be/"+match.group(1)
12 |     else : return None
13 | 
14 | 
15 | if __name__ == "__main__":
16 |     main()


--------------------------------------------------------------------------------
/week7/numb3rs/numb3rs.py:
--------------------------------------------------------------------------------
 1 | import re
 2 | import sys
 3 | 
 4 | 
 5 | def main():
 6 |     print(validate(input("IPv4 Address: ")))
 7 | 
 8 | 
 9 | def validate(ip):
10 | 
11 |     byte = r"(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)"
12 | 
13 |     if re.search(f"^{byte}\.{byte}\.{byte}\.{byte}$", ip):
14 |         return True
15 |     else:
16 |         return False
17 | 
18 | if __name__ == "__main__":
19 |     main()


--------------------------------------------------------------------------------
/week3/grocery/grocery.py:
--------------------------------------------------------------------------------
 1 | groceriesdict = {}
 2 | 
 3 | while True :
 4 | 
 5 |     try :
 6 |         key = input("")
 7 | 
 8 |         if key in groceriesdict : groceriesdict[key] += 1
 9 |         else : groceriesdict[key] = 1
10 | 
11 |     except EOFError :
12 |         for k in sorted(groceriesdict) :
13 |             print (groceriesdict[k], k.upper(), sep=" " , end="\n")
14 |         break
15 | 
16 |     except KeyError : pass
17 | 


--------------------------------------------------------------------------------
/week0/tip/tip.py:
--------------------------------------------------------------------------------
 1 | def main():
 2 |     dollars = dollars_to_float(input("How much was the meal? "))
 3 |     percent = percent_to_float(input("What percentage would you like to tip? "))
 4 |     tip = dollars * percent
 5 |     print(f"Leave ${tip:.2f}")
 6 | 
 7 | def dollars_to_float(d):
 8 |     d = d.replace("$" , "")
 9 |     return float(d)
10 | 
11 | def percent_to_float(p):
12 |     p = p.replace("%","")
13 |     return float(p)/100
14 | 
15 | 
16 | main()


--------------------------------------------------------------------------------
/week5/test_twttr/twttr.py:
--------------------------------------------------------------------------------
 1 | def main():
 2 |     print(shorten(input("Input:")))
 3 | 
 4 | 
 5 | def shorten(word):
 6 |     final = ""
 7 |     vowel_list = ["a", "e", "i", "o", "u","A", "E", "I", "O", "U"]
 8 | 
 9 |     if str(word).isnumeric():
10 |         return word
11 | 
12 |     for l in word:
13 |         for _ in vowel_list:
14 |             if l == _:
15 |                 l = ""
16 | 
17 |         final += l
18 | 
19 |     return final
20 | 
21 | 
22 | if __name__ == "__main__":
23 |     main()
24 | 


--------------------------------------------------------------------------------
/week6/lines/lines.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | 
 3 | if len(sys.argv) != 2 :
 4 |     sys.exit("Too many command line arguments!")
 5 | 
 6 | if not sys.argv[1].endswith(".py"):
 7 |     sys.exit("File must be a python file!")
 8 | 
 9 | linecounter = 0
10 | 
11 | try :
12 |     with open(sys.argv[1]) as file :
13 |         for line in file :
14 |             if not line.strip().startswith("#") and line.strip():
15 |                     linecounter += 1
16 | except FileNotFoundError :
17 |     sys.exit("File does not exist!")
18 | 
19 | print(linecounter)


--------------------------------------------------------------------------------
/week8/seasons/test_seasons.py:
--------------------------------------------------------------------------------
 1 | from datetime import date
 2 | from seasons import userinput, convert_to_minutes
 3 | import pytest
 4 | 
 5 | valid_input = "2000-01-01"
 6 | invalid_input = "01-01-2000"
 7 | 
 8 | def test_userinput_valid():
 9 |     result = userinput(valid_input)
10 |     assert result == valid_input
11 | 
12 | def test_userinput_invalid():
13 |     with pytest.raises(SystemExit):
14 |         userinput(invalid_input)
15 | 
16 | def test_convert_to_minutes():
17 |     result = convert_to_minutes("2000-01-01")
18 |     assert result is None
19 | 


--------------------------------------------------------------------------------
/week1/extensions/extensions.py:
--------------------------------------------------------------------------------
 1 | file = input("Enter file name:").strip().lower()
 2 | 
 3 | if file.endswith(".png"):
 4 |     print("image/png")
 5 | 
 6 | elif file.endswith(".jpg") or  file.endswith(".jpeg"):
 7 |     print("image/jpeg")
 8 | 
 9 | elif file.endswith(".gif"):
10 |     print("image/gif")
11 | 
12 | elif file.endswith(".pdf"):
13 |     print("application/pdf")
14 | 
15 | elif file.endswith(".txt"):
16 |     print("text/plain")
17 | 
18 | elif file.endswith(".zip"):
19 |     print("application/zip")
20 | 
21 | else:
22 |     print ("application/octet-stream")


--------------------------------------------------------------------------------
/week5/test_bank/test_bank.py:
--------------------------------------------------------------------------------
 1 | from bank import value
 2 | 
 3 | def test_twenty ():
 4 |     assert value("hi") == 20
 5 |     assert value("heyyyy") == 20
 6 |     assert value("heyHEYhey") == 20
 7 |     assert value("heyaryan") == 20
 8 |     assert value("heykhyati") == 20
 9 | 
10 | def test_zero() :
11 |     assert value("hellooooo") == 0
12 |     assert value("Hellooooo") == 0
13 |     assert value("hellooooo123") == 0
14 | 
15 | def test_hundred() :
16 |     assert value("wassup") == 100
17 |     assert value("wassupAryan") == 100
18 |     assert value("wassupKhyati") == 100
19 | 


--------------------------------------------------------------------------------
/week5/test_plates/test_plates.py:
--------------------------------------------------------------------------------
 1 | from plates import is_valid
 2 | 
 3 | def test_valid() :
 4 |     assert is_valid("CS50") == True
 5 |     assert is_valid("aryan") == True
 6 |     assert is_valid("khyati") == True
 7 |     assert is_valid("AR78") == True
 8 | 
 9 | 
10 | def test_invalid() :
11 |     assert is_valid("CS50P") == False
12 |     assert is_valid("CS05") == False
13 |     assert is_valid("PI3.14") == False
14 |     assert is_valid("H") == False
15 |     assert is_valid("OUTATIME") == False
16 |     assert is_valid("123") == False
17 |     assert is_valid("50CS") == False
18 | 
19 | 


--------------------------------------------------------------------------------
/week3/fuel/fuel.py:
--------------------------------------------------------------------------------
 1 | def take_input():
 2 |     while True:
 3 |         try:
 4 |             user_input = input("Fraction: ").strip().split("/")
 5 |             return round(int(user_input[0]) / int(user_input[1]), 2) * 100
 6 | 
 7 |         except ValueError:
 8 |             pass
 9 |         except ZeroDivisionError:
10 |             pass
11 | 
12 | 
13 | def main():
14 |     value = int(take_input())
15 |     if 99 <= value <= 100:
16 |         print("F")
17 |     elif value <= 1:
18 |         print("E")
19 |     elif value > 100:
20 |         take_input()
21 |     else:
22 |         print(int(value), "%", sep="")
23 | 


--------------------------------------------------------------------------------
/week7/working/test_working.py:
--------------------------------------------------------------------------------
 1 | from working import convert
 2 | import pytest
 3 | 
 4 | def test() :
 5 |     assert convert("9 AM to 5 PM") == "09:00 to 17:00"
 6 |     assert convert("9:00 AM to 5:00 PM") == "09:00 to 17:00"
 7 |     assert convert("8 PM to 8 AM") == "20:00 to 08:00"
 8 |     assert convert("8:00 PM to 8:00 AM") == "20:00 to 08:00"
 9 |     assert convert("12 AM to 12 PM") == "00:00 to 12:00"
10 |     assert convert("12:00 AM to 12:00 PM") == "00:00 to 12:00"
11 | 
12 |     with pytest.raises(ValueError):
13 |         convert("8:60 AM to 4:60 PM")
14 | 
15 |     with pytest.raises(ValueError):
16 |         convert("12:00 AM12:00 PM")


--------------------------------------------------------------------------------
/week4/game/game.py:
--------------------------------------------------------------------------------
 1 | import random
 2 | 
 3 | while True :
 4 |     try:
 5 |         n = int(input("Level:"))
 6 |     except ValueError :
 7 |         continue
 8 | 
 9 |     if n <= 0 :
10 |         continue
11 |     else :
12 |         number = random.randrange(1,n+1)
13 |         break
14 | 
15 | while True:
16 | 
17 |     try:
18 |         userguess = int(input("Guess:"))
19 |     except ValueError :
20 |         continue
21 | 
22 |     if userguess == number :
23 |         print("Just right!")
24 |         break
25 |     elif userguess < number :
26 |         print("Too small!")
27 |         continue
28 |     elif userguess > number :
29 |         print("Too large!")
30 | 


--------------------------------------------------------------------------------
/Final project/test_project.py:
--------------------------------------------------------------------------------
 1 | import pytest
 2 | import project
 3 | import tkinter as tk
 4 | 
 5 | def test_get_base64_encoded_credentials():
 6 |     client_id = "test"
 7 |     client_secret = "test"
 8 | 
 9 |     result = project.get_base64_encoded_credentials(client_id, client_secret)
10 | 
11 |     assert result != ""
12 | 
13 | def test_display_progress_dialog():
14 |     project.window = tk.Tk()
15 | 
16 |     project.display_progress_dialog("Test Progress")
17 | 
18 |     assert project.progress_dialog is not None
19 | 
20 | def test_print():
21 |     assert project.print_app_name() == "Welcome to AryanSpotifyTools!"
22 | 
23 | if __name__ == "__main__":
24 |     pytest.main()
25 | 


--------------------------------------------------------------------------------
/week2/nutrition/nutrition.py:
--------------------------------------------------------------------------------
 1 | fruit = input("Item: ").lower()
 2 | 
 3 | fruits = {
 4 |     "apple": "130",
 5 |     "avocado": "50",
 6 |     "banana": "110",
 7 |     "cantaloupe": "50",
 8 |     "grapefruit": "60",
 9 |     "grapes": "90",
10 |     "honeydew melon": "50",
11 |     "kiwifruit": "90",
12 |     "lemon": "15",
13 |     "lime": "20",
14 |     "nectarine": "60",
15 |     "orange": "80",
16 |     "peach": "60",
17 |     "pear": "100",
18 |     "pineapple": "50",
19 |     "plums": "70",
20 |     "strawberries": "50",
21 |     "sweet cherries": "100",
22 |     "tangerine": "50",
23 |     "watermelon": "80"
24 | }
25 | 
26 | if fruit in fruits :alwe
27 |     print ("Calories:", fruits[fruit])


--------------------------------------------------------------------------------
/week4/bitcoin/bitcoin.py:
--------------------------------------------------------------------------------
 1 | import requests
 2 | import json
 3 | import sys
 4 | 
 5 | try:
 6 |     if len(sys.argv) == 1:
 7 |         sys.exit("Missing command-line argument")
 8 | 
 9 |     elif sys.argv[1].isalpha():
10 |         sys.exit("Command-line argument is not a number")
11 |     else:
12 |         response = requests.get("https://api.coindesk.com/v1/bpi/currentprice.json")
13 |         response_json = response.json()
14 | 
15 |         amount = float(response_json["bpi"]["USD"]["rate"].replace(",", ""))
16 | 
17 |         amount = amount * float(sys.argv[1])
18 |         print(f"${amount:,.4f}")
19 | 
20 | except IndexError:
21 |     pass
22 | except requests.RequestException:
23 |     pass
24 | 


--------------------------------------------------------------------------------
/week5/test_fuel/test_fuel.py:
--------------------------------------------------------------------------------
 1 | from fuel import convert, gauge
 2 | import pytest
 3 | 
 4 | 
 5 | def test_full():
 6 |     assert gauge(convert("100/100")) == "F"
 7 |     assert gauge(convert("99/100")) == "F"
 8 | 
 9 | 
10 | def test_empty():
11 |     assert gauge(convert("0/100")) == "E"
12 |     assert gauge(convert("1/100")) == "E"
13 | 
14 | 
15 | def test_percentages():
16 |     for i in range(10, 90, 10):
17 |         assert gauge(convert(f"{i}/100")) == f"{i}%"
18 |         i += 10
19 | 
20 | 
21 | def test_value_error():
22 |     with pytest.raises(ValueError):
23 |         gauge(convert("one/two"))
24 | 
25 | 
26 | def test_div_zero_error():
27 |     with pytest.raises(ZeroDivisionError):
28 |         gauge(convert("10/0"))
29 | 


--------------------------------------------------------------------------------
/week1/meal/meal.py:
--------------------------------------------------------------------------------
 1 | def main():
 2 |     inputtime = input("What time is it?")
 3 | 
 4 |     convertedtime = convert(inputtime)
 5 | 
 6 |     if 7 <= convertedtime <=8:
 7 |         print ("breakfast time")
 8 | 
 9 |     elif 12 <= convertedtime <=13:
10 |         print ("lunch time")
11 | 
12 |     elif 18 <= convertedtime <=19:
13 |         print ("dinner time")
14 | 
15 | def convert(time):
16 |     time = time.rstrip("am").strip()
17 |     time = time.rstrip("pm").strip()
18 | 
19 |     hours, minutes = time.split(":")
20 | 
21 |     hours = float(hours)
22 |     minutes = float(minutes)
23 | 
24 |     minutes = minutes / 60
25 |     return float(hours + minutes)
26 | 
27 | main()
28 | 
29 |     # 7:00 and 8:00, lunch between 12:00 and 13:00, and dinner between 18:00 and 19:00.
30 | 


--------------------------------------------------------------------------------
/week5/test_fuel/fuel.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | def main():
 3 |     print(gauge(convert(input("Fraction: "))))
 4 | 
 5 | def convert(fraction):
 6 |     # returns as percentage
 7 |     fraction = fraction.strip().split("/")
 8 |     while True:
 9 |         try:
10 |             return round(int(fraction[0]) / int(fraction[1]), 2) * 100
11 | 
12 |         except ValueError:
13 |             pass
14 |         except ZeroDivisionError:
15 |             pass
16 | 
17 | 
18 | def gauge(percentage):
19 |     value = int(percentage)
20 |     if 99 <= value <= 100:
21 |         return("F")
22 |     elif value <= 1:
23 |         return("E")
24 |     elif value > 100:
25 |         main()
26 |     else:
27 |         return(str(value)+"%")
28 | 
29 | 
30 | if __name__ == "__main__":
31 |     main()
32 | 


--------------------------------------------------------------------------------
/week3/taqueria/taqueria.py:
--------------------------------------------------------------------------------
 1 | menu = {
 2 |     "Baja Taco": 4.00,
 3 |     "Burrito": 7.50,
 4 |     "Bowl": 8.50,
 5 |     "Nachos": 11.00,
 6 |     "Quesadilla": 8.50,
 7 |     "Super Burrito": 8.50,
 8 |     "Super Quesadilla": 9.50,
 9 |     "Taco": 3.00,
10 |     "Tortilla Salad": 8.00
11 | }
12 | 
13 | flag = True ; ordertotal = []
14 | 
15 | def takeuserinput() :
16 | 
17 |     try :
18 |         order = input("Item:").title()
19 |         if order in menu : ordertotal.append(round(menu[order],3))
20 |         return True
21 | 
22 |     except EOFError :
23 |         return False
24 |     except KeyError : return False
25 | 
26 | 
27 | while flag :
28 |     flag = takeuserinput()
29 |     if not flag :
30 |         break
31 |     print (f"${sum(ordertotal):.2f}")
32 |     print()
33 | 
34 | 


--------------------------------------------------------------------------------
/week4/figlet/figlet.py:
--------------------------------------------------------------------------------
 1 | from pyfiglet import Figlet
 2 | import sys
 3 | import random
 4 | 
 5 | f = Figlet()
 6 | 
 7 | fontlist = f.getFonts()
 8 | 
 9 | try:
10 |     if sys.argv[1] == "-f" or sys.argv[1] == "--font" :
11 |         for font in fontlist :
12 |             if sys.argv[2] == font:
13 |                 userinputfont = font
14 | 
15 |             if sys.argv[2] not in fontlist :
16 |                 sys.exit("Invalid usage")
17 |     else :
18 |         sys.exit("Invalid usage")
19 | except IndexError : pass
20 | 
21 | if len(sys.argv) == 2:
22 |     sys.exit("Invalid usage")
23 | 
24 | if len(sys.argv) == 1:
25 |     userinputfont = fontlist[random.randrange(0,10)]
26 | 
27 | f.setFont(font=userinputfont)
28 | 
29 | userinput = input("Input: ")
30 | 
31 | print (f.renderText(userinput))


--------------------------------------------------------------------------------
/week6/shirt/shirt.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | from PIL import Image,ImageOps
 3 | 
 4 | if len(sys.argv) > 3:
 5 |     sys.exit("Too many command-line arguments")
 6 | elif len(sys.argv) < 3:
 7 |     sys.exit("Too few command-line arguments")
 8 | 
 9 | file1name,file1extension = sys.argv[1].split(".")
10 | file2name,file2extension = sys.argv[2].split(".")
11 | 
12 | extensiontypes = ["png","jpg","jpeg",]
13 | 
14 | if file2extension not in extensiontypes :
15 |     sys.exit("Invalid output")
16 | 
17 | if file1extension != file2extension :
18 |     sys.exit("Input and output have different extensions")
19 | 
20 | with Image.open("shirt.png") as shirt, Image.open(sys.argv[1]) as muppet :
21 |     muppet = ImageOps.fit(muppet, shirt.size)
22 |     muppet.paste(shirt,shirt)
23 |     muppet.save(sys.argv[2])
24 | 
25 | 


--------------------------------------------------------------------------------
/week8/jar/jar.py:
--------------------------------------------------------------------------------
 1 | class Jar:
 2 |     def __init__(self, capacity=12):
 3 | 
 4 |         if capacity < 0 :
 5 |             raise ValueError("Capacity cannnot be less than 0!")
 6 | 
 7 |         self._capacity = capacity
 8 |         self._size = 0
 9 | 
10 |     def __str__(self):
11 |         return "🍪" * self._size
12 | 
13 |     def deposit(self, n):
14 |         if self._size + n > self._capacity :
15 |             raise ValueError("Cannot exceed jar's capacity!")
16 |         self._size +=n
17 | 
18 |     def withdraw(self, n):
19 |         if self._size < n :
20 |             raise ValueError("Cannot withdraw less than cookies in jar!")
21 |         self._size -= n
22 | 
23 |     @property
24 |     def capacity(self):
25 |         return self._capacity
26 | 
27 |     @property
28 |     def size(self):
29 |         return self._size


--------------------------------------------------------------------------------
/week6/pizza/pizza.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | import csv
 3 | from tabulate import tabulate
 4 | 
 5 | if len(sys.argv) > 2:
 6 |     sys.exit("Too many command-line arguments")
 7 | elif len(sys.argv) > 2:
 8 |     sys.exit("Too few command-line arguments")
 9 | 
10 | if not sys.argv[1].endswith(".csv"):
11 |     sys.exit("Not a CSV file")
12 | 
13 | file_name = sys.argv[1]
14 | 
15 | if file_name == "sicilian.csv": type = "Sicilian Pizza"
16 | elif file_name == "regular.csv": type = "Regular Pizza"
17 | 
18 | 
19 | list = []
20 | 
21 | try:
22 |     with open(file_name) as file:
23 | 
24 |         reader = csv.DictReader(file)
25 | 
26 |         list.append(reader.fieldnames)
27 | 
28 |         for row in reader:
29 |             list.append([row[type], row["Small"], row["Large"]])
30 | 
31 |         print(tabulate(list, headers="firstrow",tablefmt="grid"))
32 | 
33 | except FileNotFoundError:
34 |     sys.exit("File does not exist")


--------------------------------------------------------------------------------
/week8/seasons/seasons.py:
--------------------------------------------------------------------------------
 1 | from datetime import date
 2 | import re
 3 | import sys
 4 | import inflect
 5 | 
 6 | 
 7 | def main():
 8 |     convert_to_minutes(userinput(input("Date of Birth: ")))
 9 | 
10 | 
11 | def userinput(input):
12 |     # YYYY-MM-DD formatting
13 | 
14 |     user_input = input.strip()
15 | 
16 |     if re.match(r"^\d\d\d\d-\d\d-\d\d$", user_input):
17 |         return user_input
18 |     else:
19 |         sys.exit("Invalid date")
20 | 
21 | 
22 | def convert_to_minutes(date_user_input):
23 |     time_duration = date.today() - date.fromisoformat(date_user_input)
24 |     convert_to_words(int(time_duration.total_seconds() / 60))
25 | 
26 | 
27 | def convert_to_words(minutes):
28 |     format(inflect.engine().number_to_words(minutes))
29 | 
30 | 
31 | def format(word):
32 |     word = word + " minutes"
33 |     capitalized = word[0].upper() + word[1:]
34 |     formatted = re.sub(r"\b\sand\s\b", " ", capitalized)
35 |     print(formatted)
36 | 
37 | 
38 | if __name__ == "__main__":
39 |     main()
40 | 


--------------------------------------------------------------------------------
/week2/plates/plates.py:
--------------------------------------------------------------------------------
 1 | def main():
 2 |     plate = input("Plate: ")
 3 |     if is_valid(plate):
 4 |         print("Valid")
 5 |     else:
 6 |         print("Invalid")
 7 | 
 8 | def is_valid(s):
 9 | 
10 |     def check_numbers_letters() :
11 | 
12 |         numberindex = -1
13 | 
14 |         for c in s :
15 |             if c.isnumeric() :
16 |                 numberindex = s.find(c)
17 |                 break
18 | 
19 |         if numberindex == -1 :
20 |             return False
21 |         else :
22 | 
23 |             for c in s[numberindex:len(s)]:
24 |                 if c.isalpha():
25 |                     return True
26 | 
27 |     if "." in s or " " in s:
28 |         return False
29 |     elif s[0:2].isnumeric() :
30 |         return False
31 |     elif len(s) < 2 or len(s) > 6:
32 |         return False
33 |     elif s[0] =="0" :
34 |         return False
35 |     elif check_numbers_letters () :
36 |         return False
37 |     elif s[2] == "0" :
38 |         return False
39 |     else:
40 |         return True
41 | 
42 | main()


--------------------------------------------------------------------------------
/week5/test_plates/plates.py:
--------------------------------------------------------------------------------
 1 | def main():
 2 |     plate = input("Plate: ")
 3 |     if is_valid(plate):
 4 |         print("Valid")
 5 |     else:
 6 |         print("Invalid")
 7 | 
 8 | def is_valid(s):
 9 | 
10 |     def check_numbers_letters() :
11 | 
12 |         num_index = -1
13 | 
14 |         for c in s :
15 |             if c.isnumeric() :
16 |                 num_index = s.find(c)
17 |                 break
18 | 
19 |         if num_index == -1 :
20 |             return False
21 |         else :
22 | 
23 |             for c in s[num_index:len(s)]:
24 |                 if c.isalpha():
25 |                     return True
26 | 
27 |     if "." in s or " " in s:
28 |         return False
29 |     elif s[0:2].isnumeric() :
30 |         return False
31 |     elif len(s) < 2 or len(s) > 6:
32 |         return False
33 |     elif s[0] =="0" :
34 |         return False
35 |     elif check_numbers_letters () :
36 |         return False
37 |     elif s[2] == "0" :
38 |         return False
39 |     else:
40 |         return True
41 | 
42 | 
43 | if __name__ == "__main__":
44 |     main()
45 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2023 Aryan Randeriya
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/week6/scourgify/scourgify.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | import csv
 3 | from tabulate import tabulate
 4 | 
 5 | if len(sys.argv) > 3:
 6 |     sys.exit("Too many command-line arguments")
 7 | elif len(sys.argv) < 3:
 8 |     sys.exit("Too few command-line arguments")
 9 | 
10 | if not sys.argv[1].endswith(".csv") or not sys.argv[2].endswith(".csv"):
11 |     sys.exit("Not a CSV file")
12 | 
13 | argument_one = sys.argv[1]
14 | argument_two = sys.argv[2]
15 | 
16 | try:
17 |     with open(argument_one) as file:
18 |         reader = csv.DictReader(file)
19 | 
20 |         file = open(argument_two,"w")
21 |         writer = csv.DictWriter(file, fieldnames=["first", "last", "house"])
22 |         writer.writeheader()
23 | 
24 |         for row in reader:
25 |             house = row["house"]
26 |             lastname, firstname = row["name"].split(",")
27 |             writer.writerow(
28 |                 {
29 |                     "first": firstname.strip(),
30 |                     "last": lastname.strip(),
31 |                     "house": house.strip(),
32 |                 }
33 |             )
34 | 
35 |         file.close()
36 | except FileNotFoundError:
37 |     sys.exit("Could not read" + argument_one)
38 | 


--------------------------------------------------------------------------------
/week4/adieu/adieu.py:
--------------------------------------------------------------------------------
 1 | # Commented code is code without using and importing external libraries (slightly incomplete)
 2 | 
 3 | # import sys
 4 | # name = []
 5 | 
 6 | # try :
 7 | #     while True :
 8 | #         name.append(input("Name: \n").capitalize())
 9 | #         print()
10 | 
11 | # except EOFError :
12 | 
13 | #     print("Adieu, adieu, to ", end="")
14 | #     for i in range(len(name)-1) :
15 | #         print(name[i] + ", ", end="")
16 | 
17 | #     if(len(name)>1) :
18 | #         print("and", name[len(name)-1])
19 | #     else :
20 | #         print(name[0])
21 | 
22 | import inflect
23 | p = inflect.engine()
24 | 
25 | name = [] ; mylist =[]
26 | 
27 | try :
28 |     while True :
29 |         name.append(input("Name: \n").capitalize())
30 |         print()
31 | 
32 | except EOFError :
33 | 
34 |     mylist = p.join((name))
35 | 
36 |     print("Adieu, adieu, to ", end="")
37 | 
38 |     for i in range(len(mylist)) :
39 |         print(mylist[i], end="")
40 | 
41 |     print()
42 | 
43 | # # JOIN WORDS INTO A LIST:
44 | 
45 | # mylist = p.join(("apple", "banana", "carrot"))
46 | # # "apple, banana, and carrot"
47 | 
48 | # mylist = p.join(("apple", "banana"))
49 | # # "apple and banana"
50 | 
51 | # mylist = p.join(("apple", "banana", "carrot"), final_sep="")
52 | # # "apple, banana and carrot"


--------------------------------------------------------------------------------
/week3/outdated/outdated.py:
--------------------------------------------------------------------------------
 1 | months = {
 2 |     "01":"January",
 3 |     "02":"February",
 4 |     "03":"March",
 5 |     "04":"April",
 6 |     "05":"May",
 7 |     "06":"June",
 8 |     "07":"July",
 9 |     "08":"August",
10 |     "09":"September",
11 |     "10":"October",
12 |     "11":"November",
13 |     "12":"December"
14 | }
15 | 
16 | def Main():
17 | 
18 |     while method() :
19 |         method()
20 | 
21 | def method() :
22 | 
23 |     date = input("Date:").capitalize()
24 | 
25 |     for j in months :
26 |         value = months[j]
27 |         if "/" in date and value in date :
28 |             return True
29 |         if value in date and "," not in date :
30 |             return True
31 | 
32 |     date = date.replace("/"," ").replace(","," ").split()
33 | 
34 |     if date[1].isalpha() :
35 |         return True
36 | 
37 |     month = date[0].strip()
38 |     day = int(date[1].strip())
39 |     year = int(date[2].strip())
40 | 
41 |     if month.isnumeric() :
42 |         month=int(month.strip())
43 | 
44 |         if month > 12 :
45 |             return True
46 | 
47 |     for i in months :
48 |         if month == months[i] :
49 |             month = i
50 | 
51 |     if day > 31:
52 |         return True
53 | 
54 |     print(f"{year:04}-{month:02}-{day:02}",end="")
55 |     return False
56 | 
57 | Main()


--------------------------------------------------------------------------------
/week8/shirtificate/shirtificate.py:
--------------------------------------------------------------------------------
 1 | from fpdf import FPDF
 2 | 
 3 | pdf = FPDF()
 4 | 
 5 | def name():
 6 |     return input("Name: ").strip().title()
 7 | 
 8 | def main():
 9 |     pdf.add_page()
10 |     pdf.image("shirtificate.png", x=10, y=100, w=190, h=0, type='', link='')
11 |     pdf.set_auto_page_break(False,0)
12 |     name_param = name()
13 |     add_name(name_param)
14 |     add_title()
15 |     pdf.output("shirtificate.pdf")
16 | 
17 | def add_title():
18 |     title = "CS50 Shirtificate"
19 |     pdf.set_font("Helvetica", "B" ,size=50)
20 |     pdf.set_text_color(r=0,g=0,b=0)
21 |     text_width = pdf.get_string_width(title)
22 |     x_coordinate = pdf.w / 2 - (text_width / 2)
23 |     y_coordinate = pdf.h / 8
24 |     pdf.set_xy(x_coordinate, y_coordinate)
25 |     pdf.set_xy(x_coordinate, pdf.y)
26 |     pdf.cell(text_width, pdf.h/2-100, title, border=0, ln=1, align="C")
27 | 
28 | def add_name(name_param):
29 | 
30 |     tshirt_text = name_param + " took CS50"
31 |     pdf.set_font("Helvetica", "B" ,size=25)
32 |     pdf.set_text_color(r=255,g=255,b=255)
33 |     text_width = pdf.get_string_width(tshirt_text)
34 |     x_coordinate = pdf.w / 2 - (text_width / 2)
35 |     pdf.set_xy(x_coordinate, pdf.y)
36 |     pdf.cell(text_width, pdf.h/2+150, tshirt_text, border=0, ln=1, align="C")
37 | 
38 | 
39 | if __name__ == "__main__" :
40 |     main()


--------------------------------------------------------------------------------
/week7/working/working.py:
--------------------------------------------------------------------------------
 1 | import re
 2 | import sys
 3 | 
 4 | 
 5 | def main():
 6 | 
 7 |     print(convert(input("Hours: ").strip()))
 8 | 
 9 | def convert(s):
10 | 
11 |     if match := re.search(r"(\d?\d):?(\d\d)? (AM|PM) to (\d?\d):?(\d\d)? (PM|AM)", s, re.IGNORECASE) :
12 | 
13 |         hour1=int(match.group(1))
14 |         ampm1=match.group(3)
15 | 
16 |         hour2=int(match.group(4))
17 |         ampm2=match.group(6)
18 | 
19 |         try :
20 |             minute1=int(match.group(2))
21 |             minute2=int(match.group(5))
22 |         except TypeError :
23 |             minute1 = 0
24 |             minute2 = 0
25 | 
26 |         if minute2 or minute1 >= 60 :
27 |             raise ValueError
28 | 
29 |         if ampm1 == "PM" :
30 |             if hour1 == 12 :
31 |                 hour1 = 12
32 |             else :
33 |                 hour1 = int(hour2)+12
34 |         else : # if AM
35 |             if hour1 == 12 :
36 |                 hour1 = 0
37 | 
38 |         if ampm2 == "PM" :
39 |             if hour2 == 12 :
40 |                 hour2 = 12
41 |             else :
42 |                 hour2 = int(hour2)+12
43 |         else : #if AM
44 |             if hour2 == 12 :
45 |                 hour2 = 0
46 | 
47 |         return f"{hour1:02}:{minute1:02} to {hour2:02}:{minute2:02}"
48 | 
49 |     else :
50 |         raise ValueError
51 | 
52 | if __name__ == "__main__":
53 |     main()


--------------------------------------------------------------------------------
/week8/jar/test_jar.py:
--------------------------------------------------------------------------------
 1 | from jar import Jar
 2 | 
 3 | def test_init():
 4 |     jar = Jar()
 5 |     assert jar.capacity == 12
 6 |     assert jar.size == 0
 7 | 
 8 |     jar = Jar(20)
 9 |     assert jar.capacity == 20
10 |     assert jar.size == 0
11 | 
12 |     try:
13 |         jar = Jar(-5)
14 |     except ValueError as e:
15 |         assert str(e) == "Capacity cannnot be less than 0!"
16 | 
17 | def test_str():
18 |     jar = Jar()
19 |     assert str(jar) == ""
20 |     jar.deposit(1)
21 |     assert str(jar) == "🍪"
22 |     jar.deposit(11)
23 |     assert str(jar) == "🍪🍪🍪🍪🍪🍪🍪🍪🍪🍪🍪🍪"
24 | 
25 | def test_deposit():
26 |     jar = Jar()
27 | 
28 |     jar.deposit(5)
29 |     assert jar.size == 5
30 |     assert str(jar) == "🍪🍪🍪🍪🍪"
31 | 
32 |     try:
33 |         jar.deposit(10)
34 |     except ValueError as e:
35 |         assert str(e) == "Cannot exceed jar's capacity!"
36 | 
37 | def test_withdraw():
38 |     jar = Jar(15)
39 |     jar.deposit(10)
40 | 
41 |     jar.withdraw(5)
42 |     assert jar.size == 5
43 |     assert str(jar) == "🍪🍪🍪🍪🍪"
44 | 
45 |     try:
46 |         jar.withdraw(7)
47 |     except ValueError as e:
48 |         assert str(e) == "Cannot withdraw less than cookies in jar!"
49 | 
50 | def test_capacity():
51 |     jar = Jar(25)
52 |     assert jar.capacity == 25
53 | 
54 | def test_size():
55 |     jar = Jar()
56 |     assert jar.size == 0
57 |     jar.deposit(8)
58 |     assert jar.size == 8
59 | 


--------------------------------------------------------------------------------
/week4/professor/professor.py:
--------------------------------------------------------------------------------
 1 | import random
 2 | 
 3 | def main():
 4 |     generate_integer(get_level())
 5 | 
 6 | def get_level():
 7 | 
 8 |     while True :
 9 |         try :
10 |             level = int(input("Level: "))
11 |         except ValueError : continue
12 |         print()
13 | 
14 |         if level > 3 or level < 1 : continue
15 |         else : return level
16 | 
17 | def generate_integer(level):
18 | 
19 |     eee_counter = 0 ; correct_problems = 0
20 | 
21 |     if level == 1 :
22 |         small_range = 0
23 |         large_range = 9
24 | 
25 |     elif level == 2:
26 |         small_range = 10
27 |         large_range = 99
28 | 
29 |     elif level == 3:
30 |         small_range = 100
31 |         large_range = 999
32 | 
33 | 
34 |     for _ in range(10) :
35 |         a = random.randint(small_range,large_range)
36 |         b = random.randint(small_range,large_range)
37 |         while True :
38 |             print (f"{a} + {b} =" , end="")
39 |             c = a + b
40 |             answer = int(input(""))
41 | 
42 |             if answer == c :
43 |                 correct_problems += 1
44 |                 break
45 | 
46 |             elif answer != c :
47 |                 eee_counter += 1
48 | 
49 |                 if eee_counter >= 3 :
50 |                     print(c)
51 |                     break
52 | 
53 |                 print("EEE")
54 |                 continue
55 | 
56 |         print(correct_problems)
57 | 
58 | if __name__ == "__main__":
59 |     main()
60 | 


--------------------------------------------------------------------------------
/week6/scourgify/after.csv:
--------------------------------------------------------------------------------
 1 | first,last,house
 2 | Hannah,Abbott,Hufflepuff
 3 | Katie,Bell,Gryffindor
 4 | Susan,Bones,Hufflepuff
 5 | Terry,Boot,Ravenclaw
 6 | Lavender,Brown,Gryffindor
 7 | Millicent,Bulstrode,Slytherin
 8 | Cho,Chang,Ravenclaw
 9 | Penelope,Clearwater,Ravenclaw
10 | Vincent,Crabbe,Slytherin
11 | Colin,Creevey,Gryffindor
12 | Dennis,Creevey,Gryffindor
13 | Cedric,Diggory,Hufflepuff
14 | Marietta,Edgecombe,Ravenclaw
15 | Justin,Finch-Fletchley,Hufflepuff
16 | Seamus,Finnigan,Gryffindor
17 | Anthony,Goldstein,Ravenclaw
18 | Gregory,Goyle,Slytherin
19 | Hermione,Granger,Gryffindor
20 | Angelina,Johnson,Gryffindor
21 | Lee,Jordan,Gryffindor
22 | Neville,Longbottom,Gryffindor
23 | Luna,Lovegood,Ravenclaw
24 | Remus,Lupin,Gryffindor
25 | Draco,Malfoy,Slytherin
26 | Scorpius,Malfoy,Slytherin
27 | Ernie,Macmillan,Hufflepuff
28 | Minerva,McGonagall,Gryffindor
29 | Eloise,Midgen,Gryffindor
30 | Cormac,McLaggen,Gryffindor
31 | Graham,Montague,Slytherin
32 | Theodore,Nott,Slytherin
33 | Pansy,Parkinson,Slytherin
34 | Padma,Patil,Gryffindor
35 | Parvati,Patil,Gryffindor
36 | Harry,Potter,Gryffindor
37 | Tom,Riddle,Slytherin
38 | Demelza,Robins,Gryffindor
39 | Newt,Scamander,Hufflepuff
40 | Horace,Slughorn,Slytherin
41 | Zacharias,Smith,Hufflepuff
42 | Severus,Snape,Slytherin
43 | Alicia,Spinnet,Gryffindor
44 | Pomona,Sprout,Hufflepuff
45 | Dean,Thomas,Gryffindor
46 | Romilda,Vane,Gryffindor
47 | Myrtle,Warren,Ravenclaw
48 | Fred,Weasley,Gryffindor
49 | George,Weasley,Gryffindor
50 | Ginny,Weasley,Gryffindor
51 | Percy,Weasley,Gryffindor
52 | Ron,Weasley,Gryffindor
53 | Oliver,Wood,Gryffindor
54 | Blaise,Zabini,Slytherin
55 | 


--------------------------------------------------------------------------------
/Final project/README.md:
--------------------------------------------------------------------------------
 1 |     #  AryansSpotifyTools
 2 |     #### Video Demo:  https://youtu.be/AjHZCiDU-Wk
 3 |     #### Description: A lightweight tool built in python enabling the user to access new features and extend existing spotify functionality not available on the native app. Currently this app is the earliest release version, but I certainly do intend to publish later updates and versions with more capabilities in the near future as I further work on this project.
 4 | 
 5 |     This was a wonderful experience as it was my first ever project built in python. I learnt how to use various libraries and API's and GUI tools and further learned how to think. I am enthusiastic to continue to develop more applications and software in python as my experience building my first project was exhilirating.
 6 | 
 7 |     The feature i was most looking forward to building when i first started developing this project was the shuffle feature. Being an avid spotify user, i noticed when i'm listening to my main playlist of around 2000 songs, my playlist doesn't really shuffle. I just have to listen to the same songs over and over and I probably get to listen to a couple hundred different songs (bold assumption) while my playlist has thousands of tracks to play!
 8 | 
 9 |     Current Features: Login, View Playlists, View songs in playlist, Shuffle Playlists, Logout, Display playlist information, Display basic user information
10 | 
11 |     Features to be implemented: A more secure approach to logging in, Mini-Player, Sort playlists by genre (& other sorting parameters), Visualiser, Random song playback, Display secondary user information, a more polished and optimised user interface and experience and more...
12 | 
13 |     github/AryansSpotifyTools


--------------------------------------------------------------------------------
/week6/scourgify/before.csv:
--------------------------------------------------------------------------------
 1 | name,house
 2 | "Abbott, Hannah",Hufflepuff
 3 | "Bell, Katie",Gryffindor
 4 | "Bones, Susan",Hufflepuff
 5 | "Boot, Terry",Ravenclaw
 6 | "Brown, Lavender",Gryffindor
 7 | "Bulstrode, Millicent",Slytherin
 8 | "Chang, Cho",Ravenclaw
 9 | "Clearwater, Penelope",Ravenclaw
10 | "Crabbe, Vincent",Slytherin
11 | "Creevey, Colin",Gryffindor
12 | "Creevey, Dennis",Gryffindor
13 | "Diggory, Cedric",Hufflepuff
14 | "Edgecombe, Marietta",Ravenclaw
15 | "Finch-Fletchley, Justin",Hufflepuff
16 | "Finnigan, Seamus",Gryffindor
17 | "Goldstein, Anthony",Ravenclaw
18 | "Goyle, Gregory",Slytherin
19 | "Granger, Hermione",Gryffindor
20 | "Johnson, Angelina",Gryffindor
21 | "Jordan, Lee",Gryffindor
22 | "Longbottom, Neville",Gryffindor
23 | "Lovegood, Luna",Ravenclaw
24 | "Lupin, Remus",Gryffindor
25 | "Malfoy, Draco",Slytherin
26 | "Malfoy, Scorpius",Slytherin
27 | "Macmillan, Ernie",Hufflepuff
28 | "McGonagall, Minerva",Gryffindor
29 | "Midgen, Eloise",Gryffindor
30 | "McLaggen, Cormac",Gryffindor
31 | "Montague, Graham",Slytherin
32 | "Nott, Theodore",Slytherin
33 | "Parkinson, Pansy",Slytherin
34 | "Patil, Padma",Gryffindor
35 | "Patil, Parvati",Gryffindor
36 | "Potter, Harry",Gryffindor
37 | "Riddle, Tom",Slytherin
38 | "Robins, Demelza",Gryffindor
39 | "Scamander, Newt",Hufflepuff
40 | "Slughorn, Horace",Slytherin
41 | "Smith, Zacharias",Hufflepuff
42 | "Snape, Severus",Slytherin
43 | "Spinnet, Alicia",Gryffindor
44 | "Sprout, Pomona",Hufflepuff
45 | "Thomas, Dean",Gryffindor
46 | "Vane, Romilda",Gryffindor
47 | "Warren, Myrtle",Ravenclaw
48 | "Weasley, Fred",Gryffindor
49 | "Weasley, George",Gryffindor
50 | "Weasley, Ginny",Gryffindor
51 | "Weasley, Percy",Gryffindor
52 | "Weasley, Ron",Gryffindor
53 | "Wood, Oliver",Gryffindor
54 | "Zabini, Blaise",Slytherin
55 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | > ## ⭐ Feel free to star this repository if it was helpful!
 2 | 
 3 | <br>
 4 | 
 5 | # Harvard CS50 Python Problem Sets
 6 | 
 7 | Welcome to the Harvard CS50 Python Problem Sets repository! This repository contains my solutions to the problem sets for CS50's Introduction to Computer Science using Python. This course is offered by Harvard University through edX.
 8 | 
 9 | ## Table of Contents
10 | - [Course Information](#course-information)
11 | - [Problem Sets](#problem-sets)
12 | - [Usage](#usage)
13 | - [License](#license)
14 | 
15 | ## Course Information
16 | - **Course Name:** CS50’s Introduction to Programming with Python
17 | - **Instructor:** David J. Malan
18 | - **Platform:** edX
19 | - **Course URL:** [CS50's Introduction to Computer Science](https://cs50.harvard.edu/python/2022/)
20 | 
21 | ## Problem Sets
22 | This repository contains my solutions to the problem sets for each week of the course. Here's a list of the problem sets available:
23 | 
24 | - [Week 0: Functions, Variables](week0/)
25 | - [Week 1: Conditionals](week1/)
26 | - [Week 2: Loops](week2/)
27 | - [Week 3: Exceptions](week3/)
28 | - [Week 4: Libraries](week4/)
29 | - [Week 5: Unit Tests](week5/)
30 | - [Week 6: File I/O](week6/)
31 | - [Week 7: Regular Expressions](week7/)
32 | - [Week 8: Object-Oriented Programming](week8/)
33 | - [Week 9: Et Cetera (Final Project)](Final%20project/)
34 | 
35 | ## Usage
36 | To use this repository, follow these steps:
37 | 
38 | 1. Clone the repository to your local machine using the following command:
39 | 
40 | ```git clone https://github.com/aryanranderiya/cs50-python```
41 | 
42 | 2. Navigate to the specific problem set folder you're interested in, e.g., week0, week1, etc.
43 | 
44 | 3. Review the Python code and any accompanying documentation to understand the solution.
45 | 
46 | 4. Feel free to use the code as a reference, but remember the CS50 academic honesty policy if you are currently enrolled in the course.
47 | 
48 | ## License
49 | 
50 | This repository is licensed under the MIT License. Feel free to use, modify, and distribute the code as long as you include the original license file and provide appropriate attribution.
51 | 


--------------------------------------------------------------------------------
/Final project/project.py:
--------------------------------------------------------------------------------
  1 | import tkinter as tk
  2 | from tkinter import messagebox
  3 | from tkinter import ttk
  4 | import requests
  5 | from spotipy import Spotify, SpotifyException
  6 | from spotipy.oauth2 import SpotifyOAuth
  7 | import base64
  8 | from PIL import ImageTk, Image, ImageDraw
  9 | from io import BytesIO
 10 | import cachetools
 11 | import random
 12 | import threading
 13 | import time
 14 | 
 15 | def revoke_access_token(access_token, client_id, client_secret):
 16 |     if access_token:
 17 |         revocation_url = "https://accounts.spotify.com/api/token"
 18 |         headers = {
 19 |             "Authorization": f"Basic {get_base64_encoded_credentials(client_id, client_secret)}"
 20 |         }
 21 |         data = {"token": access_token}
 22 |         response = requests.post(revocation_url, data=data, headers=headers)
 23 |         print(response.status_code)
 24 |         return True
 25 |     else:
 26 |         return False
 27 | 
 28 | def get_base64_encoded_credentials(client_id, client_secret):
 29 |     credentials = f"{client_id}:{client_secret}"
 30 |     return base64.b64encode(credentials.encode()).decode()
 31 | 
 32 | def fetch_all_songs(playlist_uri, sp, song_cache):
 33 |     if playlist_uri in song_cache:
 34 |         return len(song_cache[playlist_uri])
 35 | 
 36 |     all_tracks = []
 37 | 
 38 |     playlist_tracks = sp.playlist_tracks(playlist_uri)
 39 |     display_progress_dialog("Loading Songs...")
 40 |     progress_dialog.update_idletasks()
 41 | 
 42 |     while playlist_tracks:
 43 |         all_tracks.extend(playlist_tracks["items"])
 44 | 
 45 |         next_page = playlist_tracks["next"]
 46 |         if not next_page:
 47 |             close_progress_dialog()
 48 |             break
 49 | 
 50 |         playlist_tracks = sp.next(playlist_tracks)
 51 |         number_of_loaded_tracks = len(all_tracks)
 52 |         label_songs_loaded.config(text=f"Loading Songs... {number_of_loaded_tracks}")
 53 |         progress_dialog.update_idletasks()
 54 | 
 55 |     song_cache[playlist_uri] = all_tracks
 56 | 
 57 |     return all_tracks
 58 | 
 59 | def display_progress_dialog(title):
 60 |     global progress_dialog
 61 |     progress_dialog = tk.Toplevel(window)
 62 |     progress_dialog.title(title)
 63 |     progress_dialog.geometry("300x100")
 64 | 
 65 |     global label_songs_loaded
 66 |     label_songs_loaded = tk.Label(progress_dialog,text=title + " 0")
 67 |     global progress_bar
 68 |     progress_bar = ttk.Progressbar(progress_dialog,orient=tk.HORIZONTAL, length=220, mode="indeterminate")
 69 |     progress_bar.pack(pady=20)
 70 |     progress_bar.start
 71 |     label_songs_loaded.pack()
 72 | 
 73 | def close_progress_dialog():
 74 |     global progress_dialog
 75 |     if progress_dialog:
 76 |         progress_bar.stop
 77 |         progress_dialog.destroy()
 78 | 
 79 | class SpotifyToolsApp:
 80 |     def __init__(self, window):
 81 |         self.window = window
 82 |         window.title("Spotify Login")
 83 | 
 84 |         self.CLIENT_ID = "58817dcd8cc54baa9dd033ea9ef0f86f"
 85 |         self.CLIENT_SECRET = "8fe689bda9e64b3d8b4e111301cf6a44"
 86 |         self.REDIRECT_URI = "http://localhost:8888/callback"
 87 | 
 88 |         self.playlists = {}
 89 |         self.playlist_uris = {}
 90 |         self.text_num_song = ""
 91 |         self.song_cache = cachetools.LRUCache(maxsize=10000)
 92 | 
 93 |         self.frame_login = tk.Frame(self.window, width=500, height=400)
 94 |         self.frame_home = tk.Frame(self.window, width=500, height=400)
 95 |         self.frame_view_playlist = tk.Frame(self.window, width=500, height=400)
 96 |         self.frame_view_all_playlists = tk.Frame(self.window, width=500, height=300)
 97 |         self.frame_view_playlist_songs = tk.Frame(self.window, width=500, height=400)
 98 | 
 99 |         self.progress_dialog = None
100 | 
101 |         self.label_number_of_songs = tk.Label(self.frame_view_playlist)
102 |         self.label_playlist_image = tk.Label(self.frame_view_playlist)
103 |         self.label_playlist_name = tk.Label(self.frame_view_playlist)
104 |         self.label_welcome_title = tk.Label(self.frame_login)
105 |         self.label_user_profile_image = tk.Label(self.frame_home)
106 |         self.label_user_profile_name = tk.Label(self.frame_home)
107 |         self.label_image_logo = tk.Label(self.frame_login)
108 | 
109 |         self.listbox_playlists = tk.Listbox(self.frame_view_all_playlists)
110 |         self.scrollbar_playlists = tk.Scrollbar(self.window, command=self.listbox_playlists.yview)
111 |         self.listbox_playlists.config(yscrollcommand=self.scrollbar_playlists.set)
112 | 
113 |         self.listbox_view_songs = tk.Listbox(self.frame_view_playlist_songs)
114 |         self.scrollbar_songs = tk.Scrollbar(self.window, command=self.listbox_view_songs.yview)
115 |         self.listbox_view_songs.config(yscrollcommand=self.scrollbar_songs.set)
116 | 
117 |         self.button_login = tk.Button(self.frame_login, text="Login to Spotify")
118 |         self.button_logout = tk.Button(self.frame_home)
119 |         self.button_view_playlists = tk.Button(self.frame_home, text="View Playlists")
120 |         self.button_back_home = tk.Button(self.frame_view_all_playlists, text="Home")
121 |         self.button_back_view_playlists = tk.Button(self.frame_view_playlist, text="Back")
122 |         self.button_back_view_playlist = tk.Button(self.frame_view_playlist_songs, text="Back to Playlist")
123 |         self.button_shuffle_playlist = tk.Button(self.frame_view_playlist, text="Shuffle Playlist")
124 |         self.button_view_songs = tk.Button(self.frame_view_playlist,text="View Songs")
125 | 
126 |         self.login_screen()
127 | 
128 |     # initialisation method ends here ^^^^^
129 | 
130 |     def login_screen(self):
131 |         self.frame_login.pack_propagate(False)
132 |         self.frame_login.pack(fill=tk.BOTH, expand=True)
133 | 
134 |         original_image = Image.open("spotify_logo.png")
135 |         resized_image = original_image.resize((333, 100))
136 |         spotify_logo = ImageTk.PhotoImage(resized_image)
137 | 
138 |         self.label_image_logo.config(image=spotify_logo)
139 |         self.label_image_logo.image = spotify_logo
140 |         self.label_image_logo.grid(row=0, column=0, pady=(40, 10), padx=50)
141 | 
142 |         self.label_welcome_title.config(
143 |             text="Welcome to Aryan's SpotifyTools!",
144 |             font=("Helvetica", 20, "bold"),
145 |             foreground="#1ab26b")
146 |         self.label_welcome_title.grid(row=1, column=0, pady=(10, 20), padx=30)
147 | 
148 |         self.button_login.config(command=self.login_to_spotify)
149 |         self.button_login.grid(row=2, column=0, pady=(10, 40), padx=30)
150 | 
151 |     def login_to_spotify(self):
152 |         self.sp_oauth = SpotifyOAuth(
153 |             client_id=self.CLIENT_ID,
154 |             client_secret=self.CLIENT_SECRET,
155 |             redirect_uri=self.REDIRECT_URI,
156 |             scope="playlist-modify-private playlist-modify-public",
157 |             open_browser="true",
158 |             show_dialog="true",
159 |         )
160 |         self.access_token = self.sp_oauth.get_access_token()
161 |         self.sp = Spotify(auth=self.access_token["access_token"])
162 |         self.user = self.sp.current_user()
163 | 
164 |         if self.access_token and "access_token" in self.access_token:
165 |             print(f"Logged in as: {self.user['display_name']}")
166 |             self.frame_login.pack_forget()
167 |             self.home_screen()
168 |         else:
169 |             messagebox.showerror("Error", "Connection Unsuccessful")
170 | 
171 |     def logout(self):
172 |         if self.access_token:
173 |             if revoke_access_token(self.access_token["access_token"], self.CLIENT_ID, self.CLIENT_SECRET):
174 |                 print("Access token revoked successfully.")
175 |                 self.frame_home.pack_forget()
176 |                 self.frame_login.pack()
177 |                 messagebox.showinfo("Success", "Successfully logged out!")
178 |             else:
179 |                 print("Failed to revoke access token.")
180 | 
181 |             self.user = None
182 |             self.access_token = None
183 |             self.sp = None
184 | 
185 |     def home_screen(self):
186 |         self.window.title("Home")
187 |         self.frame_home.grid_rowconfigure(0, weight=1)
188 |         self.frame_home.grid_columnconfigure(0, weight=1)
189 |         self.frame_home.pack_propagate(False)
190 |         self.frame_home.pack(fill=tk.BOTH, expand=True)
191 |         # self.button_back_home.pack_forget()
192 |         logout_icon = Image.open("logout_icon.png")
193 |         resized_logout_icon = logout_icon.resize((35, 35))
194 |         self.logout_icon = ImageTk.PhotoImage(resized_logout_icon)
195 | 
196 |         self.button_logout.config(image=self.logout_icon, command=self.logout)
197 |         self.button_logout.grid(row=1, column=3, pady=(50), padx=(10, 30))
198 | 
199 |         name, imageurl = self.fetch_user_details()
200 |         self.display_user_profile(name, imageurl)
201 | 
202 |     def fetch_user_details(self):
203 |         display_name = self.user["display_name"]
204 |         profile_image_url = (
205 |             self.user["images"][0]["url"] if self.user["images"] else None
206 |         )
207 | 
208 |         return display_name, profile_image_url
209 | 
210 |     def display_user_profile(self, name, image_url):
211 |         response = requests.get(image_url)
212 |         profile_image = Image.open(BytesIO(response.content))
213 | 
214 |         width, height = profile_image.size
215 |         mask = Image.new("L", (width, height), 0)
216 |         draw = ImageDraw.Draw(mask)
217 |         draw.ellipse((0, 0, width, height), fill=255)
218 | 
219 |         circular_image = Image.new("RGBA", (width, height))
220 |         circular_image.paste(profile_image, mask=mask)
221 |         self.user_image = ImageTk.PhotoImage(circular_image)
222 | 
223 |         self.label_user_profile_image.config(image=self.user_image)
224 |         self.label_user_profile_image.grid(row=1, column=0, pady=(50), padx=(30, 10))
225 | 
226 |         self.label_user_profile_name.config(
227 |             text=name, font=("Helvetica", 25), foreground="#000"
228 |         )
229 |         self.label_user_profile_name.grid(row=1, column=1, pady=(50), padx=(10, 10))
230 | 
231 |         self.button_view_playlists.config(command=self.view_playlists)
232 |         self.button_view_playlists.grid(row=2, column=0, pady=(10, 40), padx=30)
233 | 
234 |     def fetch_playlist_uri(self):
235 |         selected_index = self.listbox_playlists.curselection()
236 | 
237 |         if selected_index:
238 |             index = selected_index[0]
239 |             selected_item = self.listbox_playlists.get(index)
240 |             selected_playlist_uri = self.playlist_uris.get(selected_item, "")
241 |             return selected_playlist_uri
242 | 
243 |     def view_playlists(self):
244 |         self.window.title("View Playlists")
245 |         self.frame_home.pack_forget()
246 |         self.frame_view_all_playlists.pack(expand=True)
247 |         self.listbox_playlists.pack(
248 |             side="top", fill="both", expand=True, padx=20, pady=20
249 |         )
250 | 
251 |         self.button_back_home.config(command=lambda: self.go_back_home())
252 |         self.button_back_home.pack()
253 | 
254 |         if not self.playlists:
255 |             display_progress_dialog("Loading Playlists...")
256 |             self.fetch_playlists()
257 | 
258 |     def fetch_playlists(self):
259 |         self.playlists = self.sp.current_user_playlists()
260 | 
261 |         for playlist in self.playlists["items"]:
262 |             playlist_name = playlist["name"]
263 |             playlist_uri = playlist["uri"]
264 |             self.playlist_uris[playlist_name] = playlist_uri
265 | 
266 |         # self.listbox_playlists.delete(0, tk.END)
267 | 
268 |         for playlist_name in self.playlist_uris.keys():
269 |             self.listbox_playlists.insert(tk.END, playlist_name)
270 |             close_progress_dialog()
271 | 
272 |         self.scrollbar_playlists.pack(side="right", fill="y")
273 |         self.scrollbar_songs.pack_forget()
274 | 
275 |         self.listbox_playlists.bind("<ButtonRelease-1>", self.on_item_selected)
276 | 
277 |         close_progress_dialog()
278 | 
279 |     def on_item_selected(self, event):
280 |         self.frame_view_all_playlists.pack_forget()
281 |         self.scrollbar_playlists.pack_forget()
282 |         self.scrollbar_songs.pack_forget()
283 | 
284 |         selected_index = self.listbox_playlists.curselection()
285 |         if selected_index:
286 |             index = selected_index[0]
287 |             playlist_name = self.listbox_playlists.get(index)
288 |             # self.listbox_playlists.pack_forget()
289 |             self.window.title(f"Playlist: {playlist_name}")
290 |             self.frame_view_playlist.pack(fill=tk.BOTH, expand=True)
291 |             self.frame_view_playlist.pack_propagate(False)
292 | 
293 |             self.playlist_uri = self.fetch_playlist_uri()
294 | 
295 |             self.fetch_and_display_playlist_data(playlist_name)
296 | 
297 | 
298 |     def fetch_and_display_playlist_data(self, playlist_name):
299 |         all_fetched_tracks = fetch_all_songs(self.playlist_uri, self.sp, self.song_cache)
300 | 
301 |         self.results = self.sp.playlist_tracks(self.playlist_uri)
302 |         self.tracks = self.results["items"]
303 |         self.track_uris = [self.track["track"]["uri"] for self.track in self.tracks]
304 | 
305 |         while self.results["next"]:
306 |             self.results = self.sp.next(self.results)
307 |             self.tracks = self.results["items"]
308 |             self.track_uris.extend([self.track["track"]["uri"] for self.track in self.tracks])
309 | 
310 |         self.window.after(0, self.display_playlist_information, self.playlist_uri, playlist_name, all_fetched_tracks)
311 | 
312 |     def method_playlist_image(self):
313 |         self.playlist_image_url = (
314 |             self.playlist["images"][0]["url"] if self.playlist["images"] else None
315 |         )
316 | 
317 |         response = requests.get(self.playlist_image_url)
318 | 
319 |         original_image = Image.open(BytesIO(response.content))
320 |         resized_image = original_image.resize((100, 100))
321 |         playlist_image = ImageTk.PhotoImage(resized_image)
322 | 
323 |         width = playlist_image.width()
324 |         height = playlist_image.height()
325 | 
326 |         mask = Image.new("L", (width, height), 0)
327 |         draw = ImageDraw.Draw(mask)
328 |         draw.ellipse((0, 0, width, height), fill=255)
329 | 
330 |         circular_image = Image.new("RGBA", (width, height), (0, 0, 0, 0))
331 |         circular_image.paste(resized_image, mask=mask)
332 | 
333 |         self.playlist_image = ImageTk.PhotoImage(circular_image)
334 | 
335 |         self.label_playlist_image.config(image=self.playlist_image)
336 | 
337 | 
338 |     def display_playlist_information(self, playlist_uri, playlist_name, num_of_tracks):
339 | 
340 |         self.playlist = self.sp.playlist(playlist_uri)
341 | 
342 |         self.method_playlist_image()
343 | 
344 |         self.playlist_name = playlist_name
345 | 
346 |         self.button_shuffle_playlist.config(command=lambda: self.shuffle_playlist_songs())
347 |         self.button_back_view_playlists.config(command=lambda: self.go_back_view_playlists())
348 |         self.button_view_songs.config(command=lambda: self.view_songs_in_playlist())
349 | 
350 |         self.text_num_songs = "Number of songs: " + str(len(self.track_uris))
351 |         self.label_number_of_songs.config(text=self.text_num_songs)
352 |         self.label_playlist_name.config(text=self.playlist_name,font=("Helvetica", 30), foreground="#000")
353 | 
354 |         self.label_playlist_image.pack(anchor="n", pady=(30, 10))
355 |         self.label_playlist_name.pack(anchor="n")
356 |         self.label_number_of_songs.pack(anchor="n", pady=(10, 20))
357 |         self.button_shuffle_playlist.pack(anchor="n", pady=(0, 10))
358 |         self.button_view_songs.pack(anchor="n", pady=(0, 10))
359 | 
360 |         self.button_back_view_playlists.pack(anchor="n", pady=(0, 20))
361 | 
362 |     def view_songs_in_playlist(self):
363 |         self.frame_view_playlist_songs.pack()
364 |         self.frame_view_playlist.pack_forget()
365 |         self.listbox_view_songs.pack(anchor='n', padx=20, pady=20)
366 | 
367 |         self.scrollbar_songs.pack(side="right", fill="y")
368 |         self.scrollbar_playlists.pack_forget()
369 | 
370 |         self.button_back_view_playlist.config(command=lambda: self.go_back_view_playlist_info())
371 | 
372 |         self.button_back_view_playlist.pack(anchor='n')
373 | 
374 |         self.listbox_view_songs.delete(0, tk.END)
375 | 
376 |         def fetch_songs():
377 |             for track_uri in self.track_uris:
378 |                 track = self.sp.track(track_uri)
379 |                 track_name = track["name"]
380 |                 self.listbox_view_songs.insert(tk.END, track_name)
381 | 
382 |         song_thread = threading.Thread(target=fetch_songs)
383 |         song_thread.start()
384 | 
385 |     def go_back_view_playlist_info(self):
386 |         self.frame_view_playlist_songs.pack_forget()
387 |         self.frame_view_playlist.pack()
388 | 
389 |     def shuffle_playlist_songs(self):
390 | 
391 |         batch_size = 100
392 |         batches = [self.track_uris[i:i + batch_size] for i in range(0, len(self.track_uris), batch_size)]
393 | 
394 |         try:
395 |             random.shuffle(batches[0])
396 |             self.sp.playlist_replace_items(self.playlist_uri, batches[0])
397 | 
398 |             for batch in batches[1:]:
399 |                 random.shuffle(batch)
400 |                 self.sp.playlist_add_items(self.playlist_uri, batch)
401 | 
402 |             print("Playlist shuffled successfully.")
403 | 
404 |         except SpotifyException as e:
405 |             print(f"Error updating playlist: {str(e)}")
406 | 
407 |         print(f"Playlist Image URL: {self.playlist_image_url}")
408 |         time.sleep(2)
409 |         self.method_playlist_image()
410 |         print(f"Playlist Image URL: {self.playlist_image_url}")
411 | 
412 | 
413 |     def go_back_view_playlists(self):
414 |         self.frame_view_playlist.pack_forget()
415 |         self.frame_view_all_playlists.pack()
416 |         self.frame_view_all_playlists.pack_propagate(False)
417 |         self.playlist_image_url = "https://upload.wikimedia.org/wikipedia/commons/a/ac/Default_pfp.jpg"
418 |         self.playlist_name = None
419 |         self.text_num_songs = None
420 |         self.window.update_idletasks()
421 |         self.view_playlists()
422 | 
423 |     def go_back_home(self):
424 |         self.frame_view_all_playlists.pack_forget()
425 |         self.home_screen()
426 | 
427 | def main():
428 |     print(print_app_name)
429 |     global window
430 |     window = tk.Tk()
431 |     SpotifyToolsApp(window)
432 |     window.mainloop()
433 | 
434 | def print_app_name():
435 |     return "Welcome to AryanSpotifyTools!"
436 | 
437 | if __name__ == "__main__":
438 |     try:
439 |         main()
440 |     except KeyboardInterrupt:
441 |         print("\nKeyboard Interrupted Program Execution!")
442 | 


--------------------------------------------------------------------------------