py-simple-wrap 0.1.0__py3-none-any.whl

py_simple/__init__.py

@@ -0,0 +1,32 @@
+from .easy_file_manager import (
+    make_blank_file, is_file_there, add_a_line, read_file_to_list,
+    remove_file, rename_file, list_files, copy_file,
+)
+from .easy_date_formatter import (
+    get_pretty_date, get_past_pretty_date, get_future_pretty_date,
+    dd_mm_yyyy, past_dd_mm_yyyy, future_dd_mm_yyyy,
+    mm_dd_yyyy, past_mm_dd_yyyy, future_mm_dd_yyyy,
+    slash_dd_mm_yyyy, past_slash_dd_mm_yyyy, future_slash_dd_mm_yyyy,
+    slash_mm_dd_yyyy, past_slash_mm_dd_yyyy, future_slash_mm_dd_yyyy,
+    list_available_formats,
+)
+from .easy_converter import (
+    seconds_to_hh_mm_ss, miles_to_km, km_to_mile, fluid_oz_to_ml,
+    ml_to_fluid_oz, celsius_to_fahrenheit, fahrenheit_to_celsius, kg_to_lb,
+    lb_to_kg, meters_to_feet, feet_to_meters, cm_to_inches, inches_to_cm,
+    sq_feet_to_sq_meters, sq_meters_to_sq_feet
+)
+from .easy_numbers import (
+    is_even, is_odd, is_evenly_divisible, is_negative, is_positive,
+    average, is_prime, percentage_of
+)
+from .easy_validator import (
+    is_valid_email, is_valid_username, is_valid_zipcode, is_valid_url,
+    is_password_secure,
+)
+from .easy_web import (
+    get_page_content, is_page_up,
+)
+from .easy_strings import (
+    is_palindrome, remove_extra_spaces, to_kebab_case, to_snake_case,
+)

py_simple/easy_converter.py

