Merge branch 'avinashkranjan:master' into master

Author: raj3000k

Discord-Bot/main.py

@@ -1,56 +1,52 @@
 import random
-
 import discord
 from discord.ext import commands
 
-# your token here, inside the ""
+# Your token here, inside the ""
 TOKEN = ""
-# channel to send welcome messages to
+# Channel to send welcome messages to
 WELCOME_CHANNEL = "welcome"
-# all the nicknames for the random_nickname command
+# All the nicknames for the random_nickname command
 NICKS = ["example1", "example2", "example3"]
 
-# you can change the prefix here
+# You can change the prefix here
 bot = commands.Bot(command_prefix="!")
 
 
 @bot.event
 async def on_ready():
-    print("bot started")
+    print("Bot started")
 
 
 @bot.event
 async def on_member_join(member):
-    welcome_channel = discord.utils.get(member.guild.channels,
-                                        name=WELCOME_CHANNEL)
-    # feel free to change this message!
-    await welcome_channel.send(
-        f"welcome {member.mention}, please read our rules and have a great time!"
-    )
+    welcome_channel = discord.utils.get(member.guild.channels, name=WELCOME_CHANNEL)
+    # Feel free to change this message!
+    await welcome_channel.send(f"Welcome {member.mention}! Please read our rules and have a great time!")
 
 
 @commands.has_permissions(ban_members=True)
 @bot.command()
 async def ban(ctx, user: discord.Member):
     """Ban the given user"""
     await ctx.guild.ban(user, delete_message_days=0)
-    await ctx.send(f"banned {user}")
+    await ctx.send(f"Banned {user}")
 
 
 @commands.has_permissions(ban_members=True)
 @bot.command()
 async def unban(ctx, user: discord.User):
-    "Unban the given user"
+    """Unban the given user"""
     await ctx.guild.unban(user)
-    await ctx.send(f"unbanned {user}")
+    await ctx.send(f"Unbanned {user}")
 
 
 @commands.has_permissions(kick_members=True)
 @bot.command()
 async def kick(ctx, user: discord.User):
-    "Kick the given user"
+    """Kick the given user"""
     await ctx.guild.kick(user)
-    await ctx.send(f"kicked {user}")
+    await ctx.send(f"Kicked {user}")
 
 
 @bot.command(aliases=["rnick"])
@@ -64,9 +60,9 @@ async def random_nick(ctx):
 @commands.has_permissions(manage_nicknames=True)
 @bot.command(aliases=["change_name"])
 async def change_nick(ctx, user: discord.Member, *, new_nick):
-    """Change somebody elses nickname."""
+    """Change somebody else's nickname"""
     await user.edit(nick=new_nick)
-    await ctx.send(f"Changed the nick of {user.mention} to `{new_nick}`")
+    await ctx.send(f"Changed the nickname of {user.mention} to `{new_nick}`")
 
 
 if __name__ == "__main__":

File-Encrypter/README.md

@@ -0,0 +1,51 @@
+from cryptography.fernet import Fernet
+import os
+import sys
+import argparse
+
+def generate_key():
+	return Fernet.generate_key()
+
+def save_key(key, file_path):
+	# save encryption key to a file
+	with open(file_path,'wb') as f:
+		f.write(key)
+
+def load_key(file_path):
+	with open(file_path,'rb') as f:
+		return f.read()
+
+def encrypt_file(key,file_path):
+	f=Fernet(key)
+	with open(file_path,'rb') as f_input:
+		data = f_input.read()
+	encrypted_data = f.encrypt(data)
+	with open(file_path.split(".")[0]+'.encrypted','wb') as f_output:
+		f_output.write(encrypted_data)
+	os.remove(file_path)
+
+def decrypt_file(key, file_path):
+	f=Fernet(key)
+	with open (file_path,'rb') as f_enc:
+		data = f_enc.read()
+	dec_data = f.decrypt(data)
+	with open(file_path.split(".")[0]+".txt",'wb') as f_dec:
+		f_dec.write(dec_data)
+	os.remove(file_path)
+
+if __name__ == "__main__":
+	parser = argparse.ArgumentParser(description = "[*]Encrypt youre files and password protect them")
+	parser.add_argument('file_path', help="Add the name of the file to be encrypted")
+	parser.add_argument('mode',choices=['encrypt','decrypt'],help="Choose either encrypt or decrypt")
+	args = parser.parse_args()
+
+	if args.mode == "encrypt":
+		key = generate_key()
+		save_key(key,"secret.key")
+		encrypt_file(key,args.file_path)
+		print("Encrypted")
+	else:
+		key = load_key("secret.key")
+
+		decrypt_file(key, args.file_path )
+		print("Decrypted")

File-Encrypter/requirements.txt

@@ -1,17 +1,17 @@
 
-<h1 align="center"> Photo to Ascii</h1>
-Convert your photo to ascii with it
+<h1 align="center">Photo to Ascii</h1>
+Convert your image to ASCII art using this simple python script!
 
----------------------------------------------------------------------
+---
 
 ## Modules Used
 - pillow
 
-
 ## How it works
--  First you have to enter the correct path where your photp is located.
-- Then it will  resize your photo and grayify it
-- Then it will convert your photo to ascii
-- Then you could find your photo in {image_name}(ASCII).txt file  where image_name is the name of your photo
+- First you have to enter the correct path where your image is located.
+- Then it will resize your image and grayify it.
+- Then it will convert your image to ascii.
+- Then it will save the ascii art to the file {imageFile-name}_{imageFile-extension}_ASCII.txt, located in the same folder as your image.
 
-#### By [Avishake Maji](https://github.com/Avishake007) 
+#### Created By [Avishake Maji](https://github.com/Avishake007)
+#### Improved By [Aryan Rai](https://github.com/aryanrai2001)

