diff --git a/.github/workflows/greetings.yml b/.github/workflows/greetings.yml index ecdc784..56a835c 100644 --- a/.github/workflows/greetings.yml +++ b/.github/workflows/greetings.yml @@ -21,7 +21,7 @@ jobs: We at Metafy have some special rewards and swags for the top contributors in general repos and every contributor in web3 repos For being eligible for that, please authenticate yourself using this link: - https://hacktoberfest.auth.metafy.social + https://metafy.social/signup Rewards : T-shirts & NFT ( for blockchain contributions ) @@ -34,7 +34,7 @@ jobs: We at Metafy have some special rewards and swags for the top contributors in general repos and every contributor in web3 repos For being eligible for that, please authenticate yourself using this link: - https://hacktoberfest.auth.metafy.social + https://metafy.social/signup Rewards : T-shirts & NFT ( for blockchain contributions ) diff --git a/README.md b/README.md index b527637..4a8c52f 100644 --- a/README.md +++ b/README.md @@ -80,14 +80,42 @@ Thanks a lot for spending your time helping! Keep rocking 🍻 Agnish Ghosh + + + SiddheshKukade +
+ Siddhesh Bhupendra Kuakde + + + + + + rahulkarda +
+ Rahul Karda + + + + + N00rAhmed +
+ Noor Ahmed + + + + + Khushi260 +
+ Khushi Jha + + muratonuryildirim
Murat Onur Yildirim - - + Ayudh-65 @@ -101,7 +129,8 @@ Thanks a lot for spending your time helping! Keep rocking 🍻
Vallabh Chugh - + + Abbhiishek @@ -123,14 +152,6 @@ Thanks a lot for spending your time helping! Keep rocking 🍻 Md Farhan Sajid - - - N00rAhmed -
- Noor Ahmed - - - HVbajoria @@ -145,19 +166,20 @@ Thanks a lot for spending your time helping! Keep rocking 🍻 Raihan Khan - - - SiddheshKukade -
- Siddhesh Bhupendra Kuakde - - ArshErgon
Mohd Arsh Ali + + + + + Kunalp02 +
+ Kunal Patil + @@ -172,8 +194,7 @@ Thanks a lot for spending your time helping! Keep rocking 🍻
Samuel Jonathan - - + shreyan-naskar @@ -188,20 +209,14 @@ Thanks a lot for spending your time helping! Keep rocking 🍻 Null - - - Khushi260 -
- Khushi Jha - - AFZL210
Mohd Afzal Khan - + + MSVelan @@ -209,14 +224,6 @@ Thanks a lot for spending your time helping! Keep rocking 🍻 Null - - - rahulkarda -
- Rahul Karda - - - kriptonian1 @@ -251,21 +258,14 @@ Thanks a lot for spending your time helping! Keep rocking 🍻
Null - + + Dishant10
Dishant Nagpal - - - - - Kunalp02 -
- Kunal Patil - @@ -281,6 +281,13 @@ Thanks a lot for spending your time helping! Keep rocking 🍻 Null + + + srishti011 +
+ Srishti + + Tiagupt03 @@ -294,6 +301,14 @@ Thanks a lot for spending your time helping! Keep rocking 🍻
Avyay Jain + + + + + devtayade +
+ Null + @@ -301,8 +316,7 @@ Thanks a lot for spending your time helping! Keep rocking 🍻
Drk1rd - - + lordvader501 @@ -310,6 +324,13 @@ Thanks a lot for spending your time helping! Keep rocking 🍻 Null + + + nabroleonx +
+ Abel Ayalew + + rohitgarud21 @@ -317,6 +338,14 @@ Thanks a lot for spending your time helping! Keep rocking 🍻 Null + + + smeax +
+ Null + + + tolgakurtuluss @@ -331,6 +360,13 @@ Thanks a lot for spending your time helping! Keep rocking 🍻 Srinjoy Pati + + + personal-use1 +
+ Null + + Shradha-Suman @@ -344,14 +380,21 @@ Thanks a lot for spending your time helping! Keep rocking 🍻
Nishant Pacharne - - + thegeekyb0y
Aditya Tiwari + + + + + Asmita-Dutta +
+ Null + @@ -374,21 +417,35 @@ Thanks a lot for spending your time helping! Keep rocking 🍻 Mayuri Kolhe + + + theadeyemiolayinka +
+ Olayinka Adeyemi + + parinzee
Parinthapat P. - + + iamrahul8
Rahul Kumar - - + + + + riyaroy2086 +
+ Riya Roy + + royninja @@ -396,6 +453,13 @@ Thanks a lot for spending your time helping! Keep rocking 🍻 Sayan Roy + + + shubhajitroy123 +
+ Shubhajit Roy + + Tanya-1109 @@ -403,6 +467,14 @@ Thanks a lot for spending your time helping! Keep rocking 🍻 Tanya Mohanka + + + YashIndane +
+ Yash Indane + + + ambushneupane @@ -430,8 +502,7 @@ Thanks a lot for spending your time helping! Keep rocking 🍻
Sauraj - - + accodes21 @@ -445,7 +516,8 @@ Thanks a lot for spending your time helping! Keep rocking 🍻
Aiman Aisha - + + akashJainAJ11 @@ -460,6 +532,13 @@ Thanks a lot for spending your time helping! Keep rocking 🍻 Arijit Ghosh + + + Yaswanth820 +
+ Balaji Yaswanth Vankala + + Danuragtiwari @@ -467,6 +546,13 @@ Thanks a lot for spending your time helping! Keep rocking 🍻 ANURAG TIWARI + + + dishant-yadav +
+ DISHANT YADAV + + donheshanthaka @@ -482,6 +568,13 @@ Thanks a lot for spending your time helping! Keep rocking 🍻 Gokul_Zuzu + + + KuSantosh100 +
+ KUMAR SANTOSH + + Manice18 @@ -503,13 +596,6 @@ Thanks a lot for spending your time helping! Keep rocking 🍻 Nikunj R. Prajapati - - - theadeyemiolayinka -
- Olayinka Adeyemi - - Morbius00 @@ -596,21 +682,14 @@ Thanks a lot for spending your time helping! Keep rocking 🍻 Rohit Purkait - - - devtayade -
- Null - - - yashbrid03
Yash Nilesh Brid - + + mclmza @@ -632,21 +711,13 @@ Thanks a lot for spending your time helping! Keep rocking 🍻 Mubeen Ahmad - - - nabroleonx -
- Abel Ayalew - - neocollege
Prathamesh Nayak - - + smit-sms @@ -660,7 +731,8 @@ Thanks a lot for spending your time helping! Keep rocking 🍻
Sameer Sahu - + + shatanikmahanty diff --git a/scripts/Base_Conversion/README.md b/scripts/Base_Conversion/README.md deleted file mode 100644 index 51f0e31..0000000 --- a/scripts/Base_Conversion/README.md +++ /dev/null @@ -1,8 +0,0 @@ -# BASE CONVERSION IN PYTHON -- Various functions for interconversion of bases -- Conversion of Binary to Decimal -- Conversion of Octal to Decimal -- Conversion of Hexadecimal to Decimal -- Conversion of Decimal to Binary -- Conversion of Decimal to Octal -- Conversion of Decimal to Hexaecimal \ No newline at end of file diff --git a/scripts/Base_Conversion/main.py b/scripts/Base_Conversion/main.py deleted file mode 100644 index 8fe0a0f..0000000 --- a/scripts/Base_Conversion/main.py +++ /dev/null @@ -1,162 +0,0 @@ - -#Function to calculate x raised to the power y -def Power( x , y ) : - - if (y == 0) : - return 1 - - else : - - ans = x**y - return ans - - -#Function to convert Binary to Decimal -def BinaryToDecimal( n ) : - - ans = 0 - x = 1 - m = int(n) - - while m > 0 : - b = m%10 - ans += b*x - x = x*2 - m = m//10 - - return ans - - -#Function to convert Octal to Decimal -def OctalToDecimal( n ) : - - ans = 0 - x = 1 - m = int(n) - - while m > 0 : - b = m%10 - ans += b*x - x = x*8 - m = m//10 - - return ans - - -#Function to convert Hexadecimal to Decimal -def HexadecimalToDecimal( n ): - - ans = 0 - x = 1 - s = len( n ) - - for i in range( s-1 , -1 , -1 ) : - if n[i] >= '0' and n[i] <= '9' : - ans += x*(int(n[i])) - - elif n[i] >= 'A' and n[i] <= 'F' : - ans += x*(ord(n[i]) - ord('A') + 10) - - x = x*16 - - return ans - - -#Function to convert Decimal to Binary -def DecimalToBinary( n ) : - L = [] - while(n>0): - rem = n%2 - L.append(rem) - n = n//2 - #L = L[::-1] - - dec = 0 - for i in range(0,len(L)): - dec = dec + L[i]*(10**i) - - return dec - -#Function to convert Decimal to Octal -def DecimalToOctal( n ) : - - ans = 0 - count = 0 - - while (n > 0) : - lastDigit = n%8 - ans += lastDigit*(10**(count)) - n = n//8 - - count += 1 - - return ans - - -#Function to convert Decimal to Hexadecimal -def DecimaltoHexadecimal( n ) : - - ans = '' - - while (n > 0) : - lastDigit = n%16 - if (lastDigit >= 0 and lastDigit <=9 ) : - ans = ans + str(lastDigit) - - elif (lastDigit >= 10 and lastDigit <= 15) : - a = chr(ord('A') + (lastDigit-10)) - ans = ans + a - - n = n//16 - - return ans[::-1] - -while True: - print('1 -> Calculate Exponents') - print('2 -> convert Binary to Decimal ') - print('3 -> convert Octal to Decimal ') - print('4 -> convert Hexadecimal to Decimal ') - print('5 -> convert Decimal to Binary ') - print('6 -> convert Decimal to Octal ') - print('7 -> convert Decimal to Hexadecimal ') - print('0 -> Exit') - - - n = int(input('\nEnter: ')) - - if n == 1: - a,b = int(input("Enter Base :\n")),int(input("Enter Superscript : \n")) - print("The result is : ",Power(a,b), "\n") - - elif n == 2: - b = int(input("Enter Binary Number:\n")) - print("Corresponding Decimal Number is : ", BinaryToDecimal(b), "\n") - - elif n == 3: - b = int(input("Enter Octal Number:\n")) - print("Corresponding Decimal Number is : ", OctalToDecimal(b), "\n") - - elif n == 4: - b = (input("Enter Hexadecimal Number:\n")) - print("Corresponding Decimal Number is : ", HexadecimalToDecimal(b), "\n") - - elif n == 5: - b = int(input("Enter Decimal Number:\n")) - print("Corresponding Binary Number is : ", DecimalToBinary(b), "\n") - - elif n == 6: - b = int(input("Enter Decimal Number:\n")) - print("Corresponding Octal Number is : ", DecimalToOctal(b), "\n") - - elif n == 7: - b = int(input("Enter Decimal Number:\n")) - print("Corresponding Hexadecimal Number is : ", DecimaltoHexadecimal(b), "\n") - - elif n == 0: - - exit() - - else: - print("\nNo such option exists!! ") - - diff --git a/scripts/Brick-Breaker-Python/README.md b/scripts/Brick-Breaker-Python/README.md new file mode 100644 index 0000000..bb1a550 --- /dev/null +++ b/scripts/Brick-Breaker-Python/README.md @@ -0,0 +1,4 @@ +# Brick-Breaker-Python +Brick breaker game in which there is a ball that bounces of a platform to break a brick wall and the player has to keep the ball going by making sure the paddle is always there to bounce off the ball back. + +The game will have three layers of bricks, and each layer of brick will have a different hit capacity, which means some bricks will break in a single hit, some will require a double hit and some will require three hits. diff --git a/scripts/Brick-Breaker-Python/main.py b/scripts/Brick-Breaker-Python/main.py new file mode 100644 index 0000000..009060b --- /dev/null +++ b/scripts/Brick-Breaker-Python/main.py @@ -0,0 +1,229 @@ +import pygame +import math + +pygame.init() + +WIDTH, HEIGHT = 800, 600 +win = pygame.display.set_mode((WIDTH, HEIGHT)) +pygame.display.set_caption("Brick Breaker") + +FPS = 60 +PADDLE_WIDTH = 100 +PADDLE_HEIGHT = 15 +BALL_RADIUS = 10 + +LIVES_FONT = pygame.font.SysFont("comicsans", 40) + + +class Paddle: + VEL = 5 + + def __init__(self, x, y, width, height, color): + self.x = x + self.y = y + self.width = width + self.height = height + self.color = color + + def draw(self, win): + pygame.draw.rect( + win, self.color, (self.x, self.y, self.width, self.height)) + + def move(self, direction=1): + self.x = self.x + self.VEL * direction + + +class Ball: + VEL = 5 + + def __init__(self, x, y, radius, color): + self.x = x + self.y = y + self.radius = radius + self.color = color + self.x_vel = 0 + self.y_vel = -self.VEL + + def move(self): + self.x += self.x_vel + self.y += self.y_vel + + def set_vel(self, x_vel, y_vel): + self.x_vel = x_vel + self.y_vel = y_vel + + def draw(self, win): + pygame.draw.circle(win, self.color, (self.x, self.y), self.radius) + + +class Brick: + def __init__(self, x, y, width, height, health, colors): + self.x = x + self.y = y + self.width = width + self.height = height + self.health = health + self.max_health = health + self.colors = colors + self.color = colors[0] + + def draw(self, win): + pygame.draw.rect( + win, self.color, (self.x, self.y, self.width, self.height)) + + def collide(self, ball): + if not (ball.x <= self.x + self.width and ball.x >= self.x): + return False + if not (ball.y - ball.radius <= self.y + self.height): + return False + + self.hit() + ball.set_vel(ball.x_vel, ball.y_vel * -1) + return True + + def hit(self): + self.health -= 1 + self.color = self.interpolate( + *self.colors, self.health/self.max_health) + + @staticmethod + def interpolate(color_a, color_b, t): + # 'color_a' and 'color_b' are RGB tuples + # 't' is a value between 0.0 and 1.0 + # this is a naive interpolation + return tuple(int(a + (b - a) * t) for a, b in zip(color_a, color_b)) + + +def draw(win, paddle, ball, bricks, lives): + win.fill("white") + paddle.draw(win) + ball.draw(win) + + for brick in bricks: + brick.draw(win) + + lives_text = LIVES_FONT.render(f"Lives: {lives}", 1, "black") + win.blit(lives_text, (10, HEIGHT - lives_text.get_height() - 10)) + + pygame.display.update() + + +def ball_collision(ball): + if ball.x - BALL_RADIUS <= 0 or ball.x + BALL_RADIUS >= WIDTH: + ball.set_vel(ball.x_vel * -1, ball.y_vel) + if ball.y + BALL_RADIUS >= HEIGHT or ball.y - BALL_RADIUS <= 0: + ball.set_vel(ball.x_vel, ball.y_vel * -1) + + +def ball_paddle_collision(ball, paddle): + if not (ball.x <= paddle.x + paddle.width and ball.x >= paddle.x): + return + if not (ball.y + ball.radius >= paddle.y): + return + + paddle_center = paddle.x + paddle.width/2 + distance_to_center = ball.x - paddle_center + + percent_width = distance_to_center / paddle.width + angle = percent_width * 90 + angle_radians = math.radians(angle) + + x_vel = math.sin(angle_radians) * ball.VEL + y_vel = math.cos(angle_radians) * ball.VEL * -1 + + ball.set_vel(x_vel, y_vel) + + +def generate_bricks(rows, cols): + gap = 2 + brick_width = WIDTH // cols - gap + brick_height = 20 + + bricks = [] + for row in range(rows): + for col in range(cols): + brick = Brick(col * brick_width + gap * col, row * brick_height + + gap * row, brick_width, brick_height, 2, [(0, 255, 0), (255, 0, 0)]) + bricks.append(brick) + + return bricks + + +def main(): + clock = pygame.time.Clock() + + paddle_x = WIDTH/2 - PADDLE_WIDTH/2 + paddle_y = HEIGHT - PADDLE_HEIGHT - 5 + paddle = Paddle(paddle_x, paddle_y, PADDLE_WIDTH, PADDLE_HEIGHT, "black") + ball = Ball(WIDTH/2, paddle_y - BALL_RADIUS, BALL_RADIUS, "black") + + bricks = generate_bricks(3, 10) + lives = 3 + + def reset(): + paddle.x = paddle_x + paddle.y = paddle_y + ball.x = WIDTH/2 + ball.y = paddle_y - BALL_RADIUS + + + def display_text(text): + text_render = LIVES_FONT.render(text, 1, "red") + win.blit(text_render, (WIDTH/2 - text_render.get_width() / + 2, HEIGHT/2 - text_render.get_height()/2)) + pygame.display.update() + pygame.time.delay(3000) + + run = True + while run: + clock.tick(FPS) + + for event in pygame.event.get(): + if event.type == pygame.QUIT: + run = False + break + + keys = pygame.key.get_pressed() + + if keys[pygame.K_LEFT] and paddle.x - paddle.VEL >= 0: + paddle.move(-1) + if keys[pygame.K_RIGHT] and paddle.x + paddle.width + paddle.VEL <= WIDTH: + paddle.move(1) + + ball.move() + ball_collision(ball) + ball_paddle_collision(ball, paddle) + + for brick in bricks[:]: + brick.collide(ball) + + if brick.health <= 0: + bricks.remove(brick) + + # lives check + if ball.y + ball.radius >= HEIGHT: + lives -= 1 + ball.x = paddle.x + paddle.width/2 + ball.y = paddle.y - BALL_RADIUS + ball.set_vel(0, ball.VEL * -1) + + if lives <= 0: + bricks = generate_bricks(3, 10) + lives = 3 + reset() + display_text("You Lost!") + + if len(bricks) == 0: + bricks = generate_bricks(3, 10) + lives = 3 + reset() + display_text("You Won!") + + draw(win, paddle, ball, bricks, lives) + + pygame.quit() + quit() + + +if __name__ == "__main__": + main() diff --git a/scripts/Caeser_Cipher_sage/README.md b/scripts/Caeser_Cipher_sage/README.md new file mode 100644 index 0000000..69da04a --- /dev/null +++ b/scripts/Caeser_Cipher_sage/README.md @@ -0,0 +1,10 @@ +## Caeser Cipher files ADDED #348 + +## Caeser Cipher +Easilly Generate Caecer Cipher equivalent for any text + + +## Installation +- Clone the repo +- download the requirements +- run `python cc.py` diff --git a/scripts/Caeser_Cipher_sage/cc.py b/scripts/Caeser_Cipher_sage/cc.py new file mode 100644 index 0000000..9bb3224 --- /dev/null +++ b/scripts/Caeser_Cipher_sage/cc.py @@ -0,0 +1,62 @@ +# @author https://github.com/theadeyemiolayinka + +from statistics import mode + + +class Caesar(): + + def __init__(self): + self.LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + self.translated = '' + + def __crypt(self, mode): + for symbol in self.message.upper(): + if symbol in self.LETTERS: + num = self.LETTERS.find(symbol) + if mode == 'encrypt': + num = num + self.key + elif mode == 'decrypt': + num = num - self.key + + if num >= len(self.LETTERS): + num = num - len(self.LETTERS) + elif num < 0: + num = num + len(self.LETTERS) + + self.translated = self.translated + self.LETTERS[num] + else: + self.translated = self.translated + symbol + + return self.translated + + def encrypt(self, message, key=0): + self.translated = '' + self.key = key + self.message = message + return self.__crypt('encrypt') + + def decrypt(self, message, key=0): + self.translated = '' + self.key = key + self.message = message + return self.__crypt('decrypt') + +def invokeCipher(cipher, key, text, e_mode): + if e_mode == 'E' or e_mode == 'e': + print('\n====================RESULT====================') + return cipher.encrypt(text, key) + elif e_mode == 'D' or e_mode == 'd': + print('\n====================RESULT====================') + return cipher.decrypt(text, key) + else: + print('Ivalid mode.') + n_mode = str(input("Enter mode: [E] for encryption and [D] for decryption:\n>")) + return invokeCipher(cipher, key, text, n_mode) + +cipher = Caesar() +key = int(input('Enter encryption key:\n>')) +text = str(input('Enter text:\n>')) +e_mode = str(input("Enter mode: [E] for encryption and [D] for decryption:\n>")) + +print(invokeCipher(cipher, key, text, e_mode)) +print('==============================================') diff --git a/scripts/Calculate_your_age_script/script.py b/scripts/Calculate_your_age_script/script.py new file mode 100644 index 0000000..50ac689 --- /dev/null +++ b/scripts/Calculate_your_age_script/script.py @@ -0,0 +1,48 @@ +import time +from calendar import isleap + +# judge the leap year +def judge_leap_year(year): + if isleap(year): + return True + else: + return False + + +# returns the number of days in each month +def month_days(month, leap_year): + if month in [1, 3, 5, 7, 8, 10, 12]: + return 31 + elif month in [4, 6, 9, 11]: + return 30 + elif month == 2 and leap_year: + return 29 + elif month == 2 and (not leap_year): + return 28 + + +name = input("input your name: ") +age = input("input your age: ") +localtime = time.localtime(time.time()) + +year = int(age) +month = year * 12 + localtime.tm_mon +day = 0 + +begin_year = int(localtime.tm_year) - year +end_year = begin_year + year + +# calculate the days +for y in range(begin_year, end_year): + if (judge_leap_year(y)): + day = day + 366 + else: + day = day + 365 + +leap_year = judge_leap_year(localtime.tm_year) +for m in range(1, localtime.tm_mon): + day = day + month_days(m, leap_year) + +day = day + localtime.tm_mday +print("%s's age is %d years or " % (name, year), end="") +print("%d months or %d days" % (month, day)) \ No newline at end of file diff --git a/scripts/Confusion_Matrix/README.md b/scripts/Confusion_Matrix/README.md new file mode 100644 index 0000000..30c0c4f --- /dev/null +++ b/scripts/Confusion_Matrix/README.md @@ -0,0 +1,25 @@ +The function makes a labelled confusion matrix comparing predictions and ground truth labels. + +If classes is passed, confusion matrix will be labelled, if not, integer class values will be used. + +Args: + +* `y_true`: Array of truth labels (must be same shape as y_pred). +* `y_pred`: Array of predicted labels (must be same shape as y_true). +* `classes`: Array of class labels (e.g. string form). If `None`, integer labels are used. +* `figsize`: Size of output figure (default=(10, 10)). +* `text_size`: Size of output figure text (default=15). +* `norm`: normalize values or not (default=False). +* `savefig`: save confusion matrix to file (default=False). + +Returns: A labelled confusion matrix plot comparing y_true and y_pred. + +### Example usage: + +> """make_confusion_matrix(y_true=test_labels, # ground truth test labels + y_pred=y_preds, # predicted labels + classes=class_names, # array of class label names + figsize=(15, 15), + text_size=10)""" + +#### CODE BY ZeroToMastery TensorFlow course. diff --git a/scripts/Confusion_Matrix/make_confusion_matrix.py b/scripts/Confusion_Matrix/make_confusion_matrix.py new file mode 100644 index 0000000..635e723 --- /dev/null +++ b/scripts/Confusion_Matrix/make_confusion_matrix.py @@ -0,0 +1,54 @@ +import itertools +import matplotlib.pyplot as plt +import numpy as np +from sklearn.metrics import confusion_matrix + +def make_confusion_matrix(y_true, y_pred, classes=None, figsize=(10, 10), text_size=15, norm=False, savefig=False): + # Create the confustion matrix + cm = confusion_matrix(y_true, y_pred) + cm_norm = cm.astype("float") / cm.sum(axis=1)[:, np.newaxis] # normalize it + n_classes = cm.shape[0] # find the number of classes we're dealing with + + # Plot the figure and make it pretty + fig, ax = plt.subplots(figsize=figsize) + cax = ax.matshow(cm, cmap=plt.cm.Blues) # colors will represent how 'correct' a class is, darker == better + fig.colorbar(cax) + + # Are there a list of classes? + if classes: + labels = classes + else: + labels = np.arange(cm.shape[0]) + + # Label the axes + ax.set(title="Confusion Matrix", + xlabel="Predicted label", + ylabel="True label", + xticks=np.arange(n_classes), # create enough axis slots for each class + yticks=np.arange(n_classes), + xticklabels=labels, # axes will labeled with class names (if they exist) or ints + yticklabels=labels) + + # Make x-axis labels appear on bottom + ax.xaxis.set_label_position("bottom") + ax.xaxis.tick_bottom() + + # Set the threshold for different colors + threshold = (cm.max() + cm.min()) / 2. + + # Plot the text on each cell + for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])): + if norm: + plt.text(j, i, f"{cm[i, j]} ({cm_norm[i, j]*100:.1f}%)", + horizontalalignment="center", + color="white" if cm[i, j] > threshold else "black", + size=text_size) + else: + plt.text(j, i, f"{cm[i, j]}", + horizontalalignment="center", + color="white" if cm[i, j] > threshold else "black", + size=text_size) + + # Save the figure to the current working directory + if savefig: + fig.savefig("confusion_matrix.png") \ No newline at end of file diff --git a/scripts/Copy to clipboard/README.md b/scripts/Copy to clipboard/README.md new file mode 100644 index 0000000..3948af5 --- /dev/null +++ b/scripts/Copy to clipboard/README.md @@ -0,0 +1,6 @@ +# Copy to Clipboard +A tool that will help you to copy the contents of a file having any size without opening that file +## Usage/Examples +```sh +$ clipboard.py +``` diff --git a/scripts/Copy to clipboard/clipboard.py b/scripts/Copy to clipboard/clipboard.py new file mode 100644 index 0000000..1742b1e --- /dev/null +++ b/scripts/Copy to clipboard/clipboard.py @@ -0,0 +1,29 @@ +import os +import sys +import platform +import subprocess + +# Seeing if the file exists +if os.path.exists(sys.argv[1]): + # Open Only if the file exists on the computer + f = open(sys.argv[1], "r") + # Storing the Content of the file in the f_contents variable + f_contents = f.read() + # closing the opened file + f.close() +else: + # If the file Doesn't Exists + print("File Not found : copy2clip ") + exit(1) +# Storing the current OS version +whatos = platform.system() +# If Darwin or Ubuntu +if whatos == "Darwin": + subprocess.run("pbcopy", universal_newlines=True, input=f_contents) + print("success: copied to clipboard") +# If Windows +elif whatos == "Windows": + subprocess.run("clip", universal_newlines=True, input=f_contents) + print("success: copied to clipboard") +else: + print("failed: clipboard not supported") diff --git a/scripts/Dice Roll/main.py b/scripts/Dice Roll/main.py new file mode 100644 index 0000000..99e3369 --- /dev/null +++ b/scripts/Dice Roll/main.py @@ -0,0 +1,10 @@ +import random +b=input("Do you want to roll the dice?y/n: ") +if b=='y': + a=int(input("Number of times you want to roll: ")) + print("Result: ") + for i in range(0,a): + ans=random.randint(1,6) + print(i+1,".",ans) +else: + print("Good Bye!") \ No newline at end of file diff --git a/scripts/Dice Roll/readme.md b/scripts/Dice Roll/readme.md new file mode 100644 index 0000000..eb0ebb6 --- /dev/null +++ b/scripts/Dice Roll/readme.md @@ -0,0 +1,5 @@ +Dice Roll Game with PYTHON + +#Steps : +Run - python main.py +Have a fun time!! diff --git a/scripts/Extract_TEXT_FROM_IMAGE/README.md b/scripts/Extract_TEXT_FROM_IMAGE/README.md new file mode 100644 index 0000000..6c029cf --- /dev/null +++ b/scripts/Extract_TEXT_FROM_IMAGE/README.md @@ -0,0 +1,16 @@ +# Extract text from image + +This script extracts text from an image using the EasyOCR library. +It can support multiple languages. + +## Usage + +1. Create a virtual environment +2. Install the requirements - `pip install -r requirements.txt` +3. Run the script - `python main.py` + +## Output + +Output will be printed to console. + +Happy coding!! \ No newline at end of file diff --git a/scripts/Extract_TEXT_FROM_IMAGE/main.py b/scripts/Extract_TEXT_FROM_IMAGE/main.py new file mode 100644 index 0000000..4821213 --- /dev/null +++ b/scripts/Extract_TEXT_FROM_IMAGE/main.py @@ -0,0 +1,15 @@ +import easyocr + +gpu = False # if you want to use GPU, set gpu=True +languages = ['en'] # refer https://www.jaided.ai/easyocr/ for supporting languages + +reader = easyocr.Reader(languages, gpu=gpu) + +IMG_PATH = 'test1.png' +result = reader.readtext(IMG_PATH) + +text = '' +for tup in result: + text += tup[1] + +print(text) \ No newline at end of file diff --git a/scripts/Extract_TEXT_FROM_IMAGE/requirements.txt b/scripts/Extract_TEXT_FROM_IMAGE/requirements.txt new file mode 100644 index 0000000..c6b2d0e --- /dev/null +++ b/scripts/Extract_TEXT_FROM_IMAGE/requirements.txt @@ -0,0 +1 @@ +easyocr==1.6.2 \ No newline at end of file diff --git a/scripts/Extract_TEXT_FROM_IMAGE/test1.png b/scripts/Extract_TEXT_FROM_IMAGE/test1.png new file mode 100644 index 0000000..13a05bc Binary files /dev/null and b/scripts/Extract_TEXT_FROM_IMAGE/test1.png differ diff --git a/scripts/GUI_Dictionary/GUI_Dictionary.py b/scripts/GUI_Dictionary/GUI_Dictionary.py new file mode 100644 index 0000000..58a8fd6 --- /dev/null +++ b/scripts/GUI_Dictionary/GUI_Dictionary.py @@ -0,0 +1,54 @@ +from tkinter import * +from tkinter import messagebox +from PyDictionary import PyDictionary + + +root = Tk() +root.title("GUI Dictionary") +root.geometry("500x400") + + +dictionary = PyDictionary() + + +def getMeaning(): + response = dictionary.meaning(word.get()) + if (response): + if ('Noun' in response): + meaning = response['Noun'][0] + elif ('Verb' in response): + meaning = response['Verb'][0] + elif ('Adjective' in response): + meaning = response['Adjective'][0] + else: + meaning = "Invalid word" + else: + messagebox.showinfo( + "Error", "Please add a Noun, Pronoun, verb or a valid word.") + meaning_label.config(text=meaning) + + + +heading_label = Label(root, text="DICTIONARY", font=("Times 35 bold"), foreground='dark blue') +heading_label.config(anchor=CENTER) +heading_label.pack(pady=10) + + +frame = Frame(root) +Label(frame, text="Enter Word", font=("Helvetica 15 bold"), foreground='dodger blue').pack(side=LEFT) +word = Entry(frame, font=("Helvetica 15 bold")) +word.pack(padx=10) +frame.pack() + +search_button = Button(root, text="Search Word", font=("arial 15 bold"), relief=RIDGE, borderwidth=3, cursor="hand2", foreground='Magenta', command=getMeaning) +search_button.config(anchor=CENTER) +search_button.pack(pady=10) + + +frame1 = Frame(root) +Label(frame1, text="Meaning : ", font=("Helvetica 15 bold"), foreground='medium turquoise').pack(side=LEFT) +meaning_label = Label(frame1, text="", font=("Helvetica 12")) +meaning_label.pack(pady=5) +frame1.pack(pady=10) + +root.mainloop() \ No newline at end of file diff --git a/scripts/GUI_Dictionary/README.md b/scripts/GUI_Dictionary/README.md new file mode 100644 index 0000000..9e16c77 --- /dev/null +++ b/scripts/GUI_Dictionary/README.md @@ -0,0 +1,24 @@ +# Dictionary GUI +This script lets the user search for the meaning of words like a dictionary. + +## Setup instructions +In order to run this script, you need to have Python and pip installed on your system. After you're done installing Python and pip, run the following command from your terminal to install the requirements for the project. +``` +pip install PyDictionary +``` + +After satisfying all the requirements for the project, Open the terminal in the project folder and run +``` +python GUI_Dictionary.py +``` +or +``` +python3 GUI_Dictionary.py +``` +depending upon the python version. Make sure that you are running the command from the same virtual environment in which the required modules are installed. + +# Introducing to Interface + +
+
+ \ No newline at end of file diff --git a/scripts/GUI_Dictionary/screenshots/gui-dict-3.png b/scripts/GUI_Dictionary/screenshots/gui-dict-3.png new file mode 100644 index 0000000..b4d9c08 Binary files /dev/null and b/scripts/GUI_Dictionary/screenshots/gui-dict-3.png differ diff --git a/scripts/GUI_Dictionary/screenshots/gui-dict-4.png b/scripts/GUI_Dictionary/screenshots/gui-dict-4.png new file mode 100644 index 0000000..cb6cd05 Binary files /dev/null and b/scripts/GUI_Dictionary/screenshots/gui-dict-4.png differ diff --git a/scripts/GUI_Dictionary/screenshots/gui_dict1.png b/scripts/GUI_Dictionary/screenshots/gui_dict1.png new file mode 100644 index 0000000..f5c2585 Binary files /dev/null and b/scripts/GUI_Dictionary/screenshots/gui_dict1.png differ diff --git a/scripts/Internet Speed Tester/Readme.md b/scripts/Internet Speed Tester/Readme.md new file mode 100644 index 0000000..f1f70ec --- /dev/null +++ b/scripts/Internet Speed Tester/Readme.md @@ -0,0 +1,23 @@ +# Internet Speed Tester + +This GUI App made with Tkinter will display your internet speed(upload and download) and this will also check the ping of your internet connection. + +## How to use + +1. Install the Speedtest Package using the following command: + + `pip install speedtest` + + [Learn More about speedtest library](https://pypi.org/project/speedtest/) + +2. Run the script + + `python3 daily-python-scripts/scripts/Internet Speed Tester/main.py` + +## ```Output``` + +![]() + +## Author + +Name: [Dishant Yadav](https://github.com/dishant-yadav) diff --git a/scripts/Internet Speed Tester/main.py b/scripts/Internet Speed Tester/main.py new file mode 100644 index 0000000..a5383cf --- /dev/null +++ b/scripts/Internet Speed Tester/main.py @@ -0,0 +1,38 @@ +from tkinter import * +from speedtest import Speedtest + +root = Tk() +root.title("Internet Speed Checker") +root.geometry('1920x1080') +root.resizable(True,True) + +def get_speed(): + speed = Speedtest() + download = speed.download() + upload = speed.upload() + ping = speed.results.ping + download_speed = round(download / 8 / 1024 / 1024,2) + upload_speed = round(upload / 8 / 1024 / 1024,2) + ping = round(ping, 2) + down_lab.config(text='Download Speed : ' + str(download_speed) + " Mbps") + upload_lab.config(text='Upload Speed : ' + str(upload_speed) + " Mbps") + ping_lab.config(text='Ping : ' + str(ping) + " ms") + +fg = '#0cc6a9' +bg = '#ed4947' + +title = Label(root, text="Internet Spped Tester",fg=fg, font=("Ubuntu",24,"bold")) + +test_btn = Button(root, text="Get Speed",font=('Helvetica',32,'bold'),command=get_speed,bg=bg) +test_btn.place(x=800, y=700) + +down_lab = Label(root,text='',fg=fg,font=('Ubuntu',24,'bold')) +down_lab.place(x=800, y = 100) + +upload_lab = Label(root,text='',fg=fg,font=('Ubuntu',24,'bold')) +upload_lab.place(x=800, y = 300) + +ping_lab = Label(root,text='',fg=fg,font=('Ubuntu',24,'bold')) +ping_lab.place(x=800, y = 500) + +root.mainloop() diff --git a/scripts/Loan Prediction Model/Loan Prediction Model .ipynb b/scripts/Loan Prediction Model/Loan Prediction Model .ipynb new file mode 100644 index 0000000..80fcd0a --- /dev/null +++ b/scripts/Loan Prediction Model/Loan Prediction Model .ipynb @@ -0,0 +1,1291 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8c97baae", + "metadata": {}, + "source": [ + "## Loan Prediction Model \n", + "\n", + "\n", + "The goal of this project is that from the data collected on the loan’s applicants, preprocess the data and predict based on the information who will be able to receive the loan or not.\n", + "\n", + "\n", + "In the Dataset we find the following features:\n", + "\n", + "1. Loan ID, the identifier code of each applicant.\n", + "2. Gender, Male or Female for each applicant.\n", + "3. Married, the maritage state.\n", + "4. Dependents, how many dependents does the applicant have?\n", + "5. Education, the level of education, graduate or non graduate\n", + "6. Self Employed, Yes or No in the case\n", + "7. Applicant Income\n", + "8. Coapplicant Income\n", + "9. Loan Amount\n", + "10. Loan Amount Term\n", + "11. Credit History, just Yes or No in the case\n", + "12. Property Area, urban, semiurban or rural area of the applicant’s property\n", + "\n", + "Loan Status, Yes or No ( The independent variable represents the class)" + ] + }, + { + "cell_type": "markdown", + "id": "3f28aeb7", + "metadata": {}, + "source": [ + "## Import Packages" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4cde977c", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "markdown", + "id": "ec208c3e", + "metadata": {}, + "source": [ + "## Read & visualize the data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8895329b", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Loan_IDGenderMarriedDependentsEducationSelf_EmployedApplicantIncomeCoapplicantIncomeLoanAmountLoan_Amount_TermCredit_HistoryProperty_AreaLoan_Status
0LP001002MaleNo0GraduateNo58490.0NaN360.01.0UrbanY
1LP001003MaleYes1GraduateNo45831508.0128.0360.01.0RuralN
2LP001005MaleYes0GraduateYes30000.066.0360.01.0UrbanY
3LP001006MaleYes0Not GraduateNo25832358.0120.0360.01.0UrbanY
4LP001008MaleNo0GraduateNo60000.0141.0360.01.0UrbanY
\n", + "
" + ], + "text/plain": [ + " Loan_ID Gender Married Dependents Education Self_Employed \\\n", + "0 LP001002 Male No 0 Graduate No \n", + "1 LP001003 Male Yes 1 Graduate No \n", + "2 LP001005 Male Yes 0 Graduate Yes \n", + "3 LP001006 Male Yes 0 Not Graduate No \n", + "4 LP001008 Male No 0 Graduate No \n", + "\n", + " ApplicantIncome CoapplicantIncome LoanAmount Loan_Amount_Term \\\n", + "0 5849 0.0 NaN 360.0 \n", + "1 4583 1508.0 128.0 360.0 \n", + "2 3000 0.0 66.0 360.0 \n", + "3 2583 2358.0 120.0 360.0 \n", + "4 6000 0.0 141.0 360.0 \n", + "\n", + " Credit_History Property_Area Loan_Status \n", + "0 1.0 Urban Y \n", + "1 1.0 Rural N \n", + "2 1.0 Urban Y \n", + "3 1.0 Urban Y \n", + "4 1.0 Urban Y " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df= pd.read_csv('Loan_train.csv')\n", + "df.head()" + ] + }, + { + "cell_type": "markdown", + "id": "8c16b1bc", + "metadata": {}, + "source": [ + "## Data Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8bbe6c13", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(614, 13)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ae1c8c0f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ApplicantIncomeCoapplicantIncomeLoanAmountLoan_Amount_TermCredit_History
count614.000000614.000000592.000000600.00000564.000000
mean5403.4592831621.245798146.412162342.000000.842199
std6109.0416732926.24836985.58732565.120410.364878
min150.0000000.0000009.00000012.000000.000000
25%2877.5000000.000000100.000000360.000001.000000
50%3812.5000001188.500000128.000000360.000001.000000
75%5795.0000002297.250000168.000000360.000001.000000
max81000.00000041667.000000700.000000480.000001.000000
\n", + "
" + ], + "text/plain": [ + " ApplicantIncome CoapplicantIncome LoanAmount Loan_Amount_Term \\\n", + "count 614.000000 614.000000 592.000000 600.00000 \n", + "mean 5403.459283 1621.245798 146.412162 342.00000 \n", + "std 6109.041673 2926.248369 85.587325 65.12041 \n", + "min 150.000000 0.000000 9.000000 12.00000 \n", + "25% 2877.500000 0.000000 100.000000 360.00000 \n", + "50% 3812.500000 1188.500000 128.000000 360.00000 \n", + "75% 5795.000000 2297.250000 168.000000 360.00000 \n", + "max 81000.000000 41667.000000 700.000000 480.00000 \n", + "\n", + " Credit_History \n", + "count 564.000000 \n", + "mean 0.842199 \n", + "std 0.364878 \n", + "min 0.000000 \n", + "25% 1.000000 \n", + "50% 1.000000 \n", + "75% 1.000000 \n", + "max 1.000000 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "8b553da7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 614 entries, 0 to 613\n", + "Data columns (total 13 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 Loan_ID 614 non-null object \n", + " 1 Gender 601 non-null object \n", + " 2 Married 611 non-null object \n", + " 3 Dependents 599 non-null object \n", + " 4 Education 614 non-null object \n", + " 5 Self_Employed 582 non-null object \n", + " 6 ApplicantIncome 614 non-null int64 \n", + " 7 CoapplicantIncome 614 non-null float64\n", + " 8 LoanAmount 592 non-null float64\n", + " 9 Loan_Amount_Term 600 non-null float64\n", + " 10 Credit_History 564 non-null float64\n", + " 11 Property_Area 614 non-null object \n", + " 12 Loan_Status 614 non-null object \n", + "dtypes: float64(4), int64(1), object(8)\n", + "memory usage: 62.5+ KB\n" + ] + } + ], + "source": [ + "df.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "20168c69", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Loan_ID 0\n", + "Gender 13\n", + "Married 3\n", + "Dependents 15\n", + "Education 0\n", + "Self_Employed 32\n", + "ApplicantIncome 0\n", + "CoapplicantIncome 0\n", + "LoanAmount 22\n", + "Loan_Amount_Term 14\n", + "Credit_History 50\n", + "Property_Area 0\n", + "Loan_Status 0\n", + "dtype: int64" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.isnull().sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a52091bf", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Gender Married Dependents Education Self_Employed ApplicantIncome \\\n", + "0 1.0 0.0 0.0 1 0.0 5849 \n", + "1 1.0 1.0 1.0 1 0.0 4583 \n", + "2 1.0 1.0 0.0 1 1.0 3000 \n", + "3 1.0 1.0 0.0 0 0.0 2583 \n", + "4 1.0 0.0 0.0 1 0.0 6000 \n", + ".. ... ... ... ... ... ... \n", + "609 0.0 0.0 0.0 1 0.0 2900 \n", + "610 1.0 1.0 3.0 1 0.0 4106 \n", + "611 1.0 1.0 1.0 1 0.0 8072 \n", + "612 1.0 1.0 2.0 1 0.0 7583 \n", + "613 0.0 0.0 0.0 1 1.0 4583 \n", + "\n", + " CoapplicantIncome LoanAmount Loan_Amount_Term Credit_History \\\n", + "0 0.0 NaN 360.0 1.0 \n", + "1 1508.0 128.0 360.0 1.0 \n", + "2 0.0 66.0 360.0 1.0 \n", + "3 2358.0 120.0 360.0 1.0 \n", + "4 0.0 141.0 360.0 1.0 \n", + ".. ... ... ... ... \n", + "609 0.0 71.0 360.0 1.0 \n", + "610 0.0 40.0 180.0 1.0 \n", + "611 240.0 253.0 360.0 1.0 \n", + "612 0.0 187.0 360.0 1.0 \n", + "613 0.0 133.0 360.0 0.0 \n", + "\n", + " Property_Area Loan_Status \n", + "0 1 1 \n", + "1 0 0 \n", + "2 1 1 \n", + "3 1 1 \n", + "4 1 1 \n", + ".. ... ... \n", + "609 0 1 \n", + "610 0 1 \n", + "611 1 1 \n", + "612 1 1 \n", + "613 2 0 \n", + "\n", + "[614 rows x 12 columns]\n" + ] + } + ], + "source": [ + "#Loan Status Encoding\n", + "df= df.replace({\"Loan_Status\":{'Y': 1, 'N': 0}})\n", + "\n", + "#Gender Encoding\n", + "df= df.replace({\"Gender\":{\"Male\":1, \"Female\":0 }})\n", + "\n", + "#Married Encoding\n", + "df =df.replace({\"Married\" :{\"Yes\":1, \"No\":0}})\n", + "\n", + "#Replace the 3+ in dependents ande make the column numeric\n", + "df['Dependents'] = df['Dependents'].replace('3+', '3')\n", + "df['Dependents']=pd.to_numeric(df['Dependents'], errors='coerce')\n", + "\n", + "#Count the quantity of values on the column\n", + "df['Self_Employed'].value_counts()\n", + "df= df.replace({\"Self_Employed\":{\"Yes\":1, \"No\":0 }})\n", + "\n", + "#Education Encoding\n", + "df['Education'].value_counts()\n", + "df= df.replace({\"Education\":{\"Graduate\":1, \"Not Graduate\":0 }})\n", + "\n", + "#Drop the Loan ID column\n", + "df = df.drop('Loan_ID',axis=1)\n", + "\n", + "#Property Area Encoding\n", + "df['Property_Area'].value_counts()\n", + "df['Property_Area'] = df['Property_Area'].map({'Rural': 0, 'Urban': 1, 'Semiurban': 2})\n", + "\n", + "print(df)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "861ac719", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
GenderMarriedDependentsEducationSelf_EmployedApplicantIncomeCoapplicantIncomeLoanAmountLoan_Amount_TermCredit_HistoryProperty_AreaLoan_Status
count601.000000611.000000599.000000614.000000582.000000614.000000614.000000592.000000600.00000564.000000614.000000614.000000
mean0.8136440.6513910.7629380.7817590.1408935403.4592831621.245798146.412162342.000000.8421991.0879480.687296
std0.3897180.4769201.0152160.4133890.3482116109.0416732926.24836985.58732565.120410.3648780.8150810.463973
min0.0000000.0000000.0000000.0000000.000000150.0000000.0000009.00000012.000000.0000000.0000000.000000
25%1.0000000.0000000.0000001.0000000.0000002877.5000000.000000100.000000360.000001.0000000.0000000.000000
50%1.0000001.0000000.0000001.0000000.0000003812.5000001188.500000128.000000360.000001.0000001.0000001.000000
75%1.0000001.0000002.0000001.0000000.0000005795.0000002297.250000168.000000360.000001.0000002.0000001.000000
max1.0000001.0000003.0000001.0000001.00000081000.00000041667.000000700.000000480.000001.0000002.0000001.000000
\n", + "
" + ], + "text/plain": [ + " Gender Married Dependents Education Self_Employed \\\n", + "count 601.000000 611.000000 599.000000 614.000000 582.000000 \n", + "mean 0.813644 0.651391 0.762938 0.781759 0.140893 \n", + "std 0.389718 0.476920 1.015216 0.413389 0.348211 \n", + "min 0.000000 0.000000 0.000000 0.000000 0.000000 \n", + "25% 1.000000 0.000000 0.000000 1.000000 0.000000 \n", + "50% 1.000000 1.000000 0.000000 1.000000 0.000000 \n", + "75% 1.000000 1.000000 2.000000 1.000000 0.000000 \n", + "max 1.000000 1.000000 3.000000 1.000000 1.000000 \n", + "\n", + " ApplicantIncome CoapplicantIncome LoanAmount Loan_Amount_Term \\\n", + "count 614.000000 614.000000 592.000000 600.00000 \n", + "mean 5403.459283 1621.245798 146.412162 342.00000 \n", + "std 6109.041673 2926.248369 85.587325 65.12041 \n", + "min 150.000000 0.000000 9.000000 12.00000 \n", + "25% 2877.500000 0.000000 100.000000 360.00000 \n", + "50% 3812.500000 1188.500000 128.000000 360.00000 \n", + "75% 5795.000000 2297.250000 168.000000 360.00000 \n", + "max 81000.000000 41667.000000 700.000000 480.00000 \n", + "\n", + " Credit_History Property_Area Loan_Status \n", + "count 564.000000 614.000000 614.000000 \n", + "mean 0.842199 1.087948 0.687296 \n", + "std 0.364878 0.815081 0.463973 \n", + "min 0.000000 0.000000 0.000000 \n", + "25% 1.000000 0.000000 0.000000 \n", + "50% 1.000000 1.000000 1.000000 \n", + "75% 1.000000 2.000000 1.000000 \n", + "max 1.000000 2.000000 1.000000 " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "64ab82d9", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
GenderMarriedDependentsEducationSelf_EmployedApplicantIncomeCoapplicantIncomeLoanAmountLoan_Amount_TermCredit_HistoryProperty_AreaLoan_Status
01.00.00.010.058490.0NaN360.01.011
11.01.01.010.045831508.0128.0360.01.000
21.01.00.011.030000.066.0360.01.011
31.01.00.000.025832358.0120.0360.01.011
41.00.00.010.060000.0141.0360.01.011
.......................................
6090.00.00.010.029000.071.0360.01.001
6101.01.03.010.041060.040.0180.01.001
6111.01.01.010.08072240.0253.0360.01.011
6121.01.02.010.075830.0187.0360.01.011
6130.00.00.011.045830.0133.0360.00.020
\n", + "

614 rows Γ— 12 columns

\n", + "
" + ], + "text/plain": [ + " Gender Married Dependents Education Self_Employed ApplicantIncome \\\n", + "0 1.0 0.0 0.0 1 0.0 5849 \n", + "1 1.0 1.0 1.0 1 0.0 4583 \n", + "2 1.0 1.0 0.0 1 1.0 3000 \n", + "3 1.0 1.0 0.0 0 0.0 2583 \n", + "4 1.0 0.0 0.0 1 0.0 6000 \n", + ".. ... ... ... ... ... ... \n", + "609 0.0 0.0 0.0 1 0.0 2900 \n", + "610 1.0 1.0 3.0 1 0.0 4106 \n", + "611 1.0 1.0 1.0 1 0.0 8072 \n", + "612 1.0 1.0 2.0 1 0.0 7583 \n", + "613 0.0 0.0 0.0 1 1.0 4583 \n", + "\n", + " CoapplicantIncome LoanAmount Loan_Amount_Term Credit_History \\\n", + "0 0.0 NaN 360.0 1.0 \n", + "1 1508.0 128.0 360.0 1.0 \n", + "2 0.0 66.0 360.0 1.0 \n", + "3 2358.0 120.0 360.0 1.0 \n", + "4 0.0 141.0 360.0 1.0 \n", + ".. ... ... ... ... \n", + "609 0.0 71.0 360.0 1.0 \n", + "610 0.0 40.0 180.0 1.0 \n", + "611 240.0 253.0 360.0 1.0 \n", + "612 0.0 187.0 360.0 1.0 \n", + "613 0.0 133.0 360.0 0.0 \n", + "\n", + " Property_Area Loan_Status \n", + "0 1 1 \n", + "1 0 0 \n", + "2 1 1 \n", + "3 1 1 \n", + "4 1 1 \n", + ".. ... ... \n", + "609 0 1 \n", + "610 0 1 \n", + "611 1 1 \n", + "612 1 1 \n", + "613 2 0 \n", + "\n", + "[614 rows x 12 columns]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7a2c0144", + "metadata": {}, + "outputs": [], + "source": [ + "df.fillna(df.median(), inplace=True)\n", + "columns = df.columns\n", + "for column in columns:\n", + " df[column] = pd.to_numeric(df[column], errors='coerce')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "574b6b70", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set(rc={'figure.figsize':(15,8)})\n", + "sns.heatmap(df.corr(),annot=True,cmap=\"rocket\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "40bee983", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Married Education CoapplicantIncome Credit_History Property_Area \\\n", + "0 0.0 1 0.0 1.0 1 \n", + "1 1.0 1 1508.0 1.0 0 \n", + "2 1.0 1 0.0 1.0 1 \n", + "3 1.0 0 2358.0 1.0 1 \n", + "4 0.0 1 0.0 1.0 1 \n", + ".. ... ... ... ... ... \n", + "609 0.0 1 0.0 1.0 0 \n", + "610 1.0 1 0.0 1.0 0 \n", + "611 1.0 1 240.0 1.0 1 \n", + "612 1.0 1 0.0 1.0 1 \n", + "613 0.0 1 0.0 0.0 2 \n", + "\n", + " Loan_Status \n", + "0 1 \n", + "1 0 \n", + "2 1 \n", + "3 1 \n", + "4 1 \n", + ".. ... \n", + "609 1 \n", + "610 1 \n", + "611 1 \n", + "612 1 \n", + "613 0 \n", + "\n", + "[614 rows x 6 columns]\n" + ] + } + ], + "source": [ + "def correlationdrop(df, sl):\n", + " columns = df.columns\n", + " for column in columns:\n", + " C=abs(df[column].corr(df['Loan_Status']))\n", + " if C < sl:\n", + " df=df.drop(columns=[column])\n", + " return df\n", + "\n", + "df= correlationdrop(df,0.05)\n", + "\n", + "print(df)" + ] + }, + { + "cell_type": "markdown", + "id": "7cd3d4a8", + "metadata": {}, + "source": [ + "## Separate the variables" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c6e6d8cb", + "metadata": {}, + "outputs": [], + "source": [ + "x = df.iloc[:,:-1].values\n", + "y = df.iloc[:,-1].values" + ] + }, + { + "cell_type": "markdown", + "id": "0e743143", + "metadata": {}, + "source": [ + "## Scale the data" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b8992600", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.preprocessing import MinMaxScaler\n", + "sc = MinMaxScaler()\n", + "X= sc.fit_transform(x)" + ] + }, + { + "cell_type": "markdown", + "id": "3615ec24", + "metadata": {}, + "source": [ + "## Split the data" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "2a37ac15", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "X_train,X_test,y_train,y_test = train_test_split(X,y, test_size= 0.2, random_state= 0)" + ] + }, + { + "cell_type": "markdown", + "id": "c98b35e0", + "metadata": {}, + "source": [ + "## Logistic Regression" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "daba8de4", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.linear_model import LogisticRegression\n", + "model=LogisticRegression()\n", + "model.fit(X_train,y_train)\n", + "z=model.predict(X_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "16b8534b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.8292682926829268" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.metrics import accuracy_score\n", + "accuracy_score(y_test,z)" + ] + }, + { + "cell_type": "markdown", + "id": "2a31a652", + "metadata": {}, + "source": [ + "## SVM Classifier" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "e6c9e365", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.svm import SVC\n", + "classifier = SVC(kernel = 'rbf', gamma= 0.2)\n", + "classifier.fit(X_train, y_train)\n", + "\n", + "# Predicting the Test set results\n", + "y_pred = classifier.predict(X_test)" + ] + }, + { + "cell_type": "markdown", + "id": "e5b880d7", + "metadata": {}, + "source": [ + "## Making the Confusion Matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "a1503813", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[14 19]\n", + " [ 2 88]]\n", + "Accuracy: 80.44 %\n", + "Standard Deviation: 4.59 %\n" + ] + } + ], + "source": [ + "from sklearn.metrics import confusion_matrix\n", + "cm = confusion_matrix(y_test, y_pred)\n", + "print(cm)\n", + "\n", + "# Applying k-Fold Cross Validation\n", + "from sklearn.model_selection import cross_val_score\n", + "accuracies = cross_val_score(estimator = classifier, X = X_train, y = y_train, cv = 10)\n", + "print(\"Accuracy: {:.2f} %\".format(accuracies.mean()*100))\n", + "print(\"Standard Deviation: {:.2f} %\".format(accuracies.std()*100))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/scripts/Loan Prediction Model/Readme.md b/scripts/Loan Prediction Model/Readme.md new file mode 100644 index 0000000..eedbe79 --- /dev/null +++ b/scripts/Loan Prediction Model/Readme.md @@ -0,0 +1,22 @@ +## Loan Prediction Model + + +The goal of this project is that from the data collected on the loan’s applicants, preprocess the data and predict based on the information who will be able to receive the loan or not. + + +### In the Dataset we find the following features: + +1. Loan ID, the identifier code of each applicant. +2. Gender, Male or Female for each applicant. +3. Married, the maritage state. +4. Dependents, how many dependents does the applicant have? +5. Education, the level of education, graduate or non graduate +6. Self Employed, Yes or No in the case +7. Applicant Income +8. Coapplicant Income +9. Loan Amount +10. Loan Amount Term +11. Credit History, just Yes or No in the case +12. Property Area, urban, semiurban or rural area of the applicant’s property + +Loan Status, Yes or No ( The independent variable represents the class) diff --git a/scripts/Lyrics Scraper/LyricsScraper.py b/scripts/Lyrics Scraper/LyricsScraper.py new file mode 100644 index 0000000..8f680f7 --- /dev/null +++ b/scripts/Lyrics Scraper/LyricsScraper.py @@ -0,0 +1,22 @@ +import requests +from bs4 import BeautifulSoup + + +def get_lyrics(artist, song): + song_url = 'http://www.azlyrics.com/lyrics/' + artist + '/' + song + '.html' + + response = requests.get(song_url) + + soup = BeautifulSoup(response.content, 'html.parser') + try: + lyrics = soup.find( + 'div', class_='col-xs-12 col-lg-8 text-center').find_all('div')[5].text + print(lyrics) + except AttributeError: + print("Please make sure you have entered the correct name(i.e. Don't add spaces between words)!") + + +artist = input( + "Enter the name of the artist/band: ").strip().lower().replace(' ', '') +song = input("Enter the name of the song: ").strip().lower().replace(' ', '') +get_lyrics(artist, song) diff --git a/scripts/Lyrics Scraper/README.md b/scripts/Lyrics Scraper/README.md new file mode 100644 index 0000000..95cf968 --- /dev/null +++ b/scripts/Lyrics Scraper/README.md @@ -0,0 +1,9 @@ +# Lyrics scraper + +This simple script scrapes [Azlyrics](http://www.azlyrics.com) given the artist and the song name. + +## Usage + +It's pretty straight-forward, just install the requiremnts and run it. + +`pip install -r requirements.txt` diff --git a/scripts/Lyrics Scraper/requirements.txt b/scripts/Lyrics Scraper/requirements.txt new file mode 100644 index 0000000..d779dbe --- /dev/null +++ b/scripts/Lyrics Scraper/requirements.txt @@ -0,0 +1,2 @@ +bs4 +requests \ No newline at end of file diff --git a/scripts/Music Player/README.md b/scripts/Music Player/README.md new file mode 100644 index 0000000..7aa576d --- /dev/null +++ b/scripts/Music Player/README.md @@ -0,0 +1,13 @@ +# Music Player GUI + +![Screenshot (465)](https://user-images.githubusercontent.com/48403800/195563802-fdc224c3-8325-4e1b-b768-2d85e44a3666.png) + +This is a GUI framework where two GUI libraries are used: + +- Pygame +- Tkinter + +It has functions such as play, stop, pause and resume in order to control the music player. + +To create a music player with Python, we will be using the **Pygame** sound component and _askdirectory()_ method of Tkinter + diff --git a/scripts/Music Player/music-player.py b/scripts/Music Player/music-player.py new file mode 100644 index 0000000..3eb6fa2 --- /dev/null +++ b/scripts/Music Player/music-player.py @@ -0,0 +1,45 @@ +import pygame +import tkinter as tkr +from tkinter.filedialog import askdirectory +import os + +music_player = tkr.Tk() +music_player.title("My Music Player") +music_player.geometry("450x350") +directory = askdirectory() +os.chdir(directory) +song_list = os.listdir() + +play_list = tkr.Listbox(music_player, font="Helvetica 12 bold", bg='yellow', selectmode=tkr.SINGLE) +for item in song_list: + pos = 0 + play_list.insert(pos, item) + pos += 1 +pygame.init() +pygame.mixer.init() + +def play(): + pygame.mixer.music.load(play_list.get(tkr.ACTIVE)) + var.set(play_list.get(tkr.ACTIVE)) + pygame.mixer.music.play() +def stop(): + pygame.mixer.music.stop() +def pause(): + pygame.mixer.music.pause() +def unpause(): + pygame.mixer.music.unpause() +Button1 = tkr.Button(music_player, width=5, height=3, font="Helvetica 12 bold", text="PLAY", command=play, bg="blue", fg="white") +Button2 = tkr.Button(music_player, width=5, height=3, font="Helvetica 12 bold", text="STOP", command=stop, bg="red", fg="white") +Button3 = tkr.Button(music_player, width=5, height=3, font="Helvetica 12 bold", text="PAUSE", command=pause, bg="purple", fg="white") +Button4 = tkr.Button(music_player, width=5, height=3, font="Helvetica 12 bold", text="UNPAUSE", command=unpause, bg="orange", fg="white") + +var = tkr.StringVar() +song_title = tkr.Label(music_player, font="Helvetica 12 bold", textvariable=var) + +song_title.pack() +Button1.pack(fill="x") +Button2.pack(fill="x") +Button3.pack(fill="x") +Button4.pack(fill="x") +play_list.pack(fill="both", expand="yes") +music_player.mainloop() diff --git a/scripts/Music Player/requirements.txt b/scripts/Music Player/requirements.txt new file mode 100644 index 0000000..d6ffd30 --- /dev/null +++ b/scripts/Music Player/requirements.txt @@ -0,0 +1,2 @@ +pygame +tkinter \ No newline at end of file diff --git a/scripts/Quotes Fetch/readme.md b/scripts/Quotes Fetch/readme.md new file mode 100644 index 0000000..c9fd724 --- /dev/null +++ b/scripts/Quotes Fetch/readme.md @@ -0,0 +1,5 @@ +## A program to fetch random quote or term related quote from internet + +use following command to search quote related to a specific term or phrase + +python scrape.py -q your_search_term -r yes diff --git a/scripts/Quotes Fetch/scrape.py b/scripts/Quotes Fetch/scrape.py new file mode 100644 index 0000000..f43518b --- /dev/null +++ b/scripts/Quotes Fetch/scrape.py @@ -0,0 +1,35 @@ +#import section +import requests +from bs4 import BeautifulSoup as bs +import argparse +from random import choice + +# parser object to read cli content +parser = argparse.ArgumentParser() +parser.add_argument("-q", help="for search term") +parser.add_argument("-r", help="if you want one random quote") + +args = parser.parse_args() + + +search_term = args.q +page = 1 +# URl definition +url = f"https://www.brainyquote.com/search_results?q={search_term}&pg={page}" + +# main program +r = requests.get(url) +soup = bs(r.content, "html.parser") +anchor1 = soup.find_all('a', {"class": "b-qt"}) +anchor2 = soup.find_all('a', {"class": "bq-aut"}) + + +if args.r != None: + quote = choice( + [f"{quote.text.strip()} - {author.text.strip()}" for quote, author in zip(anchor1, anchor2)]) + print(quote) +else: + for i, (quote, author) in enumerate(zip(anchor1, anchor2)): + quote = quote.find('div').text.strip() + author = author.text.strip() + print(f"[{i}] : {quote} - {author}") diff --git a/scripts/Sudoku-Solver/README.md b/scripts/Sudoku-Solver/README.md new file mode 100644 index 0000000..bea82a2 --- /dev/null +++ b/scripts/Sudoku-Solver/README.md @@ -0,0 +1,2 @@ +This is a Sudoku Solver that uses backtracking algorithm to solve the puzzle. +Input the puzzle from command line. diff --git a/scripts/Sudoku-Solver/main.py b/scripts/Sudoku-Solver/main.py new file mode 100644 index 0000000..11fca12 --- /dev/null +++ b/scripts/Sudoku-Solver/main.py @@ -0,0 +1,83 @@ +import numpy as np + +problem = [] + +for x in range(9): + i = input() + l = [int(v) for v in i] + problem.append(l) + +#print(problem) + +np_problem = np.array(problem) + +fixed_coordinates = [] # first getting the coordinates where fixed numbers are present +empty_coordinates = [] +for i , sub_array in enumerate(problem) : + temp = [[i , c] for c , sub_element in enumerate(sub_array) if sub_element > 0] + temp2 = [[i , j] for j , sub_element2 in enumerate(sub_array) if sub_element2 == 0] + for z in temp : fixed_coordinates.append(z) + for w in temp2 : empty_coordinates.append(w) + +l , m , r = [0 , 3 , 6] , [1 , 4 , 7] , [2 , 5 , 8] + +avoid_dict = {idx : [] for idx in list(range(0 , len(empty_coordinates)))} + +def generate_bounds(r , c) -> list: + + lower_bound_c = c if c in l else c - 1 if c in m else c - 2 + upper_bound_c = c + 3 if c in l else c + 2 if c in m else c + 1 + + lower_bound_r = r if r in l else r - 1 if r in m else r - 2 + upper_bound_r = r + 3 if r in l else r + 2 if r in m else r + 1 + + return [lower_bound_c , upper_bound_c , lower_bound_r , upper_bound_r] + + +def backtrack(return_coordinates) : + + n_r , n_c = empty_coordinates[empty_coordinates.index(return_coordinates) - 1] # getting back element coordinates + + while [n_r , n_c] != empty_coordinates[empty_coordinates.index(return_coordinates) + 1]: + + if np_problem[n_r , n_c] != 0 : + avoid_dict[empty_coordinates.index([n_r , n_c])].append(np_problem[n_r , n_c]) + + fix_flag = False + r , c = n_r , n_c + for num in range(1 , 10) : + + l_b_c , u_b_c , l_b_r , u_b_r = generate_bounds(r , c) + + if all([num not in np_problem[l_b_r : u_b_r , l_b_c : u_b_c] , num not in np_problem[r , :] , num not in np_problem[: , c]]) : + if num not in avoid_dict.get(empty_coordinates.index([n_r , n_c])) : + np_problem[n_r , n_c] , fix_flag = num , True + break + + if fix_flag : n_r , n_c = empty_coordinates[empty_coordinates.index([n_r , n_c]) + 1] + + if not fix_flag : + np_problem[n_r , n_c] = 0 + avoid_dict[empty_coordinates.index([n_r , n_c])].clear() + n_r , n_c = empty_coordinates[empty_coordinates.index([n_r , n_c]) - 1] + + +for r in range(9) : + for c in range(9) : + + if [r , c] not in fixed_coordinates : + + fix_flag = False + + for num in range(1 , 10) : + + l_b_c , u_b_c , l_b_r , u_b_r = generate_bounds(r , c) + + if all([num not in np_problem[l_b_r : u_b_r , l_b_c : u_b_c] , num not in np_problem[r , :] , num not in np_problem[: , c]]) : + + np_problem[r , c] , fix_flag = num , True + break + + if not fix_flag : backtrack([r , c]) + +print(np_problem) diff --git a/scripts/Tetris-Game/README.md b/scripts/Tetris-Game/README.md new file mode 100644 index 0000000..ea5429c --- /dev/null +++ b/scripts/Tetris-Game/README.md @@ -0,0 +1,8 @@ +# Tetris Game +The game of Tetris. Made with pygame. + + +# Run in Gitpod + +You can also run Tetris-Game in Gitpod, a free online dev environment for GitHub: + diff --git a/scripts/Tetris-Game/main.py b/scripts/Tetris-Game/main.py new file mode 100644 index 0000000..334c748 --- /dev/null +++ b/scripts/Tetris-Game/main.py @@ -0,0 +1,401 @@ +import pygame +import random + +""" +10 x 20 square grid +shapes: S, Z, I, O, J, L, T +represented in order by 0 - 6 +""" + +pygame.font.init() + +# GLOBALS VARS +s_width = 800 +s_height = 700 +play_width = 300 # meaning 300 // 10 = 30 width per block +play_height = 600 # meaning 600 // 20 = 20 height per blo ck +block_size = 30 + +top_left_x = (s_width - play_width) // 2 +top_left_y = s_height - play_height + + +# SHAPE FORMATS + +S = [['.....', + '.....', + '..00.', + '.00..', + '.....'], + ['.....', + '..0..', + '..00.', + '...0.', + '.....']] + +Z = [['.....', + '.....', + '.00..', + '..00.', + '.....'], + ['.....', + '..0..', + '.00..', + '.0...', + '.....']] + +I = [['..0..', + '..0..', + '..0..', + '..0..', + '.....'], + ['.....', + '0000.', + '.....', + '.....', + '.....']] + +O = [['.....', + '.....', + '.00..', + '.00..', + '.....']] + +J = [['.....', + '.0...', + '.000.', + '.....', + '.....'], + ['.....', + '..00.', + '..0..', + '..0..', + '.....'], + ['.....', + '.....', + '.000.', + '...0.', + '.....'], + ['.....', + '..0..', + '..0..', + '.00..', + '.....']] + +L = [['.....', + '...0.', + '.000.', + '.....', + '.....'], + ['.....', + '..0..', + '..0..', + '..00.', + '.....'], + ['.....', + '.....', + '.000.', + '.0...', + '.....'], + ['.....', + '.00..', + '..0..', + '..0..', + '.....']] + +T = [['.....', + '..0..', + '.000.', + '.....', + '.....'], + ['.....', + '..0..', + '..00.', + '..0..', + '.....'], + ['.....', + '.....', + '.000.', + '..0..', + '.....'], + ['.....', + '..0..', + '.00..', + '..0..', + '.....']] + +shapes = [S, Z, I, O, J, L, T] +shape_colors = [(0, 255, 0), (255, 0, 0), (0, 255, 255), (255, 255, 0), (255, 165, 0), (0, 0, 255), (128, 0, 128)] +# index 0 - 6 represent shape + + +class Piece(object): + rows = 20 # y + columns = 10 # x + + def __init__(self, column, row, shape): + self.x = column + self.y = row + self.shape = shape + self.color = shape_colors[shapes.index(shape)] + self.rotation = 0 # number from 0-3 + + +def create_grid(locked_positions={}): + grid = [[(0,0,0) for x in range(10)] for x in range(20)] + + for i in range(len(grid)): + for j in range(len(grid[i])): + if (j,i) in locked_positions: + c = locked_positions[(j,i)] + grid[i][j] = c + return grid + + +def convert_shape_format(shape): + positions = [] + format = shape.shape[shape.rotation % len(shape.shape)] + + for i, line in enumerate(format): + row = list(line) + for j, column in enumerate(row): + if column == '0': + positions.append((shape.x + j, shape.y + i)) + + for i, pos in enumerate(positions): + positions[i] = (pos[0] - 2, pos[1] - 4) + + return positions + + +def valid_space(shape, grid): + accepted_positions = [[(j, i) for j in range(10) if grid[i][j] == (0,0,0)] for i in range(20)] + accepted_positions = [j for sub in accepted_positions for j in sub] + formatted = convert_shape_format(shape) + + for pos in formatted: + if pos not in accepted_positions: + if pos[1] > -1: + return False + + return True + + +def check_lost(positions): + for pos in positions: + x, y = pos + if y < 1: + return True + return False + + +def get_shape(): + global shapes, shape_colors + + return Piece(5, 0, random.choice(shapes)) + + +def draw_text_middle(text, size, color, surface): + font = pygame.font.SysFont('comicsans', size, bold=True) + label = font.render(text, 1, color) + + surface.blit(label, (top_left_x + play_width/2 - (label.get_width() / 2), top_left_y + play_height/2 - label.get_height()/2)) + + +def draw_grid(surface, row, col): + sx = top_left_x + sy = top_left_y + for i in range(row): + pygame.draw.line(surface, (128,128,128), (sx, sy+ i*30), (sx + play_width, sy + i * 30)) # horizontal lines + for j in range(col): + pygame.draw.line(surface, (128,128,128), (sx + j * 30, sy), (sx + j * 30, sy + play_height)) # vertical lines + + +def clear_rows(grid, locked): + # need to see if row is clear the shift every other row above down one + + inc = 0 + for i in range(len(grid)-1,-1,-1): + row = grid[i] + if (0, 0, 0) not in row: + inc += 1 + # add positions to remove from locked + ind = i + for j in range(len(row)): + try: + del locked[(j, i)] + except: + continue + if inc > 0: + for key in sorted(list(locked), key=lambda x: x[1])[::-1]: + x, y = key + if y < ind: + newKey = (x, y + inc) + locked[newKey] = locked.pop(key) + + +def draw_next_shape(shape, surface): + font = pygame.font.SysFont('comicsans', 30) + label = font.render('Next Shape', 1, (255,255,255)) + + sx = top_left_x + play_width + 50 + sy = top_left_y + play_height/2 - 100 + format = shape.shape[shape.rotation % len(shape.shape)] + + for i, line in enumerate(format): + row = list(line) + for j, column in enumerate(row): + if column == '0': + pygame.draw.rect(surface, shape.color, (sx + j*30, sy + i*30, 30, 30), 0) + + surface.blit(label, (sx + 10, sy- 30)) + + +def draw_window(surface): + surface.fill((0,0,0)) + # Tetris Title + font = pygame.font.SysFont('comicsans', 60) + label = font.render('TETRIS', 1, (255,255,255)) + + surface.blit(label, (top_left_x + play_width / 2 - (label.get_width() / 2), 30)) + + for i in range(len(grid)): + for j in range(len(grid[i])): + pygame.draw.rect(surface, grid[i][j], (top_left_x + j* 30, top_left_y + i * 30, 30, 30), 0) + + # draw grid and border + draw_grid(surface, 20, 10) + pygame.draw.rect(surface, (255, 0, 0), (top_left_x, top_left_y, play_width, play_height), 5) + # pygame.display.update() + + +def main(): + global grid + + locked_positions = {} # (x,y):(255,0,0) + grid = create_grid(locked_positions) + + change_piece = False + run = True + current_piece = get_shape() + next_piece = get_shape() + clock = pygame.time.Clock() + fall_time = 0 + level_time = 0 + fall_speed = 0.27 + score = 0 + + while run: + + grid = create_grid(locked_positions) + fall_time += clock.get_rawtime() + level_time += clock.get_rawtime() + clock.tick() + + if level_time/1000 > 4: + level_time = 0 + if fall_speed > 0.15: + fall_speed -= 0.005 + + + # PIECE FALLING CODE + if fall_time/1000 >= fall_speed: + fall_time = 0 + current_piece.y += 1 + if not (valid_space(current_piece, grid)) and current_piece.y > 0: + current_piece.y -= 1 + change_piece = True + + for event in pygame.event.get(): + if event.type == pygame.QUIT: + run = False + pygame.display.quit() + quit() + + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_LEFT: + current_piece.x -= 1 + if not valid_space(current_piece, grid): + current_piece.x += 1 + + elif event.key == pygame.K_RIGHT: + current_piece.x += 1 + if not valid_space(current_piece, grid): + current_piece.x -= 1 + elif event.key == pygame.K_UP: + # rotate shape + current_piece.rotation = current_piece.rotation + 1 % len(current_piece.shape) + if not valid_space(current_piece, grid): + current_piece.rotation = current_piece.rotation - 1 % len(current_piece.shape) + + if event.key == pygame.K_DOWN: + # move shape down + current_piece.y += 1 + if not valid_space(current_piece, grid): + current_piece.y -= 1 + + '''if event.key == pygame.K_SPACE: + while valid_space(current_piece, grid): + current_piece.y += 1 + current_piece.y -= 1 + print(convert_shape_format(current_piece))''' # todo fix + + shape_pos = convert_shape_format(current_piece) + + # add piece to the grid for drawing + for i in range(len(shape_pos)): + x, y = shape_pos[i] + if y > -1: + grid[y][x] = current_piece.color + + # IF PIECE HIT GROUND + if change_piece: + for pos in shape_pos: + p = (pos[0], pos[1]) + locked_positions[p] = current_piece.color + current_piece = next_piece + next_piece = get_shape() + change_piece = False + + # call four times to check for multiple clear rows + if clear_rows(grid, locked_positions): + score += 10 + + draw_window(win) + draw_next_shape(next_piece, win) + pygame.display.update() + + # Check if user lost + if check_lost(locked_positions): + run = False + + draw_text_middle("You Lost", 40, (255,255,255), win) + pygame.display.update() + pygame.time.delay(2000) + + +def main_menu(): + run = True + while run: + win.fill((0,0,0)) + draw_text_middle('Press any key to begin.', 60, (255, 255, 255), win) + pygame.display.update() + for event in pygame.event.get(): + if event.type == pygame.QUIT: + run = False + + if event.type == pygame.KEYDOWN: + main() + pygame.quit() + + +win = pygame.display.set_mode((s_width, s_height)) +pygame.display.set_caption('Tetris') + +main_menu() # start game + + + + + + diff --git a/scripts/Tetris-Game/requirements.txt b/scripts/Tetris-Game/requirements.txt new file mode 100644 index 0000000..0cb7ff1 --- /dev/null +++ b/scripts/Tetris-Game/requirements.txt @@ -0,0 +1 @@ +pygame diff --git a/scripts/Text_Game/Text_Game.py b/scripts/Text_Game/Text_Game.py index 0a05b93..6df50fa 100644 --- a/scripts/Text_Game/Text_Game.py +++ b/scripts/Text_Game/Text_Game.py @@ -2,6 +2,7 @@ import time import sys + def start(): # story generated print('Hello you are in the future and are fighting a robot') @@ -87,6 +88,7 @@ def random_select(rightpath): if rightpath == str(select): time.sleep(3) print('good you went down the correct path and cheated death!!') + level2() else: time.sleep(3) @@ -94,7 +96,246 @@ def random_select(rightpath): time.sleep(3) print('and you have been shot multiple time and are now dead.') +def level2(): + time.sleep(3) + print('You are running far away from the robots') + + time.sleep(2) + print(""" β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β–ˆβ–ˆ + β–„β”€β”€β”€β–„β–€β–ˆβ–„β–„β–„β–„ + ─ β–„β–€β”€β–ˆβ–„β–„ + ▄▄▄▀───▀▄ + ▀────────▀▀ """) + + time.sleep(3) + print('and all of a sudden you see a cyborg in the distance') + time.sleep(2) + print("""β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β”Œβ”€β”€β”€β”€β”€β”β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘ +β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β”‚β–‘β–Œβ–‘β–Œβ–‘β”‚β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘ +β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β”‚β–‘β–„β–„β–‘β–‘β”‚β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘ +β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β”Œβ”€β”¬β”€β”€β”΄β”€β”¬β”€β”¬β”€β”΄β”€β”€β”¬β”€β”β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘ +β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β”‚β–‘β”œβ”β–‘β–‘β–‘β”‚β–‘β”‚β–‘β–‘β–‘β”Œβ”€β–‘β”‚β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘ +β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β”‚β–‘β”‚β”‚β–‘β–‘β–‘β”‚β–‘β”‚β–‘β–‘β–‘β”‚β”‚β–‘β”‚β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘ +β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β”‚β–‘β”‚β”‚β–‘β–‘β–‘β”œβ”€β”€β–‘β–‘β–‘β”‚β”‚β–‘β”‚β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘ +β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β””β”€β”˜β”œβ”€β”€β”¬β”΄β”€β”΄β”¬β”€β”¬β”˜β””β”€β”˜β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘ +β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β”‚β–‘β–‘β”‚β–‘β–‘β–‘β”‚β–‘β”‚β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘ +β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β”‚β–‘β–‘β”‚β–‘β–‘β–‘β”‚β–‘β”‚β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘ +β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β”Œβ”€β”˜β–‘β–‘β”‚β–‘β–‘β–‘β”‚β–‘β””β”€β”β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘ +β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β””β”€β”€β”€β”€β”˜β–‘β–‘β–‘β””β”€β”€β”€β”˜β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘β–‘""") + time.sleep(3) + print('he has been sent to capture you and take you back to the robots!!!') + + time.sleep(3) + print('three items are infront of you ') + + time.sleep(3) + print("a mech suit") + time.sleep(2) + print("""───────────▄▄▄▄▄▄▄▄▄─────────── +β”€β”€β”€β”€β”€β”€β”€β”€β–„β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–„β”€β”€β”€β”€β”€β”€β”€β”€ +β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ”€β”€β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ”€β”€β–ˆβ–ˆβ–ˆβ–ˆβ–ˆ +β–β–ˆβ–ˆβ–ˆβ–ˆβ–Œβ”€β–€β–ˆβ–ˆβ–ˆβ–„β”€β”€β”€β”€β”€β”€β”€β–„β–ˆβ–ˆβ–ˆβ–€β”€β–β–ˆβ–ˆβ–ˆβ–ˆβ–Œ +β”€β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–„β”€β”€β–€β–ˆβ–ˆβ–ˆβ–„β”€β”€β”€β–„β–ˆβ–ˆβ–ˆβ–€β”€β”€β–„β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ”€ +β”€β–β–ˆβ–ˆβ–€β–ˆβ–ˆβ–ˆβ–„β”€β”€β–€β–ˆβ–ˆβ–ˆβ–„β–ˆβ–ˆβ–ˆβ–€β”€β”€β–„β–ˆβ–ˆβ–ˆβ–€β–ˆβ–ˆβ–Œβ”€ +β”€β”€β–ˆβ–ˆβ–ˆβ–„β–€β–ˆβ–ˆβ–ˆβ–„β”€β”€β–€β–ˆβ–ˆβ–ˆβ–€β”€β”€β–„β–ˆβ–ˆβ–ˆβ–€β–„β–ˆβ–ˆβ–ˆβ”€β”€ +β”€β”€β–β–ˆβ–„β–€β–ˆβ–„β–€β–ˆβ–ˆβ–ˆβ”€β–„β”€β–€β”€β–„β”€β–ˆβ–ˆβ–ˆβ–€β–„β–ˆβ–€β–„β–ˆβ–Œβ”€β”€ +β”€β”€β”€β–ˆβ–ˆβ–ˆβ–„β–€β–ˆβ–„β–ˆβ–ˆβ”€β–ˆβ–ˆβ–„β–ˆβ–ˆβ”€β–ˆβ–ˆβ–„β–ˆβ–€β–„β–ˆβ–ˆβ–ˆβ”€β”€β”€ +β”€β”€β”€β”€β–€β–ˆβ–ˆβ–ˆβ–„β–€β–ˆβ–ˆβ”€β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ”€β–ˆβ–ˆβ–€β–„β–ˆβ–ˆβ–ˆβ–€β”€β”€β”€β”€ +β”€β”€β”€β–ˆβ–„β”€β–€β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ”€β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ”€β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–€β”€β–„β–ˆβ”€β”€β”€ +β”€β”€β”€β–ˆβ–ˆβ–ˆβ”€β”€β”€β”€β”€β”€β”€β”€β–ˆβ–ˆβ–ˆβ”€β”€β”€β”€β”€β”€β”€β”€β–ˆβ–ˆβ–ˆβ”€β”€β”€ +β”€β”€β”€β–ˆβ–ˆβ–ˆβ–„β”€β”€β”€β”€β–„β–ˆβ”€β–ˆβ–ˆβ–ˆβ”€β–ˆβ–„β”€β”€β”€β”€β–„β–ˆβ–ˆβ–ˆβ”€β”€β”€ +β”€β”€β”€β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ”€β–„β–ˆβ–ˆβ–ˆβ”€β–ˆβ–ˆβ–ˆβ”€β–ˆβ–ˆβ–ˆβ–„β”€β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ”€β”€β”€ +β”€β”€β”€β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ”€β–ˆβ–ˆβ–ˆβ–ˆβ”€β–ˆβ–ˆβ–ˆβ”€β–ˆβ–ˆβ–ˆβ–ˆβ”€β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ”€β”€β”€ +β”€β”€β”€β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ”€β–ˆβ–ˆβ–ˆβ–ˆβ”€β–ˆβ–ˆβ–ˆβ”€β–ˆβ–ˆβ–ˆβ–ˆβ”€β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ”€β”€β”€ +β”€β”€β”€β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ”€β–ˆβ–ˆβ–ˆβ–ˆβ”€β–ˆβ–ˆβ–ˆβ”€β–ˆβ–ˆβ–ˆβ–ˆβ”€β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ”€β”€β”€ +β”€β”€β”€β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ”€β–ˆβ–ˆβ–ˆβ–ˆβ–„β–„β–„β–„β–„β–ˆβ–ˆβ–ˆβ–ˆβ”€β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ”€β”€β”€ +β”€β”€β”€β”€β–€β–ˆβ–ˆβ–ˆβ”€β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ”€β–ˆβ–ˆβ–ˆβ–€β”€β”€β”€β”€ +β”€β”€β”€β”€β”€β”€β–€β–ˆβ”€β–ˆβ–ˆβ–ˆβ”€β–„β–„β–„β–„β–„β”€β–ˆβ–ˆβ–ˆβ”€β–ˆβ–€β”€β”€β”€β”€β”€β”€ +β”€β”€β”€β”€β”€β”€β”€β”€β”€β–€β–ˆβ–Œβ–β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–Œβ–β–ˆβ–€β”€β”€β”€β”€β”€β”€β”€β”€β”€ +β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€ +""") + + time.sleep(3) + print("tank") + time.sleep(2) + print("""β–‘β–‘β–‘β–‘β–‘β–‘β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆ ]β–„β–„β–„β–„β–„β–„β–„β–„ + β–‚β–„β–…β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–…β–„β–ƒβ–‚ + Iβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆ]. + β—₯βŠ™β–²βŠ™β–²βŠ™β–²βŠ™β–²βŠ™β–²βŠ™β–²βŠ™β—€... + """) + + time.sleep(3) + print('bomb') + + time.sleep(2) + print("""´´´´´´´´´´´´´´´´´´´´´´´$¢´´´´´¢´´´´´¢’ + ´´´´´´´´´´´¢¢¢¢¢¢¢´´´´´´´¢’´´´¢´´´ø¢ + ´´´´´´´´´´¢¢´´´´ø¢¢¢´´´´´´oø´´ø´´øo + ´´´´´´´´´´¢7´´´´´´´¢¢¢´´´´´´1´´´1´´´´1o + ´´´´´´´¢¢¢¢¢¢¢´´´´´´´¢¢¢7´´´´´´´´1oΒΆΒΆΒΆΓΈ + ´´´´´´´¢¢¢¢¢¢¢´´´´´´´´´¢¢¢¢¢¢¢¢´´1 + ´´´´´o¢¢¢¢¢¢¢¢¢ø´´´´´´´´´´´´´´´´´´o$Β’ + ´´´¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢´´´´´´´´´´’´´1ø´´´1ΒΆΒΆ + ´´¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢o´´´´´´´1$´´´¢ + ´¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢´´´´´´´¢´´´´oΒΆΒ΄ + ´¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢´´´´´¢¢ + ´´¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢´ + ´´´¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢¢´ + ´´´´´¢¢¢¢¢¢¢¢¢¢¢¢´ + ´´´´´´´¢¢¢¢¢¢¢¢ + """) +# question_one = '' + # while question_one != 'run away' and question_one != 'shoot robot in head': + items = '' + while items != 'tank' and items != 'bomb' and items != 'mech suit': + items = input("which item do you choose - the mech suit, tank or bomb : ") + + if (items == 'tank'): + time.sleep(3) + print('oh no the cyborg has ripped through the tank') + time.sleep(3) + print('you are running away to find safety') + time.sleep(3) + print('but the cyborg has seen you and captured you') + + elif (items == 'bomb'): + time.sleep(3) + print('you throw the bomb and it exlodes') + time.sleep(3) + print('but it doesnt even lay a scratch on him') + time.sleep(3) + print('because he is made from vibranium') + time.sleep(3) + print('you are instantly captured now') + + elif (items == "mech suit"): + time.sleep(3) + print('you are now in the mech suit') + time.sleep(3) + print('the cyborg is running towards you') + time.sleep(3) + print('this suit is highly advanced and gives you a ton of diffrent options') + suit_options() +# question_one = '' + # while question_one != 'run away' and question_one != 'shoot robot in head': +def combat_option(): + combat_moves = '' + while combat_moves != 'right hook' and combat_moves != 'head butt': + time.sleep(3) + combat_moves = input("do you want to throw a right hook or head butt: ") + if (combat_moves == 'right hook'): + time.sleep(3) + print('wow your right hook to the cyborg was so DEVASTATING that it has killed him') + level3() + elif (combat_moves == 'head butt'): + time.sleep(3) + print('incredible your head butt has KNOCKED OUT the cyborg') + level3() + +def suit_options(): + time.sleep(3) + select_option = '' + while select_option != 'rocket fist' and select_option != 'missile' and select_option != 'body slam': + select_option = input("what would you like to use: rocket fist, missile, body slam: ") + + if (select_option == "rocket fist"): + time.sleep(3) + print('good the cyborg is extremely disorientated') + combat_option() + # def combat_option(): + # combat_moves = '' + # while combat_moves != 'right hook' and combat_moves != 'head butt': + # time.sleep(3) + # combat_moves = input("do you want to throw a right hook or head butt: ") + # if (combat_moves == 'right hook'): + # time.sleep(3) + # print('wow your right hook to the cyborg was so DEVASTATING that it has killed him') + # level3() + # elif (combat_moves == 'head butt'): + # time.sleep(3) + # print('incredible your head butt has KNOCKED OUT the cyborg') + # level3() + + elif (select_option == 'missile'): + time.sleep(3) + print('oh no the cyborg is made from vibranium') + time.sleep(3) + print('the cyborg punches you and takes you back to the robots') + elif (select_option == 'body slam'): + time.sleep(3) + print('the cyborg has been knocked unconsious good job') + time.sleep(3) + print('u have enough time to run') + level3() + +def level3(): + time.sleep(3) + print('after that battle you are completely drained and are trying to find safety') + time.sleep(3) + print('after walking for hours you come across a strange looking object') + time.sleep(3) + print('the strange looking object looks like a computer from the past') + time.sleep(4) + print(""" +β–β–“β–ˆβ–€β–€β–€β–€β–€β–€β–€β–€β–€β–ˆβ–“β–Œβ–‘β–„β–„β–„β–„β–„β–‘ +β–β–“β–ˆβ–‘β–‘β–€β–‘β–‘β–€β–„β–‘β–‘β–ˆβ–“β–Œβ–‘β–ˆβ–„β–„β–„β–ˆβ–‘ +β–β–“β–ˆβ–‘β–‘β–„β–‘β–‘β–„β–€β–‘β–‘β–ˆβ–“β–Œβ–‘β–ˆβ–„β–„β–„β–ˆβ–‘ +β–β–“β–ˆβ–„β–„β–„β–„β–„β–„β–„β–„β–„β–ˆβ–“β–Œβ–‘β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–‘ +β–‘β–‘β–‘β–‘β–„β–„β–ˆβ–ˆβ–ˆβ–„β–„β–‘β–‘β–‘β–‘β–‘β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–‘ + + """) + time.sleep(3) + print('there is a video recording on it') +# question_one = '' + # while question_one != 'run away' and question_one != 'shoot robot in head': + message = '' + while message != 'yes' and message != 'no': + message = input('Do you want to play the recording: ') + if message == 'yes': + time.sleep(2) + print('...') + time.sleep(2) + print('..') + time.sleep(2) + print('.') + time.sleep(3) + print('Computer: We have found a way to end the war') + time.sleep(3) + print('We have ...') + time.sleep(5) + print("Computer: We have created an algorithm which can search and terminate all AI organisms") + time.sleep(2) + print('Computer: OH NO') + time.sleep(3) + print('Computer: the machines have invaded our base') + time.sleep(3) + print("/@)|Β¬!}{") + algorithm() + +def algorithm(): + time.sleep(3) + initiate = '' + while initiate != 'start' and initiate != 'terminate': + initiate = input('If you wish to initiate this algorithm please type start or if you wish to terminate the algorithm please type terminate: ') + if (initiate == 'start'): + time.sleep(3) + print('....') + time.sleep(3) + print('beep') + time.sleep(3) + print('boop') + time.sleep(3) + print('boop') + time.sleep(3) + print('beep') + time.sleep(3) + print('Congratulations you have sucessfully killed all of the robots in this timeline !!!!!!') + + elif (initiate == 'terminate'): + time.sleep(3) + print('WTF !!!!') + # option to play again at completion of game diff --git a/scripts/Tic-Tac-Toe/main.py b/scripts/Tic-Tac-Toe/main.py new file mode 100644 index 0000000..91e79a9 --- /dev/null +++ b/scripts/Tic-Tac-Toe/main.py @@ -0,0 +1,40 @@ +def check(m): + if ( (m[0][0] == m[0][1] == m[0][2] != 0) + or (m[1][0] == m[2][0] == m[0][0] != 0 ) + or (m[0][0] == m[1][1] == m[2][2] != 0) + or (m[1][0] == m[1][2] == m[1][2] != 0) + or (m[2][0] == m[2][1] == m[2][2] != 0) + or (m[0][1] == m[1][1] == m[2][1] != 0) + or (m[0][2] == m[1][2] == m[2][2] != 0) + or (m[0][2] == m[1][1] == m[2][0] != 0) ): + return 1 + else: + return 0 + + +def display(m): + for i in range(3): + for j in range(3): + print(m[i][j],end = "\t") + print("\n") + + +a=input("Want to play tic-tac-toe?y/n: ") +if a== "y": + m = [[0, 0, 0], [0, 0, 0], [0, 0, 0]] + while True: + i,j= int(input("X: enter row no.")), int(input("enter column no.")) + m[i][j]="X" + display(m) + if check(m)== 1: + print("Congratulations you won!") + break + + i,j= int(input("O: enter row no.")), int(input("enter column no.")) + m[i][j]="O" + display(m) + if check(m)== 1: + print("Congratulations you won!") + break +else: + print("Good Bye!") \ No newline at end of file diff --git a/scripts/Tic-Tac-Toe/readme.md b/scripts/Tic-Tac-Toe/readme.md new file mode 100644 index 0000000..456a99c --- /dev/null +++ b/scripts/Tic-Tac-Toe/readme.md @@ -0,0 +1,5 @@ +Tic Tac Toe with PYTHON + +#Steps : +Run - python main.py +Have a fun time!! diff --git a/scripts/Voice_Assited_Musicplayer/.gitignore b/scripts/Voice_Assited_Musicplayer/.gitignore new file mode 100644 index 0000000..71f6e2b --- /dev/null +++ b/scripts/Voice_Assited_Musicplayer/.gitignore @@ -0,0 +1,49 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +# C extensions +*.so + +# Distribution / packaging +bin/ +build/ +develop-eggs/ +dist/ +eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +*.egg-info/ +.installed.cfg +*.egg + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +.tox/ +.coverage +.cache +nosetests.xml +coverage.xml + +# Translations +*.mo + +# Mr Developer +.mr.developer.cfg +.project +.pydevproject + +# Rope +.ropeproject + +# Django stuff: +*.log +*.pot + +# Sphinx documentation +docs/_build/ \ No newline at end of file diff --git a/scripts/Voice_Assited_Musicplayer/README.md b/scripts/Voice_Assited_Musicplayer/README.md new file mode 100644 index 0000000..cf2a96b --- /dev/null +++ b/scripts/Voice_Assited_Musicplayer/README.md @@ -0,0 +1,33 @@ +# Voice_assisted_musicplayer +This project contains Ai powered voice activated music player system. +The system supports mp3,wav and mpeg audio files. +It can also play songs according to yor emotion(files need to be stored in voice_assisted_musicplayer/Songs/[-] **folder name according to your choice**) +It can also load music files form other directories. + +To run the program execute the assistant.py file and say the desired song according to your mood +# preview +![image](https://user-images.githubusercontent.com/115635715/195788102-1906c8b2-edd7-456b-9a10-7130bfb19704.png) + +![image](https://user-images.githubusercontent.com/115635715/195788334-144aab6a-bb67-42a1-a427-63ceef34a8fe.png) + + +## Features of the music player: +-backward button
+-forward button
+-pause/play button
+-progress bar
+-volume button
+-delete button
+-load file button
+ + +## Requirements:
+pyttsx3
+SpeechRecognition
+os
+datetime
+pickle
+tkinter
+pygame
+mutagen
+time
diff --git a/scripts/Voice_Assited_Musicplayer/Songs/happy/Happy (from Despicable Me 2) G I R L - 320Kbps.mp3 b/scripts/Voice_Assited_Musicplayer/Songs/happy/Happy (from Despicable Me 2) G I R L - 320Kbps.mp3 new file mode 100644 index 0000000..f9caed2 Binary files /dev/null and b/scripts/Voice_Assited_Musicplayer/Songs/happy/Happy (from Despicable Me 2) G I R L - 320Kbps.mp3 differ diff --git a/scripts/Voice_Assited_Musicplayer/Songs/sad/Lewis Capaldi - Before You Go - Copy (2).mp3 b/scripts/Voice_Assited_Musicplayer/Songs/sad/Lewis Capaldi - Before You Go - Copy (2).mp3 new file mode 100644 index 0000000..ad56a0d Binary files /dev/null and b/scripts/Voice_Assited_Musicplayer/Songs/sad/Lewis Capaldi - Before You Go - Copy (2).mp3 differ diff --git a/scripts/Voice_Assited_Musicplayer/assistant.py b/scripts/Voice_Assited_Musicplayer/assistant.py new file mode 100644 index 0000000..bbe1d9c --- /dev/null +++ b/scripts/Voice_Assited_Musicplayer/assistant.py @@ -0,0 +1,84 @@ +import pyttsx3 +import speech_recognition as sr +import datetime +import os +from player import run + +engine = pyttsx3.init('sapi5') +voices = engine.getProperty('voices') +engine.setProperty('voice', voices[1].id) + +playlist = [] + + +def speak(audio): + engine.say(audio) + engine.runAndWait() + + +def bot_answer(answer): + print("assistant:", answer) + + +def greetings(): + global playlist + hour = int(datetime.datetime.now().hour) + if(hour >= 0 and hour < 12): + speak("good morning") + elif hour >= 12 and hour < 18: + speak("good afternoon") + else: + speak("good evening") + + speak("welcome to py-Musicplayer") + bot_answer('say playlist name to play') + playlist = os.listdir('Songs') + bot_answer(playlist) + + +def action_taker(): + r = sr.Recognizer() + with sr.Microphone() as source: + print("Listening...") + speak("listening") + r.adjust_for_ambient_noise(source, duration=5) + audio = r.listen(source) + + try: + print("recognizing...") + speak("recognizing") + command = r.recognize_google(audio) + print(f'User:{command}\n"') + + except Exception as e: + print(e) + bot_answer("Say that again please....") + + return "None" + return command + + +greetings() +while True: + command = action_taker().lower() + song_playlist = list(map(str.lower, playlist)) + + if any(command in s for s in song_playlist): + get_ind = song_playlist.index(command) + playlist_name = playlist.index(command) + playlist_name = playlist[get_ind] + playlist_dir = os.path.abspath("./Songs/"+playlist_name) + bot_answer('Playing: '+playlist_name + + 'playlist for you with Musicplayer') + speak('playing:'+playlist_name+'playlist for you with music player') + print(playlist_dir) + run(playlist_dir) + elif 'stop' in command: + speak('good bye,have a good day') + bot_answer('exit') + engine.stop() + break + else: + bot_answer('did not get the playlist...') + speak('did not get the playlist') + print(playlist) diff --git a/scripts/Voice_Assited_Musicplayer/images/image2.gif b/scripts/Voice_Assited_Musicplayer/images/image2.gif new file mode 100644 index 0000000..5c621b0 Binary files /dev/null and b/scripts/Voice_Assited_Musicplayer/images/image2.gif differ diff --git a/scripts/Voice_Assited_Musicplayer/images/next.gif b/scripts/Voice_Assited_Musicplayer/images/next.gif new file mode 100644 index 0000000..5fca996 Binary files /dev/null and b/scripts/Voice_Assited_Musicplayer/images/next.gif differ diff --git a/scripts/Voice_Assited_Musicplayer/images/pause.gif b/scripts/Voice_Assited_Musicplayer/images/pause.gif new file mode 100644 index 0000000..ff7a306 Binary files /dev/null and b/scripts/Voice_Assited_Musicplayer/images/pause.gif differ diff --git a/scripts/Voice_Assited_Musicplayer/images/play.gif b/scripts/Voice_Assited_Musicplayer/images/play.gif new file mode 100644 index 0000000..7ece421 Binary files /dev/null and b/scripts/Voice_Assited_Musicplayer/images/play.gif differ diff --git a/scripts/Voice_Assited_Musicplayer/images/previous.gif b/scripts/Voice_Assited_Musicplayer/images/previous.gif new file mode 100644 index 0000000..e5bccfa Binary files /dev/null and b/scripts/Voice_Assited_Musicplayer/images/previous.gif differ diff --git a/scripts/Voice_Assited_Musicplayer/player.py b/scripts/Voice_Assited_Musicplayer/player.py new file mode 100644 index 0000000..941ab41 --- /dev/null +++ b/scripts/Voice_Assited_Musicplayer/player.py @@ -0,0 +1,293 @@ +import time +import os +import pickle +import tkinter as tk +from tkinter import Label, filedialog +from tkinter import PhotoImage +from pygame import mixer +from mutagen.mp3 import MP3 +import tkinter.ttk as ttk +from tkinter import messagebox + + +class Player(tk.Frame): + def __init__(self, song_path, master=None): + super().__init__(master) + self.master = master + self.song_path = song_path + self.pack() + mixer.init() + + if os.path.exists('songs.pickle'): + with open('songs.pickle', 'rb') as f: + self.playlist = pickle.load(f) + else: + self.playlist = [] + + self.current = 0 + self.paused = True + self.played = False + self.song_length = 0 + + self.page_layouts() + self.track_config() + self.control_widgets() + self.song_list() + self.retrieve_songs2() + + def page_layouts(self): + self.track = tk.LabelFrame(self, text='Song Track', + font=("times new roman", 15, "bold"), + bg="black", fg="white", bd=5, relief=tk.GROOVE) + self.track.config(width=400, height=300) + self.track.grid(row=0, column=0, padx=1) + + self.tracklist = tk.LabelFrame(self, text=f'PlayList - {str(len(self.playlist))}', + font=("times new roman", 12, "bold"), + bg="black", fg="white", bd=5, relief=tk.GROOVE) + self.tracklist.config(width=190, height=200) + self.tracklist.grid(row=0, column=1, pady=1) + + self.controls = tk.LabelFrame(self, + font=("times new roman", 15, "bold"), + bg="black", fg="white", bd=2, relief=tk.GROOVE) + self.controls.config(width=410, height=80) + self.controls.grid(row=2, column=0, pady=1, padx=1) + + self.music_slider = tk.LabelFrame(self, + font=("times new roman", 15, "bold"), + bg="black", fg="white", bd=5, relief=tk.GROOVE) + self.music_slider.config(width=410, height=80) + self.music_slider.grid(row=3, column=0, pady=1, padx=1) + + self.func = tk.LabelFrame(self, + font=("times new roman", 12, "bold"), + bg="black", fg="white", bd=5, relief=tk.GROOVE) + self.func.config(width=250, height=210) + self.func.grid(row=3, column=1) + + self.promo = tk.LabelFrame(self, + bg="black", fg="white", bd=5, relief=tk.GROOVE) + self.promo.config(width=50, height=50) + self.promo.grid(row=2, column=1) + + def track_config(self): + self.views = tk.Label(self.track, image=img) + self.views.configure(width=400, height=240) + self.views.grid(row=0, column=0) + + self.musictrack = tk.Label(self.track, font=("times new roman", 16, "bold"), + bg="white", fg="dark blue") + self.musictrack['text'] = 'MP3 Player' + self.musictrack.config(width=30, height=1) + self.musictrack.grid(row=1, column=0, padx=10) + + def control_widgets(self): + self.loading = tk.Button( + self.controls, bg='green', fg='white', font=10) + self.loading['text'] = 'Load Songs' + self.loading['command'] = self.retrieve_songs + self.loading.grid(row=0, column=0, padx=10) + + self.prev = tk.Button(self.controls, image=prev) + self.prev['command'] = self.prev_song + self.prev.grid(row=0, column=1) + + self.pause = tk.Button(self.controls, image=pause) + self.pause['command'] = self.pause_song + self.pause.grid(row=0, column=2) + + self.next = tk.Button(self.controls, image=next_) + self.next['command'] = self.next_song + self.next.grid(row=0, column=3) + + self.volume = tk.DoubleVar(self) + self.slider = tk.Scale(self.controls, from_=0, + to=10, orient=tk.HORIZONTAL) + self.slider['variable'] = self.volume + self.slider.set(5) + mixer.music.set_volume(1) + self.slider['command'] = self.change_volume + self.slider.grid(row=0, column=4, padx=10, pady=4) + + self.mu_slider = ttk.Scale(self.music_slider, from_=0, to=100, + orient=tk.HORIZONTAL, value=0, length=390) + self.mu_slider.grid(pady=20, padx=10) + + self.status_bar = Label(self.music_slider, text="Time Elapsed: 0/0") + self.status_bar.grid(pady=1) + + self.delet = tk.Button(self.func, text="Delete", bg='green', fg='white', font=15) + self.delet['command'] = self.delete_songs + self.delet.grid(row=0, column=1, padx=39, pady=29) + + self.prom = tk.Label(self.promo, text="artgoblin's work", font=("times new roman", 10, "bold", "italic"), + bg="grey", fg="black") + self.prom.grid(row=0, column=2, padx=20, pady=12) + + def song_list(self): + self.scrollbar = tk.Scrollbar(self.tracklist, orient=tk.VERTICAL) + self.scrollbar.grid(row=0, column=1, rowspan=5, sticky='ns') + + self.list = tk.Listbox(self.tracklist, selectmode=tk.SINGLE, + yscrollcommand=self.scrollbar.set, selectbackground='sky blue') + self.enum_songs() + self.list.config(height=17) + self.list.bind('', self.play_song) + + self.scrollbar.config(command=self.list.yview) + self.list.grid(row=0, column=0, rowspan=5) + + def retrieve_songs2(self): + self.songlist2 = [] + os.chdir(self.song_path) + + for files in os.listdir(self.song_path): + try: + if files.endswith(".mp3"): + + self.songlist2.append(files) + elif files.endswith(".wav"): + + self.songlist2.append(files) + elif files.endswith(".mpeg"): + + self.songlist2.append(files) + except: + pass + + with open('songs2.pickle', 'wb') as f: + pickle.dump(self.songlist2, f) + self.playlist = self.songlist2 + self.tracklist['text'] = f'PlayList - {str(len(self.playlist))}' + self.list.delete(0, tk.END) + + self.enum_songs() + + def retrieve_songs(self): + self.songlist = [] + + directory = filedialog.askdirectory() + for root_, dirs, files in os.walk(directory): + for file in files: + if os.path.splitext(file)[1] == '.mp3': + path = (root_ + '/' + file).replace('\\', '/') + self.songlist.append(path) + elif os.path.splitext(file)[1] == '.mpeg': + path = (root_ + '/' + file).replace('\\', '/') + self.songlist.append(path) + elif os.path.splitext(file)[1] == '.wav': + path = (root_ + '/' + file).replace('\\', '/') + self.songlist.append(path) + + with open('songs.pickle', 'wb') as f: + pickle.dump(self.songlist, f) + self.playlist = self.songlist + self.tracklist['text'] = f'PlayList - {str(len(self.playlist))}' + self.list.delete(0, tk.END) + self.enum_songs() + + def enum_songs(self): + for index, song in enumerate(self.playlist): + self.list.insert(index, os.path.basename(song)) + + def play_song(self, event=None): + if event is not None: + self.current = self.list.curselection()[0] + for i in range(len(self.playlist)): + self.list.itemconfigure(i, bg="white") + + print(self.playlist[self.current]) + mixer.music.load(self.playlist[self.current]) + self.m = mixer.music.load(self.playlist[self.current]) + self.musictrack['anchor'] = 'w' + self.musictrack['text'] = os.path.basename(self.playlist[self.current]) + + self.pause['image'] = play + self.paused = False + self.played = True + self.list.activate(self.current) + self.list.itemconfigure(self.current, bg='sky blue') + + mixer.music.play() + self.update_progress() + + def update_progress(self): + song_mut = MP3(self.playlist[self.current]) + self.song_length = song_mut.info.length + slider_position = int(self.song_length) + self.mu_slider.config(to=slider_position) + pos_ms = mixer.music.get_pos() / 1000 + self.mu_slider.config(value=pos_ms) + clock = time.strftime('%M:%S', time.gmtime(self.song_length)) + clock2 = time.strftime('%M:%S', time.gmtime(pos_ms)) + self.status_bar.config(text=f'Time Elapsed: {clock2} / {clock} ') + self.after(1000, self.update_progress) + + def pause_song(self): + if not self.paused: + self.paused = True + mixer.music.pause() + self.pause['image'] = pause + else: + if self.played == False: + self.play_song() + self.paused = False + mixer.music.unpause() + self.pause['image'] = play + + def prev_song(self): + if self.current > 0: + self.current -= 1 + else: + self.current = 0 + self.list.itemconfigure(self.current + 1, bg='white') + self.play_song() + + def next_song(self): + if self.current < len(self.playlist) - 1: + self.current += 1 + else: + self.current = 0 + self.list.itemconfigure(self.current - 1, bg='white') + self.play_song() + + def change_volume(self, event=None): + self.v = self.volume.get() + mixer.music.set_volume(self.v / 10) + + def delete_songs(self, event=None): + items = map(int, self.list.curselection()) + for item in items: + self.list.delete(item) + self.playlist.pop(item) + self.tracklist['text'] = 'Total Songs: ' + str(len( self.playlist)) + + + + + +def run(song_path): + global img, prev, play, next_, pause + root = tk.Tk() + root.title('MP3 Player') + root.geometry("572x458") + + def on_closing(): + + if messagebox.askokcancel("Quit", "Do you want to quit?"): + + mixer.music.stop() + root.destroy() + root.protocol("WM_DELETE_WINDOW", on_closing) + + os.path.join(os.path.curdir, 'file.name') + + img = PhotoImage(file=os.path.join(os.path.curdir, 'images/image2.gif')) + next_ = PhotoImage(file=os.path.join(os.path.curdir, 'images/next.gif')) + prev = PhotoImage(file=os.path.join(os.path.curdir, 'images/previous.gif')) + play = PhotoImage(file=os.path.join(os.path.curdir, 'images/play.gif')) + pause = PhotoImage(file=os.path.join(os.path.curdir, 'images/pause.gif')) + + app = Player(song_path, master=root) + app.mainloop() \ No newline at end of file diff --git a/scripts/checksum/README.md b/scripts/checksum/README.md new file mode 100644 index 0000000..4737b31 --- /dev/null +++ b/scripts/checksum/README.md @@ -0,0 +1,29 @@ +# Checksum + +This script can generate checksums from md5, sha1, sha224, sha256, sha384, and sha512. +Additionally, for another layer of secret it can create signed checksums using HMAC and a provided secret. +Lastly, to provide actual value to the script it can also verify if a checksum matches the file it was generated from. + +Examples: + +Generate a sha1 checksum +``` +python checksum.py -H sha1 -f test.txt -g +# b29d28bc5239dbc2689215811b2a73588609f301 +``` + +Generate a signature +``` +python checksum.py -f test.txt -s secret +# 3YYMCthY4hFxQj1wPF3uAg== +``` + +Verify a checksum +``` +python -H sha1 -f test.txt -v b29d28bc5239dbc2689215811b2a73588609f301 +``` + +Verify a signature +``` +python -f test.txt -s secret -v 3YYMCthY4hFxQj1wPF3uAg== +``` \ No newline at end of file diff --git a/scripts/checksum/checksum.py b/scripts/checksum/checksum.py new file mode 100644 index 0000000..eca87d5 --- /dev/null +++ b/scripts/checksum/checksum.py @@ -0,0 +1,92 @@ +import os +import sys +import hmac +import base64 +import hashlib +import argparse + +def checksum(hash, seed=None): + hashs = { + "md5": hashlib.md5, + "sha1": hashlib.sha1, + "sha224": hashlib.sha224, + "sha256": hashlib.sha256, + "sha384": hashlib.sha384, + "sha512": hashlib.sha512 + } + method = hashs.get(hash, hashlib.md5)() + if seed is not None: + method.update(seed.encode("utf-8")) + else: + method.update(os.urandom(32)) + return method.hexdigest() + +def sign(hash, message, secret): + hashs = { + "md5": hashlib.md5, + "sha1": hashlib.sha1, + "sha224": hashlib.sha224, + "sha256": hashlib.sha256, + "sha384": hashlib.sha384, + "sha512": hashlib.sha512 + } + method = hashs.get(hash, hashlib.md5)() + digest = hmac.new(secret.encode("utf-8"), + msg=message.encode(), + digestmod=hashs.get(hash, hashlib.md5)).digest() + signature = base64.b64encode(digest).decode("utf-8") + return signature + +def verify(hash, input, check, secret=None): + challenge = None + if secret is not None: + challenge = sign(hash, input, secret) + else: + challenge = checksum(hash, input) + return "Valid! :D" if challenge == check else "Invalid :(" + +def main(): + description = "Checksum tool to generate, sign, and verify" + parser = argparse.ArgumentParser(description=description) + parser.add_argument("-g", "--generate", dest="generate", + action="store_true", help="Generates checksum") + parser.add_argument("-s", "--sign", dest="sign", default=None, + help="Signs input using HMAC") + parser.add_argument("-H", "--hash", dest="hash", default="md5", + help="Hash method (md5, sha1, sha224, sha256, sha384, sha512)") + parser.add_argument("-v", "--verify", dest="verify", default=None, + help="Checksum or signature used to verify against file / stdin") + parser.add_argument("-f", "--file", dest="file", + type=argparse.FileType("r"), default=sys.stdin, + help="File / stdin to create checksum, make signature, or verify from") + arguments = parser.parse_args() + + if arguments.verify is not None: + if not arguments.file: + print("Missing input to generate checksum from") + sys.exit(1) + if arguments.sign is not None: + print(verify(arguments.hash, arguments.file.read(), + arguments.verify, arguments.sign)) + return + else: + print(verify(arguments.hash, arguments.file.read(), + arguments.verify)) + return + elif arguments.generate: + if not arguments.file: + print("Missing input to generate checksum from") + sys.exit(1) + print(checksum(arguments.hash, arguments.file.read())) + return + elif arguments.sign is not None: + if not arguments.file: + print("Missing input to generate checksum from") + sys.exit(1) + print(sign(arguments.hash, arguments.file.read(), arguments.sign)) + return + print("Missing function (-g, -s, -v)") + sys.exit(1) + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/scripts/csv_to_json/README.md b/scripts/csv_to_json/README.md deleted file mode 100644 index 5f2d167..0000000 --- a/scripts/csv_to_json/README.md +++ /dev/null @@ -1,8 +0,0 @@ -# CSV to EXCEL -This simple script will convert CSV file to json. - -## Usage - -* requires pandas -* Use `pip install pandas` -* Run `python script.py` diff --git a/scripts/csv_to_json/script.py b/scripts/csv_to_json/script.py deleted file mode 100644 index 7f8e6b0..0000000 --- a/scripts/csv_to_json/script.py +++ /dev/null @@ -1,15 +0,0 @@ -import pandas as pd -import os,json - -def csv_to_json(): - file = input("Enter csv path: ") - df = pd.read_csv(file) - name=os.path.basename(file).replace("csv","json") - data =df.to_dict("r") - with open(file,'w') as f: - json.dump(df, d) - - print(f"file saved at {name}") - - -csv_to_json() \ No newline at end of file diff --git a/scripts/fetching_system_information/README.md b/scripts/fetching_system_information/README.md new file mode 100644 index 0000000..d4e6d86 --- /dev/null +++ b/scripts/fetching_system_information/README.md @@ -0,0 +1,8 @@ +# Fetching System Information +This is a simple script that fetches system information for your system.(Windows) + +## Improvements +Script for fetching all systems information +## Usage +1. Clone the repo +2. Run python script.py \ No newline at end of file diff --git a/scripts/fetching_system_information/script.py b/scripts/fetching_system_information/script.py new file mode 100644 index 0000000..35cae6e --- /dev/null +++ b/scripts/fetching_system_information/script.py @@ -0,0 +1,11 @@ +import wmi + +c = wmi.WMI() +my_system = c.Win32_ComputerSystem()[0] + +print(f"Manufacturer: {my_system.Manufacturer}") +print(f"Model: {my_system. Model}") +print(f"Name: {my_system.Name}") +print(f"NumberOfProcessors: {my_system.NumberOfProcessors}") +print(f"SystemType: {my_system.SystemType}") +print(f"SystemFamily: {my_system.SystemFamily}") diff --git a/scripts/typing-speed-checker/README.md b/scripts/typing-speed-checker/README.md deleted file mode 100644 index 1c1c9db..0000000 --- a/scripts/typing-speed-checker/README.md +++ /dev/null @@ -1,3 +0,0 @@ -# Typing Speed Checker - -You can check someone's typing speed with this simple Python script. It uses python's inbuild time module to test the user's typing speed. diff --git a/scripts/typing-speed-checker/main.py b/scripts/typing-speed-checker/main.py deleted file mode 100644 index 35be6fb..0000000 --- a/scripts/typing-speed-checker/main.py +++ /dev/null @@ -1,32 +0,0 @@ -from time import time - -print("PARAGRAPH:") -print() - -typingString = "Medical transcription, also known as MT, is an allied health profession dealing with the process of transcribing voice-recorded medical reports that are dictated by physicians, nurses and other healthcare practitioners. Medical reports can be voice files, notes taken during a lecture, or other spoken material." - -words = len(typingString.split()) - -print(typingString) - -print("\nAfter finishing the test, press the enter key to see your time and speed (in WPM)") -input("\nPress any key to Start:") - -try: - print("\nTimer Started\n") - start = time() - t = input() - end = time() - if t == typingString: - total = round(end - start, 2) - print("\nCongrats! You typed everything correctly.") - print("You took was %s seconds" % total) - total = int(total) / 60 - print("Your speed was %s wpm" % (str(words // total))) - - else: - print("\nWrongly entered") - print("Try again") - -except KeyboardInterrupt: - print("") \ No newline at end of file diff --git a/scripts/wifi_password_checker/README.md b/scripts/wifi_password_checker/README.md new file mode 100644 index 0000000..cc5c706 --- /dev/null +++ b/scripts/wifi_password_checker/README.md @@ -0,0 +1,9 @@ +# Wifi Passwords +This is a simple script that fetches all the saved passwords. + +## Improvements +Generating a QR code to easily connect mobile devices. + +## Usage +1. Clone the repo +2. Run python script.py \ No newline at end of file diff --git a/scripts/wifi_password_checker/script.py b/scripts/wifi_password_checker/script.py new file mode 100644 index 0000000..c02028f --- /dev/null +++ b/scripts/wifi_password_checker/script.py @@ -0,0 +1,49 @@ +import subprocess +import os +import platform + +pswd_txt = open(f"{os.getlogin()}-{platform.node()}", "w") + +data = subprocess.check_output(['netsh', 'wlan', 'show', 'profiles']).decode('utf-8', errors="backslashreplace").split( + '\n') +profiles = [i.split(":")[1][1:-1] for i in data if "All User Profile" in i] + +pswd_txt.write(f'{"{:<30}| {:<}".format("WIFI", "Password")} \n') +pswd_txt.write(f'{"-" * 50} \n') + +print("{:<30}| {:<}".format('WIFI', 'Password')) +print("-" * 50) + +for i in profiles: + try: + + results = subprocess.check_output(['netsh', 'wlan', 'show', 'profile', i, 'key=clear']).decode('utf-8', + errors="backslashreplace").split( + '\n') + results = [b.split(":")[1][1:-1] for b in results if "Key Content" in b] + + try: + + pswd_txt.write(f'{"{:<30}| {:<}".format(i, results[0])} \n') + pswd_txt.write(f'{"-" * 50} \n') + + print("{:<30}| {:<}".format(i, results[0])) + print("-" * 50) + + + except IndexError: + + pswd_txt.write(f'{"{:<30}| {:<}".format(i, "")} \n') + pswd_txt.write(f'{"-" * 50} \n') + print("{:<30}| {:<}".format(i, "")) + print("-" * 50) + + + except subprocess.CalledProcessError: + + pswd_txt.write(f'{"{:<30}| {:<}".format(i, "ENCODING ERROR")} \n') + pswd_txt.write(f'{"-" * 50} \n') + print("{:<30}| {:<}".format(i, "ENCODING ERROR")) + print("-" * 50) + +pswd_txt.close() \ No newline at end of file diff --git a/scripts/youtube_channel_info/README.md b/scripts/youtube_channel_info/README.md new file mode 100644 index 0000000..1cb7017 --- /dev/null +++ b/scripts/youtube_channel_info/README.md @@ -0,0 +1,8 @@ +# Youtube Channel Info +This is a simple script that fetches info about a youtube channel. + +## Usage +- Clone the repo +- download the requirements +- add the api key and channel id +- run python script.py diff --git a/scripts/youtube_channel_info/script.py b/scripts/youtube_channel_info/script.py new file mode 100644 index 0000000..4c3f14a --- /dev/null +++ b/scripts/youtube_channel_info/script.py @@ -0,0 +1,18 @@ +from googleapiclient.discovery import build + +youtube = build('youtube', 'v3', + developerKey='Enter API key') + +ch_request = youtube.channels().list( + part='statistics', + id='Enter Channel ID') + +ch_response = ch_request.execute() + +sub = ch_response['items'][0]['statistics']['subscriberCount'] +vid = ch_response['items'][0]['statistics']['videoCount'] +views = ch_response['items'][0]['statistics']['viewCount'] + +print("Total Subscriber:- ", sub) +print("Total Number of Videos:- ", vid) +print("Total Views:- ", views)