@@ -0,0 +1,302 @@
+"""
+easy_converter is built to simplify different types of conversions
+"""
+
+from datetime import timedelta
+
+
+def seconds_to_hh_mm_ss(seconds: int) -> str:
+    """
+    Returns seconds in HH:MM:SS format.
+
+    Arguments:
+        seconds (int) -- number of seconds to convert
+
+    Example:
+        seconds_to_hh_mm_ss(90)
+        (00:01:30)
+    """
+    return str(timedelta(seconds=seconds))
+
+
+def hh_mm_ss_to_seconds(hours: int = 0, minutes: int = 0, seconds: int = 0) \
+        -> int:
+    """
+        Returns hours, minutes and seconds converted to seconds.
+
+        Arguments:
+            hours (int) -- number of hours to convert. Defaults to 0.
+            minutes (int) -- number of minutes to convert. Defaults to 0.
+            seconds (int) -- number of seconds to convert. Defaults to 0.
+
+        Example:
+            hh_mm_ss_to_seconds(1, 1, 1)
+            (3661)
+        """
+    total_seconds = seconds
+    total_seconds += hours * 3600
+    total_seconds += minutes * 60
+    return total_seconds
+
+
+def km_to_mile(km: float) -> float:
+    """
+    Converts kilometers to miles. Returns miles as a float.
+
+    Arguments:
+        km (float) -- kilometers
+
+    Example:
+        km_to_mile(100)
+        (62.13)
+    """
+    return float(f"{km * 0.621371:.2f}")
+
+
+def miles_to_km(miles: float) -> float:
+    """
+        Converts miles to kilometers. Returns kilometers as a float.
+
+        Arguments:
+            miles (float) -- miles
+
+        Example:
+            miles_to_km(100)
+            (160.93)
+    """
+    return float(f"{miles * 1.60934:.2f}")
+
+
+def fluid_oz_to_ml(oz: float, standard = 'us') -> float | None:
+    """
+    Converts fluid ounces to milliliters. Returns milliliters as a float.
+
+    :param:
+        oz (float) -- fluid ounces
+        standard -- us or uk
+
+    Example:
+        standard = 'us'
+        fluid_oz_to_ml(1)
+        (29.6)
+        standard = 'uk'
+        fluid_oz_to_ml(1)
+        (28.4)
+
+    """
+    match standard:
+        case "uk":
+            return float(f"{oz * 28.4:.2f}")
+        case "us":
+            return float(f"{oz * 29.6:.2f}")
+    return None
+
+
+def ml_to_fluid_oz(milliliters: float, standard = 'us') -> float | None:
+    """
+        Converts milliliters to fluid ounces. Returns fluid ounces as a
+        float.
+
+        :param:
+            milliliters (float) -- milliliters
+            standard -- us or uk
+
+        Example:
+            standard = 'us'
+            ml_to_fluid_oz(1)
+            (0.03)
+            standard = 'uk'
+            ml_to_fluid_oz(1)
+            (0.04)
+
+        """
+    match standard:
+        case "uk":
+            return float(f"{milliliters * 0.035:.2f}")
+        case "us":
+            return float(f"{milliliters * 0.034:.2f}")
+    return None
+
+
+def celsius_to_fahrenheit(temp_celsius: float) -> float:
+    """
+        Converts temperature in Celsius to temperature in Fahrenheit.
+        Returns degrees Fahrenheit as float.
+
+        :param:
+            temp_celsius (float) -- temperature in Celsius
+
+        Example:
+            celsius_to_fahrenheit(40)
+            (104.0)
+
+        """
+    return float(f"{((temp_celsius * 9 / 5) + 32):.2f}")
+
+
+def fahrenheit_to_celsius(temp_fahrenheit: float) -> float:
+    """
+        Converts temperature in Fahrenheit to temperature in Celsius.
+        Returns degrees Celsius as float.
+
+        :param:
+            temp_fahrenheit (float) -- temperature in Fahrenheit
+
+        Example:
+            fahrenheit_to_celsius(104)
+            (40.0)
+        """
+    return float(f"{((temp_fahrenheit - 32) * 5 / 9):.2f}")
+
+
+def kg_to_lb(kg: float) -> float:
+    """
+        Converts kilograms to pounds.
+        Returns pounds as float.
+
+        :param:
+            kg (float) -- kilograms
+
+        Example:
+            kg_to_lb(50)
+            (110.23)
+        """
+    return float(f"{kg * 2.20462:.2f}")
+
+
+def lb_to_kg(lb: float) -> float:
+    """
+        Converts pounds to kilograms.
+        Returns kilograms as float.
+
+        :param:
+            lb (float) -- pounds
+
+        Example:
+            lb_to_kg(110.23)
+            (50.0)
+        """
+    return float(f"{(lb * 0.453592):.2f}")
+
+
+def meters_to_feet(meters: float) -> float:
+    """
+        Converts meters to feet.
+        Returns feet as float.
+
+        Arguments:
+            meters (float) -- meters to be converted to feet.
+
+        Example:
+            meters_to_feet(100)
+            (328.08)
+        """
+    return float(f"{(meters * 3.28084):.2f}")
+
+
+def feet_to_meters(feet: float) -> float:
+    """
+        Converts feet to meters.
+        Returns meters as float.
+
+        Arguments:
+            feet (float) -- feet to be converted to meters.
+
+        Example:
+            feet_to_meters(328.08)
+            (100.0)
+        """
+    return float(f"{(feet * 0.3048):.2f}")
+
+
+def cm_to_inches(cm: float) -> float:
+    """
+        Converts centimeters to inches.
+        Returns inches as float.
+
+        Arguments:
+            cm (float) -- centimeters to be converted to inches.
+
+        Example:
+            cm_to_inches(100)
+            (39.37)
+        """
+    return float(f"{(cm / 2.54):.2f}")
+
+
+def inches_to_cm(inches: float) -> float:
+    """
+        Converts centimeters to inches.
+        Returns inches as float.
+
+        Arguments:
+            inches (float) -- inches to be converted to centimeters.
+
+        Example:
+            inches_to_cm(39.37)
+            (100.0)
+        """
+    return float(f"{(inches * 2.54):.2f}")
+
+
+def sq_meters_to_sq_feet(sq_meters: float) -> float:
+    """
+        Converts square meters to square feet.
+        Returns square feet as float.
+
+        Arguments:
+            sq_meters (float) -- square meters to be converted to
+            square feet.
+
+        Example:
+            sq_meters_to_sq_feet(10)
+            (107.64)
+        """
+    return float(f"{(sq_meters * 10.7639):.2f}")
+
+
+def sq_feet_to_sq_meters(sq_feet: float) -> float:
+    """
+        Converts square feet to square meters.
+        Returns square meters as float.
+
+        Arguments:
+            sq_feet (float) -- square feet to be converted to
+            square meters.
+
+        Example:
+            sq_feet_to_sq_meters(107.64)
+            (10.0)
+        """
+    return float(f"{(sq_feet * 0.092903):.2f}")
+
+def mph_to_kph(mph):
+    """
+        Converts mph speed to kph speed.
+        Returns kph speed as float.
+
+        Arguments:
+            mph (float) -- mph speed to be converted to
+            kph speed.
+
+        Example:
+            mph_to_kph(0.621371)
+            (1.0)
+        """
+    return float(f"{(mph * 1.60934):.2f}")
+
+
+def kph_to_mph(kph):
+    """
+        Converts kph speed to mph speed.
+        Returns mph speed as float.
+
+        Arguments:
+            kph (float) -- kph speed to be converted to
+            kph speed.
+
+        Example:
+            kph_to_mph(1.60934)
+            (1.0)
+        """
+    return float(f"{(kph * 0.621371):.2f}")