File-Encrypter/script.py

@@ -1,62 +1,49 @@
 from PIL import Image
 
-# ascii characters used to build the output text
+# ASCII characters used to build the output text
 CHARS = [".", ".", ".", "1", "1", "1", "1", "1", "0", "0", "0"]
-# convert each pixel to grayscale
-
-
-def grayify(image):
-    grayscale_image = image.convert("L")
-    return(grayscale_image)
-
-# convert pixels to a string of ascii characters
-
 
+# Convert pixels to a string of ASCII characters
 def pixels_to_ascii(image):
-    pixels = image.getdata()
-    characters = "".join([CHARS[pixel//23] for pixel in pixels])
+    pixels = image.convert("L").getdata()
+    characters = " ".join([CHARS[int((pixel/256)*len(CHARS))] for pixel in pixels])
     return(characters)
 
-
 def photoascii():
-
-    # attempt to open image from user-input
+    # Attempt to open image file from user-input
     path = input("Enter a valid pathname to an image:\n")
     try:
         image = Image.open(path)
     except Exception:
         print("Invalid path")
         return
-    # Fetching the name of the image
-    image_name = ""
-    flag = 0
-    for i in path[::-1]:
-        if i == "/":
-            break
-        if flag == 1:
-            image_name = i+image_name
-        if i == '.':
-            flag = 1
-
-    # Resizing of image
+
+    # Fetch the name of the image file
+    dot_index = path.rfind('.')
+    slash_index = path.rfind('\\')
+    if slash_index == -1:
+        slash_index = path.rfind('/')
+    image_name = path[slash_index+1:dot_index] + "_" + path[dot_index+1:]
+
+    # Resize image
     new_width = 100
     width, height = image.size
     ratio = height/width
     new_height = int(new_width * ratio)
     resized_image = image.resize((new_width, new_height))
 
-    # convert image to ascii
-    new_image_data = pixels_to_ascii(grayify(resized_image))
-
+    # Convert image to ASCII
+    new_image_data = pixels_to_ascii(resized_image)
     pixel_count = len(new_image_data)
-    ascii_image = "\n".join([new_image_data[index:(index+new_width)]
-                            for index in range(0, pixel_count, new_width)])
+    scanline_width = new_width * 2;
+    ascii_image = "\n".join([new_image_data[index:(index+scanline_width)]
+                            for index in range(0, pixel_count, scanline_width)])
 
-    # save result to "ascii_image.txt"
-    with open("./Photo To Ascii/{}(ASCII).txt".format(image_name), "w") as f:
+    # Save result to text file
+    with open(path[:slash_index] + "/{}_ASCII.txt".format(image_name), "w") as f:
         f.write(ascii_image)
 
 
-# run program
+# Run Program
 if __name__ == '__main__':
     photoascii()

Photo To Ascii/README.md

@@ -1,19 +1,29 @@
-<h3 align="center">Plagiarism Checker</h3>
+<h1 align="center">Plagiarism Checker</h1>
 
-## How it works <br><br>
-- In order to compute the simlilarity between two text documents, the textual raw data is transformed into vectors.
-- Then it is transformed into arrays of numbers and then from that by using a basic knowledge vector to compute the the similarity between them.
+## Introduction <br>
+- Plagiarism checking/detection is the identification of similarities between texts and establishing if one text is derived from another, and it may be used to spot situations of academic dishonesty or unauthorised copying. 
+- This code analyses the textual data and looks for possible instances of plagiarism using TF-IDF (Term Frequency-Inverse Document Frequency) vectorization and cosine similarity.
 
-## Dependencies<br>
-- Install scikit-learn by:
+## Prerequisites <br>
+- Install scikit-learn by: '**$ pip install scikit-learn**'
 
-$ pip install scikit-learn
+## How it works <br>
+1. There are four text documents in the repository.
+2. The paths to text files that are located in the same directory as the code file are loaded at the beginning of the code. It recognises and records the paths of all files with the **.txt** extension in the **student_files** list.
+3. Next, the code reads the contents of each text file and stores them in the **student_notes** list.
+4. **The TfidfVectorizer** class from scikit-learn is used by the **vectorize** function to perform TF-IDF vectorization on a list of text documents. The relative relevance of each term in a document in relation to the corpus of texts is captured by the TF-IDF, a numerical representation of textual data. The function returns arrays of numbers that represent the documents' TF-IDF vectors.
+5. The **similarity** function computes the cosine similarity between two document vectors. Cosine similarity measures the cosine of the angle between two vectors and is commonly used to compare the similarity of documents represented as vectors. The function returns the similarity score between the two input vectors.
+6. The code with the help of the **vectorize** function vectorizes the textual data, converting it to numerical arrays using TF-IDF representation.
+7. The vectorized data is then paired with their corresponding student files and stored in the **s_vectors** list.
+8. The **check_plagiarism** function compares the vectorized documents of each pair of students using cosine similarity. It iterates through each student's vector and compares it with the vectors of all other students. For each pair of students, it computes the similarity score using the **similarity** function and stores the student pair and their similarity score in the **plagiarism_results** set.
+9. And at last the code loops through the **plagiarism_results** set and prints the student pairings along with their similarity ratings.
 
-## Running the app <br>
-- There are four text documents in the repository. 
-- Basically the code will compare all the .txt files and check for any similarity.
+- $ python plagiarism.py
 
-$ python plagiarism.py
+## Notes <br>
+- Please make sure the text files are readable and contain textual processable data.
+- The text files must be in the same directory as the code file.
+- If not need to provide the appropriate path in the **student_files** section of the code.
 
 ## Screenshots
 <img src="https://raw.githubusercontent.com/Anupreetadas/plagiarism_checker/main/assets/Capture1.PNG" width="100%" height="100%" align="left" >