└── Exam
    ├── Part_3
        ├── Question_2.py
        └── Question_1.py
    ├── Part_1
        ├── Code_1.py
        ├── Code_2.py
        └── Code_3.py
    └── Part_2
        ├── Code_2.py
        └── Code_1.py


/Exam/Part_3/Question_2.py:
--------------------------------------------------------------------------------
1 | import webbrowser
2 | import re
3 | 
4 | 


--------------------------------------------------------------------------------
/Exam/Part_3/Question_1.py:
--------------------------------------------------------------------------------
 1 | # Using random, datetime, and collections :
 2 | 
 3 | 
 4 | from datetime import date
 5 | import random
 6 | import collections
 7 | 
 8 | start_date = date.today().replace(day=1, month=1).toordinal()
 9 | end_date = date.today().toordinal()
10 | 
11 | # Random dates
12 | dates = [date.fromordinal(random.randint(start_date, end_date)) for i in range(100)]
13 | 
14 | # Count the number of times each day of the week appears
15 | day_count = collections.Counter(date.weekday(d) for d in dates)
16 | 
17 | # Print the results
18 | for day, count in day_count.items():
19 |     print(f"{day}: {count}")
20 |     
21 |     
22 |     
23 | # This is a Python code  generates 100 
24 | # random dates in the current year and counts the number of 
25 | # times each day of the week appears in those dates.
26 | 
27 | 
28 | # replace(day=1, month=1) sets it to January 1 of the current year.
29 | 
30 | 


--------------------------------------------------------------------------------
/Exam/Part_1/Code_1.py:
--------------------------------------------------------------------------------
 1 | # Part I: Read Code Written by another Coder 
 2 | 
 3 | 
 4 | import random
 5 | import string
 6 | def function_one(length):
 7 |     characters = string.ascii_letters + string.digits + string.punctuation
 8 |     return ''.join(random.choice(characters) for _ in range(length))
 9 | 
10 | function_one(10)
11 | # ============================Modules Imported :========================
12 | # The random : This module Generates pseudo-random numbers.
13 | 
14 | # Imported string : This Module defines Constants like :
15 | 
16 |     # 1-ascii_letters
17 |     # 2-ascii_lowercase
18 |     # 3-ascii_uppercase
19 |     # 4-digits
20 |     # 5-punctuation
21 |     # 6-hexdigits
22 |     # 7-octdigits
23 |     # 8-printable
24 |     # 9-whitespace
25 |     
26 | 
27 | # This code generally generates random characters using ascci letters + digits + ponctuation 
28 | # (using string module).
29 | 
30 | 
31 | # This code can be useful in cases where you want to generate a random code , that is hard to be 
32 | # memorized or cracked , for all general uses. 
33 | 
34 | 
35 | # we can run the code like this :
36 | 
37 | function_one(10)
38 | 
39 | # 10 is the length of the password generated 
40 |     
41 |   


--------------------------------------------------------------------------------
/Exam/Part_2/Code_2.py:
--------------------------------------------------------------------------------
 1 | # Original Code That needs Debuging :
 2 | 
 3 | 
 4 | # import webbrowser
 5 | # import re
 6 | # def search_google(query):
 7 | #     """Search for the given query on Google and open the first result in a web
 8 | # browser."""
 9 | #     url = f'https://www.google.com/search?q={query}'
10 | #     response = webbrowser.open(url)
11 | #     if not response:
12 | #         return 'Unable to open web browser'
13 | #     html = webbrowser.get().open(url).read().decode('utf-8')
14 | #     pattern = re.compile(r'<a href="(https?://.*?)"')
15 | #     match = pattern.search(html)
16 | #     if not match:
17 | #         return 'No search results found'
18 | #     result_url = match.group(2)
19 | #     response = webbrowser.open(result_url)
20 | #     if not response:
21 | #         return 'Unable to open web browser'
22 | #     return 'Success'
23 | # if __name__ == '__main__':
24 | #     query = None
25 | #     result = search_google(query)
26 | #     print(result)
27 | 
28 | 
29 | 
30 | 
31 | 
32 | # The Fixed Version :
33 | 
34 | import webbrowser
35 | import re
36 | def search_google(query):
37 |     """Search for the given query on Google and open the first result in a web
38 | browser."""
39 |     url = f'https://www.google.com/search?q={query}'
40 |     response = webbrowser.open(url)
41 |     if not response:
42 |         return 'Unable to open web browser'
43 |     html = webbrowser.get().open(url).read().decode('utf-8')
44 |     pattern = re.compile(r'<a href="(https?://.*?)"')
45 |     match = pattern.search(html)
46 |     if not match:
47 |         return 'No search results found'
48 |     result_url = match.group(2)
49 |     response = webbrowser.open(result_url)
50 |     if not response:
51 |         return 'Unable to open web browser'
52 |     return 'Success'
53 | if __name__ == '__main__':
54 |     query = input("Enter Your Google Search Here: ")
55 |     result = search_google(query)
56 |     print(result)