py_simple/easy_date_formatter.py

@@ -0,0 +1,139 @@
+"""
+easy_date_formatter is meant to simplify getting formatted dates.
+Built on top of the datetime module — no more memorizing strftime codes.
+"""
+
+from datetime import datetime, timedelta
+
+
+# ── Format registry (strftime pattern → readable name) ──────────────
+_FORMATS = {
+    "pretty": "%A, %B %d, %Y",
+    "dd-mm-yyyy": "%d-%m-%Y",
+    "mm-dd-yyyy": "%m-%d-%Y",
+    "dd/mm/yyyy": "%d/%m/%Y",
+    "mm/dd/yyyy": "%m/%d/%Y",
+}
+
+
+def list_available_formats():
+    """Return the supported format names for reference."""
+    return list(_FORMATS.keys())
+
+
+def _format_date(date_obj, fmt_key: str) -> str:
+    """Apply a named format to a datetime object."""
+    return date_obj.strftime(_FORMATS[fmt_key])
+
+
+def _get_past_date(num_days_ago: int):
+    """Calculate and return a past date."""
+    return datetime.now() - timedelta(days=num_days_ago)
+
+
+def _get_future_date(num_days_from_now: int):
+    """Calculate and return a future date."""
+    return datetime.now() + timedelta(days=num_days_from_now)
+
+
+# ── Pretty dates ────────────────────────────────────────────────────
+
+def get_pretty_date():
+    """
+    Returns the current date in a human-friendly format.
+
+    Returns:
+        str: Current date formatted as 'Weekday, Month Day, Year'
+             (e.g., 'Monday, July 20, 2026').
+    """
+    return _format_date(datetime.now(), "pretty")
+
+
+def get_past_pretty_date(num_days_ago: int):
+    """
+    Calculates a date from the past in pretty format.
+
+    Args:
+        num_days_ago (int): Number of days to subtract from today.
+
+    Returns:
+        str: Past date as 'Weekday, Month Day, Year'.
+    """
+    return _format_date(_get_past_date(num_days_ago), "pretty")
+
+
+def get_future_pretty_date(num_days_from_now: int):
+    """
+    Calculates a future date in pretty format.
+
+    Args:
+        num_days_from_now (int): Number of days to add to today.
+
+    Returns:
+        str: Future date as 'Weekday, Month Day, Year'.
+    """
+    return _format_date(_get_future_date(num_days_from_now), "pretty")
+
+
+# ── Hyphenated formats (DD-MM-YYYY or MM-DD-YYYY) ───────────────────
+
+def dd_mm_yyyy():
+    """Current date in 'DD-MM-YYYY' format (e.g., '20-07-2026')."""
+    return _format_date(datetime.now(), "dd-mm-yyyy")
+
+
+def past_dd_mm_yyyy(num_days_ago: int):
+    """Past date in 'DD-MM-YYYY' format."""
+    return _format_date(_get_past_date(num_days_ago), "dd-mm-yyyy")
+
+
+def future_dd_mm_yyyy(num_days_from_now: int):
+    """Future date in 'DD-MM-YYYY' format."""
+    return _format_date(_get_future_date(num_days_from_now), "dd-mm-yyyy")
+
+
+def mm_dd_yyyy():
+    """Current date in 'MM-DD-YYYY' format (e.g., '07-20-2026')."""
+    return _format_date(datetime.now(), "mm-dd-yyyy")
+
+
+def past_mm_dd_yyyy(num_days_ago: int):
+    """Past date in 'MM-DD-YYYY' format."""
+    return _format_date(_get_past_date(num_days_ago), "mm-dd-yyyy")
+
+
+def future_mm_dd_yyyy(num_days_from_now: int):
+    """Future date in 'MM-DD-YYYY' format."""
+    return _format_date(_get_future_date(num_days_from_now), "mm-dd-yyyy")
+
+
+# ── Slashed formats (DD/MM/YYYY or MM/DD/YYYY) ──────────────────────
+
+def slash_dd_mm_yyyy():
+    """Current date in 'DD/MM/YYYY' format (e.g., '20/07/2026')."""
+    return _format_date(datetime.now(), "dd/mm/yyyy")
+
+
+def past_slash_dd_mm_yyyy(num_days_ago: int):
+    """Past date in 'DD/MM/YYYY' format."""
+    return _format_date(_get_past_date(num_days_ago), "dd/mm/yyyy")
+
+
+def future_slash_dd_mm_yyyy(num_days_from_now: int):
+    """Future date in 'DD/MM/YYYY' format."""
+    return _format_date(_get_future_date(num_days_from_now), "dd/mm/yyyy")
+
+
+def slash_mm_dd_yyyy():
+    """Current date in 'MM/DD/YYYY' format (e.g., '07/20/2026')."""
+    return _format_date(datetime.now(), "mm/dd/yyyy")
+
+
+def past_slash_mm_dd_yyyy(num_days_ago: int):
+    """Past date in 'MM/DD/YYYY' format."""
+    return _format_date(_get_past_date(num_days_ago), "mm/dd/yyyy")
+
+
+def future_slash_mm_dd_yyyy(num_days_from_now: int):
+    """Future date in 'MM/DD/YYYY' format."""
+    return _format_date(_get_future_date(num_days_from_now), "mm/dd/yyyy")

py_simple/easy_file_manager.py

@@ -0,0 +1,240 @@
+"""
+easy_file_manager is meant to simplify working with files.
+"""
+
+import os
+import shutil
+
+
+VALID_EXTENSIONS = ['txt', 'md', 'log', 'csv']
+
+
+class InvalidExtension(Exception):
+    """Exception raised for invalid extension"""
+
+    def __init__(self, message):
+        self.message = message
+        super().__init__(self.message)
+
+
+def _is_valid_extension(extension):
+    """Check if extension is valid"""
+    return extension in VALID_EXTENSIONS
+
+
+def _get_extension(filename: str) -> str:
+    """Extract the lowercased extension from a filename."""
+    return filename.split('.')[-1].lower()
+
+
+def is_file_there(filename: str) -> bool:
+    """
+    Check if file exists in current working directory.
+
+    Args:
+        filename (str): Name of the file to be checked.
+
+    Returns:
+        bool: True if file exists, False otherwise.
+
+    Example:
+        is_file_there("new_file.txt")
+    """
+    return os.path.isfile(filename)
+
+
+def make_blank_file(filename: str, file_extension: str):
+    """
+    Creates a blank file in current working directory.
+    If file already exists, nothing is done.
+
+    Args:
+        filename (str): The name of the file to be created.
+        file_extension (str): The extension without '.'.
+            Allowed: ['txt', 'csv', 'md', 'log']
+
+    Example:
+        make_blank_file("new_file", "txt")
+    """
+    if _is_valid_extension(file_extension.lower()):
+        file = f"{filename}.{file_extension.lower()}"
+        if is_file_there(file):
+            print(f"File {file} already exists in current working directory.")
+        else:
+            with open(file, 'w', encoding='utf-8'):
+                pass
+    else:
+        raise InvalidExtension(
+            f"\n'{file_extension}' is not a valid extension.\n"
+            f"Please enter a valid extension and try again.\n"
+            f"\nVALID EXTENSIONS: {VALID_EXTENSIONS}"
+        )
+
+
+def add_a_line(filename: str, line: str):
+    """
+    Add line to existing file. If file does not exist, create it.
+
+    Args:
+        filename (str): File to write to.
+        line (str): Line to write.
+
+    Example:
+        add_a_line("new_file.txt", "hello world!")
+    """
+    ext = _get_extension(filename)
+    if _is_valid_extension(ext):
+        with open(filename, 'a', encoding='utf-8') as f:
+            f.write(line + '\n')
+    else:
+        raise InvalidExtension(
+            f"\n'{ext}' is not a valid extension.\n"
+            f"Please enter a valid extension and try again.\n"
+            f"\nVALID EXTENSIONS: {VALID_EXTENSIONS}"
+        )
+
+
+def read_file_to_list(filename: str) -> list:
+    """
+    Reads lines of existing file to list.
+
+    Args:
+        filename (str): File to read from.
+
+    Returns:
+        list: List of lines.
+
+    Example:
+        read_file_to_list("new_file.txt")
+    """
+    ext = _get_extension(filename)
+    if _is_valid_extension(ext):
+        try:
+            with open(filename, 'r', encoding='utf-8') as f:
+                return [line.strip() for line in f.readlines()]
+        except FileNotFoundError:
+            print(f"\nFile '{filename}' not found.")
+            return []
+    else:
+        raise InvalidExtension(
+            f"\n'{ext}' is not a valid extension.\n"
+            f"Please enter a valid extension and try again.\n"
+            f"\nVALID EXTENSIONS: {VALID_EXTENSIONS}"
+        )
+
+
+def remove_file(filename: str):
+    """
+    Removes file from current working directory.
+
+    Args:
+        filename (str): File to delete.
+
+    Example:
+        remove_file("new_file.txt")
+    """
+    ext = _get_extension(filename)
+    if _is_valid_extension(ext):
+        if is_file_there(filename):
+            os.remove(filename)
+        else:
+            print(f"File {filename} does not exist!")
+    else:
+        raise InvalidExtension(
+            f"\n'{ext}' is not a valid extension.\n"
+            f"Please enter a valid extension and try again.\n"
+            f"\nVALID EXTENSIONS: {VALID_EXTENSIONS}"
+        )
+
+
+def rename_file(old_name: str, new_name: str):
+    """
+    Rename file in the current working directory.
+
+    Args:
+        old_name (str): Current filename.
+        new_name (str): New filename.
+
+    Example:
+        rename_file("old_name.txt", "new_name.txt")
+    """
+    ext_old = _get_extension(old_name)
+    ext_new = _get_extension(new_name)
+    if _is_valid_extension(ext_old) and _is_valid_extension(ext_new):
+        if is_file_there(old_name):
+            if not is_file_there(new_name):
+                os.rename(old_name, new_name)
+            else:
+                print(f"File '{new_name}' already exists in current working directory.")
+        else:
+            print(f"File {old_name} does not exist in current working directory.")
+    else:
+        raise InvalidExtension(
+            f"\n'{ext_old}' or '{ext_new}' is not a valid extension.\n"
+            f"Please enter a valid extension and try again.\n"
+            f"\nVALID EXTENSIONS: {VALID_EXTENSIONS}"
+        )
+
+
+def list_files(extension: str = None) -> list:
+    """
+    List files in the current working directory that have valid extensions.
+    Optionally filter by a specific extension.
+
+    Args:
+        extension (str, optional): Filter by extension (e.g., 'txt').
+            If None, all valid extension files are listed.
+
+    Returns:
+        list: Sorted list of filenames matching the filter.
+
+    Example:
+        list_files()
+        list_files("txt")
+    """
+    if extension is not None and not _is_valid_extension(extension.lower()):
+        raise InvalidExtension(
+            f"\n'{extension}' is not a valid extension.\n"
+            f"\nVALID EXTENSIONS: {VALID_EXTENSIONS}"
+        )
+
+    matches = []
+    for fname in os.listdir('.'):
+        if os.path.isfile(fname):
+            ext = _get_extension(fname)
+            if _is_valid_extension(ext):
+                if extension is None or ext == extension.lower():
+                    matches.append(fname)
+    return sorted(matches)
+
+
+def copy_file(source: str, destination: str):
+    """
+    Copy a file to a new location or name.
+
+    Args:
+        source (str): File to copy.
+        destination (str): Destination path or filename.
+
+    Example:
+        copy_file("notes.txt", "notes_backup.txt")
+    """
+    ext_src = _get_extension(source)
+    ext_dst = _get_extension(destination)
+    if not _is_valid_extension(ext_src):
+        raise InvalidExtension(
+            f"\n'{ext_src}' is not a valid extension.\n"
+            f"\nVALID EXTENSIONS: {VALID_EXTENSIONS}"
+        )
+    if not _is_valid_extension(ext_dst):
+        raise InvalidExtension(
+            f"\n'{ext_dst}' is not a valid extension.\n"
+            f"\nVALID EXTENSIONS: {VALID_EXTENSIONS}"
+        )
+    if not is_file_there(source):
+        print(f"File '{source}' does not exist.")
+        return
+    if is_file_there(destination):
+        print(f"File '{destination}' already exists — not overwriting.")
+        return
+    shutil.copy2(source, destination)