--------------------------------------------------------------------------------
/Exam/Part_2/Code_1.py:
--------------------------------------------------------------------------------
 1 | # Original Code That needs Debuging :
 2 | 
 3 | 
 4 | 
 5 | 
 6 | # import os
 7 | # import random
 8 | # from collections import Counter, defaultdict
 9 | # from datetime import datetime
10 | # def create_file():
11 | #     """Create a new file with a random filename and some random contents."""
12 | #     filename = f'file_{datetime.now().strftime("%Y%m%d%H%M%S%f")}.txt'
13 | #     with open(filename, 'w') as f:
14 | #         for i in range(10):
15 | #             f.write(f'Line {i}: {random.randint(1, 100)}\n')
16 | #     return filename
17 | # def read_file(filename):
18 | #     """Read the contents of a file and return as a string."""
19 | #     with open(filename, 'r') as f:
20 | #         return f.read()
21 | # def count_numbers(text):
22 | #     lines = text.splitlines()
23 | #     counts = defaultdict(int)
24 | #     for line in lines:
25 | #         words = line.split()
26 | #         for word in words:
27 | #             if word.isdigit():
28 | #                 counts[int(word)] += 1
29 | #     return Counter(counts)
30 | # if __name__ == '__main__':
31 | #     filename = create_file()
32 | #     text = read_file(filename)
33 | #     counts = count_numbers(text)
34 | #     print(f'Counts for file {filename}: {counts}')
35 | #     os.remove(filename)
36 | #     print(f'Total count: {sum(counts)}')
37 | 
38 | 
39 | 
40 | 
41 | 
42 | 
43 | # The Fixed Version :
44 | 
45 | 
46 | 
47 | 
48 | import os
49 | import random
50 | from collections import Counter, defaultdict
51 | from datetime import datetime
52 | def create_file():
53 |     """Create a new file with a random filename and some random contents."""
54 |     filename = f'file_{datetime.now().strftime("%Y%m%d%H%M%S%f")}.txt'
55 |     with open(filename, 'w') as f:
56 |         for i in range(10):
57 |             f.write(f'Line {i}: {random.randint(1, 100)}\n')
58 |     return filename
59 | def read_file(filename):
60 |     """Read the contents of a file and return as a string."""
61 |     with open(filename, 'r') as f:
62 |         return f.read()
63 | def count_numbers(text):
64 |     lines = text.splitlines()
65 |     counts = defaultdict(int)
66 |     for line in lines:
67 |         words = line.split()
68 |         for word in words:
69 |             if word.isdigit():
70 |                 counts[int(word)] += 1
71 |     return Counter(counts)
72 | if __name__ == '__main__':
73 |     filename = create_file()
74 |     text = read_file(filename)
75 |     counts = count_numbers(text)
76 |     print(f'Counts for file {filename}: {counts}')
77 |     os.remove(filename)
78 |     print(f'Total count: {sum(counts)}')
79 | 
80 | 
81 | 
82 | 
83 | 
84 | 


--------------------------------------------------------------------------------
/Exam/Part_1/Code_2.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import re
 3 | import datetime
 4 | def function_two(directory):
 5 |     date_pattern = re.compile(r'\d{4}-\d{2}-\d{2}')
 6 |     for filename in os.listdir(directory):
 7 |         if os.path.isfile(os.path.join(directory, filename)):
 8 |             match = date_pattern.search(filename)
 9 |     if match:
10 |         date_str = match.group()
11 |     file_date = datetime.datetime.strptime(date_str, '%Y-%m-%d')
12 |     year = str(file_date.year)
13 |     month = file_date.strftime('%B')
14 |     new_directory = os.path.join(directory, year, month)
15 |     os.makedirs(new_directory, exist_ok=True)
16 |     old_path = os.path.join(directory, filename)
17 |     new_path = os.path.join(new_directory, filename)
18 |     os.rename(old_path, new_path)
19 |     
20 |     
21 | # ============================Modules Imported :========================
22 | # In This Code We Imported The OS : This module Allows us to use the
23 | # operating system dependent functionality.
24 | 
25 | 
26 | # Imported re : 
27 | 
28 | # Imported datetime : 
29 | 
30 | 
31 | 
32 | 
33 | # Explaining the Code: 
34 | 
35 | 
36 | # 1-Defines a function called function_two 
37 |     
38 | # 2-The re.compile() method returns a pattern object and that matches a date in the 
39 | # format YYYY-MM-DD.
40 | 
41 | # 3-Loops through each file in the directory using os.listdir(directory) and gives 
42 | # each filename a variable filename.
43 |     # in Directory You specify the disired directory according to you
44 | 
45 | 
46 | # 4- Checking if the file is a regular file using os.path.isfile(os.path.join(directory, filename)).
47 |     # -----> If the file is a regular file, searches for a match for the pattern using match = date_pattern.search(filename).
48 |         # ------> If a match is found, extracts the matched date using match.group() .
49 |     # (used two consucutive if statements in the code)
50 |     
51 | # 5- Difining variables :
52 |     # ------> file_date: date of the file
53 |     # ------> Year: the year
54 |     # ------> month: the month
55 |     # ------> new_directory: Creates a new directory with the path using os.path.join(directory, year, month)
56 |     # ------> old_path: assigns this variable to directory and old path
57 |     # ------> new_path: assigns this variable to directory and new path
58 |     
59 | 
60 | 
61 | 
62 | # ====================This Code Used For:=========================
63 | 
64 | 
65 | # This code renames files in the selected directory :
66 | #     ------> extracting the date from the filename 
67 | #     ------> creating a new directory with the date extracted. 
68 | #     ------> moves the file to the new directory while you can rename it.
69 | 
70 | 
71 | 
72 | 
73 | 
74 | 
75 | 
76 | 
77 | 
78 | 
79 | 
80 | 
81 | 
82 | 
83 | 


--------------------------------------------------------------------------------
/Exam/Part_1/Code_3.py:
--------------------------------------------------------------------------------
 1 | import asyncio
 2 | from datetime import datetime, timedelta
 3 | from collections import defaultdict
 4 | async def is_w(date):
 5 |     return date.weekday() >= 5
 6 | async def is_h(date):
 7 |     holidays = [datetime(2023, 1, 1), datetime(2023, 4, 15), datetime(2023, 5, 1),
 8 | datetime(2023, 6, 7), datetime(2023, 9, 16)]
 9 |     return date in holidays
10 | async def generater(start_date, end_date):
11 |     dates = defaultdict(list)
12 |     current_date = start_date
13 |     while current_date <= end_date:
14 |         if not await is_w(current_date) and not await is_h(current_date):
15 |             dates[current_date.year].append(current_date)
16 |         current_date += timedelta(days=1)
17 |     return dates
18 | async def main():
19 |     start_date = datetime(2023, 1, 1)
20 |     end_date = datetime(2023, 12, 31)
21 |     dates = await generater(start_date, end_date)
22 |     year_counts = {year: len(dates[year]) for year in dates}
23 |     print('Number of workdays in 2023:', sum(year_counts.values()))
24 | if __name__ == '__main__':
25 |     asyncio.run(main())
26 |     
27 |     
28 |     
29 |     
30 | # ============================Modules Imported :========================
31 | # In This Code We Imported The asyncio : asyncio library which is used for writing 
32 | # asynchronous code in Python.
33 | 
34 | 
35 | # Imported collections : 
36 | 
37 | # importing the defaultdict class from the collections module.
38 | 
39 | 
40 | 
41 | # Imported datetime : 
42 |     
43 |     
44 |     
45 | # Explaining the Code: 
46 | 
47 | # 1-defines four functions is_w, is_h, generater. 
48 | # async def is_w(date)/async def is_h(date):
49 |     # --------> is_w: defines a coroutine function takes a date and returns whether the 
50 |         # day of the week for that date is a weekend day (Saturday or Sunday)
51 |     # --------> is_h: defines a coroutine function called is_h that takes in a date and returns whether the date 
52 |     # falls on one of the holidays specified in the function.
53 | 
54 | # 2- async def main(): 
55 |         # -------> defines a coroutine function called main that initializes the start_date and end_date parameters.
56 |         # -------> generate the dates, and how many workdays for each year. 
57 |         
58 |         
59 | # 3-if __name__ == '__main__':
60 | #     asyncio.run(main():
61 |         # -----------> runs the main coroutine using asyncio.
62 | 
63 | # Result : finally :prints the total number of work days in 2023.
64 | 
65 | 
66 | 
67 | # This code is used for counting the working days of a given year in this cases :
68 |     # 2023 = 258 
69 | # by eliminating holidays and sundays and maybe saturdays
70 | 
71 | # it is useful for working people to know how much time they gonna spend with their families each year 
72 | 
73 | 
74 | 
75 | 
76 | 
77 | 
78 | 


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