py_simple/easy_numbers.py

@@ -0,0 +1,151 @@
+"""
+easy_numbers is built to simplify different types of number operations.
+"""
+
+
+def is_even(number: int) -> bool:
+    """
+        Returns true if the number is even and false if it is odd.
+
+        Arguments:
+            number (int) -- number to check if odd or even.
+
+        Example:
+            is_even(90)
+            (True)
+            is_even(67)
+            (False)
+        """
+    return number % 2 == 0
+
+
+def is_odd(number: int) -> bool:
+    """
+        Returns true if the number is odd and false if it is even.
+
+        Arguments:
+            number (int) -- number to check if odd or even.
+
+        Example:
+            is_odd(90)
+            (False)
+            is_odd(67)
+            (True)
+        """
+    return number % 2 == 1
+
+
+def is_evenly_divisible(number: int, divisor: int) -> bool:
+    """
+        Returns true if the number can be evenly divided by divisor.
+
+        Arguments:
+            number (int) -- number to check if evenly divided by divisor.
+            divisor (int) -- divisor to check if number can be
+             evenly divided by divisor.
+
+        Example:
+            is_evenly_divisible(90, 9)
+            (True)
+            is_evenly_divisible(67, 2)
+            (False)
+        """
+    return number % divisor == 0
+
+
+def is_positive(number: int) -> bool:
+    """
+        Returns true if the number is positive and false if it is
+        negative.
+
+        Arguments:
+            number (int) -- number to check if positive.
+
+        Example:
+            is_positive(90)
+            (True)
+            is_positive(-10)
+            (False)
+        """
+    return number > 0
+
+
+def is_negative(number: int) -> bool:
+    """
+        Returns true if the number is negative and false if it is
+        positive.
+
+        Arguments:
+            number (int) -- number to check if negative.
+
+        Example:
+            is_negative(90)
+            (False)
+            is_negative(-10)
+            (True)
+        """
+    return number < 0
+
+
+def average(nums: list[float]) -> float:
+    """
+        Returns the average of a list of numbers.
+
+        Arguments:
+            nums (list[float]) -- list of numbers to average.
+
+        Example:
+            average([1.5, 2, 3])
+            (2.17)
+            average([3, 5, 2.3, 6.24])
+            (4.13)
+        """
+    return float(f"{(sum(nums) / len(nums)):.2f}")
+
+
+def is_prime(number: int) -> bool:
+    """
+        Returns true if the number is prime and false if it is.
+
+        Arguments:
+            number (int) -- number to check if prime.
+
+        Example:
+            is_prime(2)
+            (True)
+            is_prime(15)
+            (False)
+        """
+    if number > 0:
+        limit = int((number ** 0.5) + 1)
+    else:
+        return False
+    if number < 2:
+        return False
+    elif number == 2:
+        return True
+    elif is_even(number):
+        return False
+    else:
+        for i in range(3, limit, 2):
+            if is_evenly_divisible(number, i):
+                return False
+    return True
+
+
+def percentage_of(number: int, percentage: float) -> float:
+    """
+        Returns percentage of number as a float.
+
+        Arguments:
+            number (int) -- number to get percentage of.
+            percentage (float) -- percentage to get.
+            Must be between 0 and 1 (e.g. 0.5, 0.75)
+
+        Example:
+            percentage_of(100, 0.5)
+            (50.0)
+            percentage_of(19, 0.4)
+            (7.6)
+        """
+    return float(f"{(number * percentage):.2f}")

py_simple/easy_strings.py

@@ -0,0 +1,62 @@
+"""Beginner-friendly helpers for common string operations."""
+
+import re
+
+
+def remove_extra_spaces(text: str) -> str:
+    """
+    Removes leading, trailing, and repeated spaces from text.
+
+    Example:
+        remove_extra_spaces("  hello   world  ")
+        "hello world"
+    """
+    return " ".join(text.split())
+
+
+def to_snake_case(text: str) -> str:
+    """
+    Converts text to snake_case.
+
+    Example:
+        to_snake_case("Hello World")
+        "hello_world"
+    """
+    cleaned_text = _separate_words(text)
+    return cleaned_text.lower().replace(" ", "_")
+
+
+def to_kebab_case(text: str) -> str:
+    """
+    Converts text to kebab-case.
+
+    Example:
+        to_kebab_case("Hello World")
+        "hello-world"
+    """
+    cleaned_text = _separate_words(text)
+    return cleaned_text.lower().replace(" ", "-")
+
+
+def is_palindrome(text: str) -> bool:
+    """
+    Returns True when text reads the same forwards and backwards.
+
+    Spaces, punctuation, and letter casing are ignored.
+
+    Example:
+        is_palindrome("Never odd or even")
+        True
+    """
+    cleaned_text = "".join(
+        character.lower() for character in text if character.isalnum()
+    )
+    return cleaned_text == cleaned_text[::-1]
+
+
+def _separate_words(text: str) -> str:
+    """Normalizes common word separators and separates camel-case words."""
+    text = re.sub(r"([a-z0-9])([A-Z])", r"\1 \2", text)
+    text = re.sub(r"[_\-]+", " ", text)
+    text = re.sub(r"[^\w\s]", " ", text)
+    return remove_extra_spaces(text)

py_simple/easy_validator.py

@@ -0,0 +1,139 @@
+"""
+easy_validator is built to simplify validation.
+"""
+import re
+from string import punctuation
+
+
+def is_valid_email(email: str) -> bool:
+    """
+        Returns true if email is valid.
+
+        Arguments:
+            email (str) -- email address to validate.
+
+        Example:
+            is_valid_email("mymail@gmail.com")
+            (True)
+            is_valid_email("email.com")
+            (False)
+        """
+    pattern = r'[a-zA-Z_.%+-]+@[a-zA-Z0-9-]+\.[a-zA-Z]+'
+    return bool(re.fullmatch(pattern, email))
+
+
+def is_valid_username(username: str) -> bool:
+    """
+        Returns true if username is valid.
+
+        Arguments:
+            username (str) -- username to validate.
+
+        Example:
+            is_valid_username("user_name")
+            (True)
+            is_valid_username("user.name")
+            (False)
+        """
+    pattern = r'^[a-zA-Z0-9_]+'
+    return bool(re.fullmatch(pattern, username))
+
+
+def is_valid_zipcode(zipcode: int) -> bool:
+    """
+        Returns true if US zip code is valid.
+
+        Arguments:
+            zipcode (int) -- US zipcode to validate.
+
+        Example:
+            is_valid_zipcode(12345)
+            (True)
+            is_valid_zipcode(1248721)
+            (False)
+        """
+    pattern = r'^[0-9]{5}$'
+    return bool(re.fullmatch(pattern, str(zipcode)))
+
+
+def is_valid_url(url: str) -> bool:
+    """
+        Returns true if url is valid.
+
+        Arguments:
+            url (str) -- URL to validate.
+
+        Example:
+            is_valid_url("www.google.com")
+            (True)
+            is_valid_url("something.com")
+            (False)
+        """
+    pattern = r'(https://|http://|www\.)[a-zA-Z0-9]+\.[a-zA-Z]+'
+    return bool(re.fullmatch(pattern, url))
+
+
+def is_password_secure(password: str) -> bool:
+    """
+        Returns true if password is valid.
+
+        Validation checks:
+            - minimum length of 8 characters
+            - at least one special character
+            - at least one upper case letter
+            - at least two lowercase letters
+            - at least two digits
+            - no repeating characters
+
+        Arguments:
+            password (str) -- password to validate.
+
+        Example:
+            is_password_secure("1andkrf!AG5")
+            (True)
+            is_password_secure("111mskagowd")
+            (False)
+        """
+    min_length = 8
+    upper_letters = 0
+    lower_letters = 0
+    digits = 0
+    special_characters = 0
+    last_char = ''
+
+    if len(password) > min_length:
+        for char in password:
+            if char.isdigit():
+                digits += 1
+                if char == last_char:
+                    return False
+                else:
+                    last_char = char
+            elif char.isalpha():
+                if char.upper() == char:
+                    upper_letters += 1
+                    if char == last_char:
+                        return False
+                    else:
+                        last_char = char
+                elif char.lower() == char:
+                    lower_letters += 1
+                    if char == last_char:
+                        return False
+                    else:
+                        last_char = char
+            elif char in punctuation:
+                special_characters += 1
+                if char == last_char:
+                    return False
+                else:
+                    last_char = char
+            else:
+                pass
+        if (upper_letters >= 1 and lower_letters >= 2 and digits >= 2 and
+                special_characters >= 1):
+            return True
+        else:
+            return False
+    else:
+        return False

py_simple/easy_web.py

@@ -0,0 +1,39 @@
+"""
+easy_web is built to simplify getting information from the web.
+"""
+import requests
+from bs4 import BeautifulSoup
+
+
+def get_page_content(url: str) -> str | None:
+    """
+        Returns content of the website or None if an error occurs.
+
+        Arguments:
+            url (str) -- website to be parsed.
+        """
+    try:
+        response = requests.get(url, timeout=10)
+        if response.ok:
+            return BeautifulSoup(response.text, 'html.parser').prettify()
+        else:
+            return None
+    except Exception as e:
+        print(f"Something went wrong with {url}\nERROR: {e}")
+        return None
+
+
+def is_page_up(url: str) -> bool:
+    """
+        Returns true if HTTP status code is 200 else returns false.
+
+        Arguments:
+            url (str) -- website to check.
+        """
+    try:
+        response = requests.get(url, timeout=10)
+        response.raise_for_status()
+        return bool(response.status_code == 200)
+    except Exception as e:
+        print(f"Something went wrong with {url}\nERROR: {e}")
+        return False

py_simple_wrap-0.1.0.dist-info/METADATA

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: py_simple_wrap
+Version: 0.1.0
+Summary: A package to make complex python functionality simple
+Author-email: Sara Czasak <sara.p.czasak.m@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Sara Czasak
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: Homepage, https://github.com/sara-czasak/py_simple
+Project-URL: Repository, https://github.com/sara-czasak/py_simple
+Project-URL: Bug Tracker, https://github.com/sara-czasak/py_simple/issues
+Keywords: python,beginner-friendly,wrapper,education
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Education
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: requests>=2.25.0
+Requires-Dist: beautifulsoup4>=4.9.0
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Dynamic: license-file
+
+# Py_simple 🚀
+
+Making Python feel like plain English.
+
+Py_simple is a beginner-friendly Python wrapper package designed to help beginners and developers perform common tasks using simple, intuitive functions.
+
+The goal of this project is to remove the need for memorizing complex syntax or writing repetitive boilerplate code, making Python more accessible and enjoyable for everyone.
+
+---
+
+## 🛠️ Module Menu
+
+Py_simple provides simple modules designed to make common Python tasks easier.
+
+### 📂 Easy File Manager
+
+Simplify everyday file operations with beginner-friendly utilities.
+
+Features include:
+
+- File management helpers
+- Easier file operations
+- Cleaner Python workflows
+
+---
+
+### 🕰️ Easy Date Formatter
+
+Make working with dates simpler and more readable.
+
+Features include:
+
+- Date formatting utilities
+- Easier date manipulation
+- Simple date-related functions
+
+---
+
+### 🔢 Easy Numbers
+
+Perform common number operations using simple and readable functions.
+
+Features include:
+
+- Number utilities
+- Beginner-friendly calculations
+- Cleaner mathematical operations
+
+---
+### 🔤 Easy Strings
+
+Handle common string operations using clear, beginner-friendly functions.
+
+Features include:
+
+- Removing repeated spaces
+- Converting text to `snake_case`
+- Converting text to `kebab-case`
+- Checking whether text is a palindrome
+
+### 🔄 Easy Converter
+
+Convert values easily using simple utility functions.
+
+Features include:
+
+- Simple conversions
+- Easy-to-use helpers
+- Less repetitive code
+
+---
+
+### ✅ Easy Validator
+
+Validate common input formats using simple, readable functions.
+
+Features include:
+
+- Email, username, and URL validation
+- US zip code validation
+- Password strength validation
+
+---
+
+### 🌐 Easy Web
+[Easy Web Documentation](docs/easy_web.md)
+
+Make getting data from the web less complex.
+
+Features include:
+
+- Checking if website is up
+- Getting page content
+
+More examples and documentation will be added as the project grows.
+
+---
+
+## 🤝 Contributing
+
+I would love to have your help in making Python simpler for everyone!
+
+Contributions of all sizes are welcome:
+
+- Fix documentation
+- Improve existing modules
+- Suggest new features
+- Add new functionality
+- Improve examples
+
+Please check [CONTRIBUTING.md](CONTRIBUTING.md) before submitting changes.
+
+Every contribution helps make Py_simple better for beginners and developers.
+
+---
+
+## 🌟 Hall of Fame
+
+A huge thank you to the wonderful people who have helped build Py_simple:
+
+- **Sara Czasak** (Creator)
+- **ghostfix-pm** (Major features & Refactoring)
+- **jagjitkaur0000** (Added tests for easy_numbers module)
+- **Onion0121** (Improved documentation)
+- **averyquinnhq** (Added tests for easy_converter.py)
+- **gaoharimran29-glitch** (Added tests for easy_validator.py)
+- **mmaxjr** (Improved documentation)
+- **sol4nki** (Expanded easy_converter.py module)
+- **shivams786** (Added easy_strings.py)
+- **HeaTTap** (Added tests for easy_web module)
+
+See the full list of contributions in [CONTRIBUTORS.md](CONTRIBUTORS.md).
+
+---
+
+## ⚖️ License
+
+This project is licensed under the MIT License.
+
+You are free to use, modify, and distribute it.
+
+See the [LICENSE.md](LICENSE.md) file for the full legal text.

py_simple_wrap-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+py_simple/__init__.py,sha256=XHrkE1J8ka270vJ4aibXfvmWcaKenw52HUznudTVJ0w,1278
+py_simple/easy_converter.py,sha256=M8uTmL0zkYHzP3nUZTDsCpuj8_-1YLyVK2vlIEaIBds,7198
+py_simple/easy_date_formatter.py,sha256=Pr0NpXuD4YX4uuifC21K3_w3Rpfhf7IkuWnRN9B-yU0,4426
+py_simple/easy_file_manager.py,sha256=w_hz3frtUspUXc42d0lDO-B4xLmeA_rNvR2Hs3l2Dfw,7191
+py_simple/easy_numbers.py,sha256=P0n8s0WB5xVtHGLHdRJzfiUqYiFx5sjPPWbsx9OIe8A,3651
+py_simple/easy_strings.py,sha256=IkkAjwjuxGsVGawpvti-xWp4Ux1AN-JcfJDE0oAJZxY,1572
+py_simple/easy_validator.py,sha256=PfCMMhKnwPVgAZUB1BFDcdRLxymIN5QfPFCe69g1hfQ,3808
+py_simple/easy_web.py,sha256=rIhcjR1PZ8aWddfSxYXS1l-J5VHLppXl31JDhCsN1fo,1102
+py_simple_wrap-0.1.0.dist-info/licenses/LICENSE.md,sha256=W77s9qaGad9KmOHxFfXCI2DDM2AAvhXcUpK1TrjgERI,1087
+py_simple_wrap-0.1.0.dist-info/METADATA,sha256=fU5n4ZM9w6-UMVuo2nhzcfHWMN463z9r95uxK9cvrV0,5819
+py_simple_wrap-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+py_simple_wrap-0.1.0.dist-info/top_level.txt,sha256=K7f28_hUQjHjTl5yt3GsS_FL4XHvymdpWqF5ZBc819Q,10
+py_simple_wrap-0.1.0.dist-info/RECORD,,

py_simple_wrap-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

py_simple_wrap-0.1.0.dist-info/licenses/LICENSE.md

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

py_simple_wrap-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+py_simple