atomicshop 2.11.47__py3-none-any.whl → 3.10.5__py3-none-any.whl

atomicshop/basics/strings.py

@@ -4,7 +4,7 @@ from pathlib import Path
 import argparse
 
 from . import lists
-from ..print_api import print_api
+from .. import print_api
 
 
 def get_nth_character_from_start(input_string: str, nth: int):
@@ -108,7 +108,12 @@ def is_any_string_from_list_in_string(string_list: list, check_string: str) -> b
     return any(test_string in check_string for test_string in string_list)
 
 
-def match_pattern_against_string(pattern: str, check_string: str, prefix_suffix: bool = False) -> bool:
+def _match_pattern_against_string(
+        pattern: str,
+        check_string: str,
+        case_insensitive: bool = False,
+        prefix_suffix: bool = False
+) -> bool:
     """
     Function checks the 'pattern' against 'check_string' and returns 'True' if pattern matches and 'False' if not.
 
@@ -121,6 +126,7 @@ def match_pattern_against_string(pattern: str, check_string: str, prefix_suffix:
 
     :param pattern: string, can include wildcards as '*'.
     :param check_string: string, to check the pattern against.
+    :param case_insensitive: boolean, if 'True' will treat the 'pattern' and 'check_string' as case-insensitive.
     :param prefix_suffix: boolean, that sets if the function should return 'True' also for all the cases that wildcard
         in the beginning of the pattern and in the end of the pattern, since the default behavior of regex to return
         'False' on these cases.
@@ -152,12 +158,16 @@ def match_pattern_against_string(pattern: str, check_string: str, prefix_suffix:
     # on complex strings.
     # return fnmatch.fnmatch(check_string, pattern)
 
+    # Determine the regex flags based on case_insensitive.
+    flags = re.IGNORECASE if case_insensitive else 0
+
     def search_pattern(function_pattern):
         # Use regex to match the pattern.
-        return re.search(fr'{function_pattern}', check_string)
+        return re.search(fr'{function_pattern}', check_string, flags)
 
     wildcard_str: str = '*'
     wildcard_re: str = '.+'
+    # wildcard_re: str = '.*'  # Adjusted to '.*' to match zero or more characters
 
     # Replace the wildcard string '*' with regex wildcard string '.+'.
     # In regex '.' is a wildcard, but only for 1 character, if you need more than 1 character you should add '+'.
@@ -204,13 +214,86 @@ def match_pattern_against_string(pattern: str, check_string: str, prefix_suffix:
     return False
 
 
-def match_list_of_patterns_against_string(patterns: list, check_string: str, prefix_suffix: bool = False) -> bool:
+def match_pattern_against_string(
+        pattern: str,
+        check_string: str,
+        case_insensitive: bool = False,
+        prefix_suffix: bool = False
+) -> bool:
+    """
+    Function checks the 'pattern' against 'check_string' and returns 'True' if pattern matches and 'False' if not.
+
+    Example:
+        pattern_string = "*ffmpeg*full_build.zip"
+        check_string = "https://github.com/GyanD/codexffmpeg/releases/download/5.1.2/ffmpeg-5.1.2-full_build.zip"
+        match_pattern_against_string(pattern_string, check_string)
+    Result:
+        True
+
+    :param pattern: string, can include wildcards as '*'.
+    :param check_string: string, to check the pattern against.
+    :param case_insensitive: boolean, if 'True' will treat the 'pattern' and 'check_string' as case-insensitive.
+    :param prefix_suffix: boolean, that sets if the function should return 'True' also for all the cases that wildcard
+        in the beginning of the pattern and in the end of the pattern, since the default behavior of regex to return
+        'False' on these cases.
+
+        Example:
+            pattern: *test
+            check_string: testblabla
+        Default regex behavior will return 'False' with 'prefix_suffix' switch set to 'True',
+        this case will return 'True'. Same will go for:
+        pattern: test*
+            check_string: blablatest
+
+        Why this is good?
+        Let's say you have a python script 'example.py' and you want to find all the executed command lines,
+        and you want to make sure that this was executed by 'python'. Your python is installed
+        in 'c:\\Python310\\python.exe', and you want to match all the possible patterns of 'python' and 'example.py'.
+        Pattern:
+            *python*example.py
+        You want to match 'True' for the next cases:
+            python example.py
+            c:\\Python310\\python.exe example.py
+
+        Default regex behavior is to return 'False' on 'python example.py'.
+
+    :return: boolean.
+    """
+    # Determine the regex flags based on case_insensitive.
+    flags = re.IGNORECASE if case_insensitive else 0
+
+    # Escape the pattern for regex, then replace '*' with '.*' to match any characters.
+    escaped_pattern = re.escape(pattern).replace(r'\*', '.*')
+
+    # Adjust the pattern to match from the start and/or end based on prefix_suffix.
+    if prefix_suffix:
+        if not pattern.startswith('*'):
+            escaped_pattern = '.*' + escaped_pattern
+        if not pattern.endswith('*'):
+            escaped_pattern = escaped_pattern + '.*'
+    else:
+        escaped_pattern = '^' + escaped_pattern + '$'
+
+    # Compile the regex pattern with the appropriate flags.
+    regex_pattern = re.compile(escaped_pattern, flags)
+
+    # Perform the search and return the result.
+    return bool(regex_pattern.search(check_string))
+
+
+def match_list_of_patterns_against_string(
+        patterns: list,
+        check_string: str,
+        case_insensitive: bool = False,
+        prefix_suffix: bool = False
+) -> bool:
     """
     Function checks each pattern in 'patterns' list against 'check_string' and returns 'True' if any pattern matches
     and 'False' if not.
 
     :param patterns: list, of string patterns to check against. May include wildcards.
     :param check_string: string, to check the pattern against.
+    :param case_insensitive: boolean, if 'True' will treat the 'pattern' and 'check_string' as case-insensitive.
     :param prefix_suffix: boolean, that sets if the function should return 'True' also for all the cases that wildcard
         in the beginning of the pattern and in the end of the pattern, since the default behavior of regex to return
         'False' on these cases.
@@ -221,7 +304,8 @@ def match_list_of_patterns_against_string(patterns: list, check_string: str, pre
     """
 
     for pattern in patterns:
-        if match_pattern_against_string(pattern, check_string, prefix_suffix=prefix_suffix):
+        if match_pattern_against_string(
+                pattern, check_string, case_insensitive=case_insensitive, prefix_suffix=prefix_suffix):
             return True
 
     return False
@@ -339,7 +423,7 @@ def replace_words_with_values_from_dict(
 
 
 def replace_strings_with_values_from_dict(string_to_replace: str, dictionary: dict) -> str:
-    """
+    r"""
     Function replaces strings, which are keys with values from dictionary.
 
     :param string_to_replace: string, to replace words in.
@@ -453,7 +537,7 @@ def replace_string_in_file(
             file.writelines(lines)
 
     # Output the relevant line numbers
-    print_api(f"Target string found on the following lines: {changed_lines}", **(print_kwargs or {}))
+    print_api.print_api(f"Target string found on the following lines: {changed_lines}", **(print_kwargs or {}))
     return changed_lines
 
 
@@ -487,3 +571,72 @@ def replace_string_in_file_main_argparse():
         new_string=args.new_string,
         find_only=args.find_only
     )
+
+
+def _replace_string_in_variable():
+    """
+    Replace string in a string variable, but do it by a meta variable inside the string.
+    This is just an example, using the 'Template' class from the 'string' module is a better way to do it.
+    """
+
+    from string import Template
+    import os
+    import tempfile
+    import subprocess
+
+    get_docker_url: str = "https://get.docker.com"
+    docker_proxy_image_name: str = "rpardini/docker-registry-proxy:0.6.5"
+    preparation_output_dir: str = str(Path(__file__).parent / "offline-bundle")
+
+    class BashTemplate(Template):
+        # Anything that is not '$', which is a default delimiter in Template class, but also used in bash scripts.
+        # The below symbol can be printed from keyboard by holding 'Alt' and typing '0167' on the numeric keypad.
+        delimiter = '§'
+
+    bash_tmpl = BashTemplate(r"""#!/usr/bin/env bash
+#
+set -Eeuo pipefail
+
+die()       { echo "ERROR: $*" >&2; exit 1; }
+need_root() { [[ $EUID -eq 0 ]] || die "Run as root (use sudo)"; }
+need_cmd() {
+  local cmd=$1
+  local pkg=${2:-$1}               # default package == command
+  if ! command -v "$cmd" &>/dev/null; then
+    echo "[*] $cmd not found – installing $pkg ..."
+    apt-get update -qq
+    DEBIAN_FRONTEND=noninteractive \
+      apt-get install -y --no-install-recommends "$pkg" || \
+      die "Unable to install required package: $pkg"
+  fi
+}
+
+need_root
+need_cmd curl                 # binary and pkg are both “curl”
+need_cmd gpg                  # → apt-get install gpg
+
+DRY_LOG=$(curl -fsSL "§url" | bash -s -- --dry-run)
+IMAGE="§proxyimage"
+ARCHIVE="$OUTDIR/registry-proxy-image.tar.gz"
+zip -r "§output_zip" "$OUTDIR"
+        """)
+
+    # Substitute the variables in the bash script template.
+    bash_script = bash_tmpl.substitute(
+        url=get_docker_url, proxyimage=docker_proxy_image_name, output_zip=preparation_output_dir)
+
+    # Write it to a secure temporary file.
+    with tempfile.NamedTemporaryFile('w', delete=False, suffix='.sh') as f:
+        f.write(bash_script)
+        temp_path = f.name
+    os.chmod(temp_path, 0o755)  # make it executable
+
+    # Decide where the bundle should land (optional argument to the script).
+    cmd = ["sudo", temp_path, preparation_output_dir]  # use sudo because the script demands root
+
+    # Run it and stream output live.
+    try:
+        subprocess.run(cmd, check=True)
+    finally:
+        # 5. Clean up the temp file unless you want to inspect it.
+        os.remove(temp_path)

atomicshop/basics/threads.py

@@ -18,6 +18,20 @@ def current_thread_id():
     return thread_id
 
 
+def get_current_thread_name():
+    return threading.current_thread().name
+
+
+def set_current_thread_name(name: str):
+    threading.current_thread().name = name
+
+
+def set_current_thread_name_by_process_name():
+    import multiprocessing
+    current_process_name = multiprocessing.current_process().name
+    threading.current_thread().name = current_process_name
+
+
 def get_number_of_active_threads():
     return threading.active_count()
 

atomicshop/basics/tracebacks.py

@@ -1,17 +1,26 @@
-# v1.0.0 - 02.04.2023 16:20
 import traceback
 
 
-def get_as_string(one_line: bool = False, replace_end: str = str()) -> str:
+def get_as_string(
+        exc: BaseException = None,
+        one_line: bool = False,
+        replace_end: str = str()
+) -> str:
     """
     Returns traceback as string.
 
+    :param exc: Exception to get traceback from. If 'None', current exception will be used.
     :param one_line: If 'True', traceback will be returned as one line.
     :param replace_end: If 'one_line' is 'True', this string will be used to replace '\n' in traceback.
     :return: Traceback as string.
     """
 
+    if exc is None:
+        stringed_exception: str = traceback.format_exc()
+    else:
+        stringed_exception: str = ''.join(traceback.TracebackException.from_exception(exc).format())
+
     if not one_line:
-        return traceback.format_exc()
+        return stringed_exception
     else:
-        return traceback.format_exc().replace('\n', replace_end)
+        return stringed_exception.replace('\n', replace_end)

atomicshop/certificates.py

@@ -5,9 +5,10 @@ https://oidref.com/1.3.6.1.5.5.7.3.1
 
 
 import ssl
+from typing import Literal, Any
 
 from .wrappers import cryptographyw
-from .print_api import print_api
+from .wrappers.pywin32w import cert_store
 
 
 # Valid for 3 years from now
@@ -16,72 +17,172 @@ from .print_api import print_api
 SECONDS_NOT_AFTER_3_YEARS = 3 * 365 * 24 * 60 * 60
 
 
-def is_certificate_in_store(certificate, issuer_only: bool = False, thumbprint_only: bool = False):
+def get_pem_certificate_from_string(certificate: str) -> str:
     """
-    The function will check if the certificate is installed in the Windows certificate store.
-
-    :param certificate: x509 object, certificate to check.
-    :param issuer_only: bool, if True, will check only by the certificate issuer common name is installed in the store.
-        The problem that the issuer common name is not unique, so it can be installed multiple times.
-    :param thumbprint_only: bool, if True, will check only by the certificate thumbprint is installed in the store.
-        The problem that searching by the thumbprint will not tell you if there are multiple certificates with the same
-        issuer name.
-    :return: bool, True if certificate is installed, False if not.
+    Some PEM certificates can contain a private key. This function will return only the certificate part.
+
+    :param certificate: string, PEM certificate.
+    :return: string, certificate part.
     """
 
-    # Make sure the certificate is x509.Certificate object.
-    certificate = cryptographyw.convert_object_to_x509(certificate)
-    # Get the certificate thumbprint.
-    thumbprint = cryptographyw.get_sha1_thumbprint_from_x509(certificate)
-    issuer_common_name: str = cryptographyw.get_issuer_common_name_from_x509(certificate)
+    certificate_lines = certificate.split('\n')
+    certificate_part = ''
+    start = False
+    for line in certificate_lines:
+        if 'BEGIN CERTIFICATE' in line:
+            start = True
+        if start:
+            certificate_part += line + '\n'
+        if 'END CERTIFICATE' in line:
+            break
 
-    # for store in ["CA", "ROOT", "MY"]:
-    for cert, encoding, trust in ssl.enum_certificates("ROOT"):
-        store_certificate = cryptographyw.convert_object_to_x509(cert)
-        store_issuer_common_name: str = cryptographyw.get_issuer_common_name_from_x509(store_certificate)
-        store_thumbprint = cryptographyw.get_sha1_thumbprint_from_x509(store_certificate)
-
-        if issuer_only:
-            if store_issuer_common_name == issuer_common_name:
-                return True, certificate
-        elif thumbprint_only:
-            if store_thumbprint == thumbprint:
-                return True, certificate
-        elif not issuer_only and not thumbprint_only:
-            if store_thumbprint == thumbprint and store_issuer_common_name == issuer_common_name:
-                return True, certificate
+    return certificate_part
 
 
-def get_certificates_by_issuer_name(issuer_name: str, print_kwargs: dict = None):
+def write_crt_certificate_file_in_pem_format_from_pem_file(
+        pem_file_path: str,
+        crt_file_path: str
+):
     """
-    The function will return all certificates with the specified issuer name.
+    The function will read the PEM certificate file and write it to the CRT file in PEM format.
+    The function is used to convert the PEM certificate file to the CRT file.
 
-    :param issuer_name: string, issuer name to search for.
-    :param print_kwargs: dict, that contains all the arguments for 'print_api' function.
+    Basically the point here is that the CRT file is the same as the PEM file, but the extension is different,
+    and it doesn't support integrated private key.
 
-    :return: list, of certificates with the specified issuer name.
+    :param pem_file_path: string, path to the PEM certificate file.
+    :param crt_file_path: string, path to the CRT certificate file.
     """
 
-    if not print_kwargs:
-        print_kwargs = {}
+    with open(pem_file_path, 'r') as f:
+        certificate_string = f.read()
 
-    certificates_list = []
+    certificate_pem = get_pem_certificate_from_string(certificate_string)
+
+    with open(crt_file_path, 'w') as f:
+        f.write(certificate_pem)
+
+
+def is_certificate_in_store(
+        certificate: Any = None,
+        by_cert_issuer: bool = True,
+        by_cert_thumbprint: bool = True,
+        issuer_name: str = None,
+        store_location: str = "ROOT",
+        print_kwargs: dict = None
+) -> tuple[bool, list]:
+    """
+    The function will check if the CA certificate is installed in the Windows certificate Trusted Root store.
+    NO ADMIN RIGHTS NEEDED.
+
+    :param certificate: x509 object, certificate to check. You can search by certificate or by issuer name.
+        Supported types:
+            string that is path to file will be imported as bytes object abd converted to x509.Certificate
+                After check if it's PEM or DER format.
+            string that is PEM certificate will be converted to bytes, then x509.Certificate
+            bytes of PEM or DER will be converted to x509.Certificate.
+            x509.Certificate will be returned as is.
+    :param by_cert_issuer: bool, if True, will check only by the certificate issuer common name is installed in the store.
+        The problem if the search will be by issuer alone, that the issuer common name is not unique,
+        so it can be installed multiple times.
+    :param by_cert_thumbprint: bool, if True, will check only by the certificate thumbprint is installed in the store.
+        The problem that searching by the thumbprint alone will not tell you if there are multiple
+        certificates with the same issuer name.
+    :param issuer_name: string, issuer name to search for. You can search by certificate or by issuer name.
+    :param store_location: string, store location to search in. Default is "ROOT".
+    :param print_kwargs: dict, print_api kwargs.
+    :return: tuple(bool - True if certificate is installed and False if not, list of certificates found)
+    """
+
+    if not by_cert_issuer and not by_cert_thumbprint:
+        raise ValueError('At least one of the parameters "by_issuer" or "by_thumbprint" must be True.')
+
+    if not certificate and not issuer_name:
+        raise ValueError('At least one of the parameters "certificate" or "issuer_name" must be provided.')
+    elif certificate and issuer_name:
+        raise ValueError('Only one of the parameters "certificate" or "issuer_name" must be provided.')
+
+    if certificate:
+        # Make sure the certificate is x509.Certificate object.
+        certificate_x509 = cryptographyw.convert_object_to_x509(certificate, print_kwargs=print_kwargs)
+        # Get the certificate thumbprint.
+        provided_thumbprint = cryptographyw.get_sha1_thumbprint_from_x509(certificate_x509)
+        provided_issuer_common_name: str = cryptographyw.get_issuer_common_name_from_x509(certificate_x509)
+    elif issuer_name:
+        provided_thumbprint = None
+        provided_issuer_common_name = issuer_name
+    else:
+        raise ValueError('At least one of the parameters "certificate" or "issuer_name" must be provided.')
 
-    for cert, encoding, trust in ssl.enum_certificates("ROOT"):
+    # Iterate over all certificates in the store specifically in the ROOT.
+    # for store in ["CA", "ROOT", "MY"]:
+    result_found_list: list = []
+    found: bool = False
+    for cert, encoding, trust in ssl.enum_certificates(store_location):
+        # Some certificates in the store can have zero or negative serial number.
+        # We will skip them, since they're deprecated by the cryptography library.
         store_certificate = cryptographyw.convert_object_to_x509(cert)
+        if not store_certificate:
+            continue
+
         store_issuer_common_name: str = cryptographyw.get_issuer_common_name_from_x509(store_certificate)
+        store_thumbprint = cryptographyw.get_sha1_thumbprint_from_x509(store_certificate)
 
-        if store_issuer_common_name == issuer_name:
-            certificates_list.append(store_certificate)
+        if certificate:
+            if by_cert_issuer and not by_cert_thumbprint:
+                if store_issuer_common_name == provided_issuer_common_name:
+                    result_found_list.append(store_certificate)
+                    found = True
+            elif by_cert_thumbprint and not by_cert_issuer:
+                if store_thumbprint == provided_thumbprint:
+                    result_found_list.append(store_certificate)
+                    found = True
+            elif by_cert_issuer and by_cert_thumbprint:
+                if store_thumbprint == provided_thumbprint and store_issuer_common_name == provided_issuer_common_name:
+                    result_found_list.append(store_certificate)
+                    found = True
+        elif issuer_name:
+            if store_issuer_common_name == provided_issuer_common_name:
+                result_found_list.append(store_certificate)
+                found = True
+
+    return found, result_found_list
+
+
+def delete_certificate_by_issuer_name(
+        issuer_name: str,
+        store_location: Literal[
+            "ROOT",
+            "CA",
+            "MY"] = "ROOT",
+        print_kwargs: dict = None
+):
+    """
+    NEED ADMIN RIGHTS.
+    The function will remove all certificates with the specified issuer name.
+    There can be several certificates with this name.
 
-    if certificates_list:
-        for certificate_single in certificates_list:
-            issuer_name = cryptographyw.get_issuer_common_name_from_x509(certificate_single)
-            thumbprint = cryptographyw.get_sha1_thumbprint_from_x509(certificate_single)
-            message = f'Issuer name: {issuer_name} | Thumbprint: {thumbprint}'
-            print_api(message, **print_kwargs)
-    else:
-        message = f'No certificates with issuer name: {issuer_name}'
-        print_api(message, **print_kwargs)
+    :param issuer_name: string, issuer name to search for.
+    :param store_location: string, store location to search in. Default is "ROOT".
+    :param print_kwargs: dict, print_api kwargs.
+    """
+
+    cert_store.delete_certificate_by_issuer_name(issuer_name, store_location, print_kwargs)
+
+
+def install_certificate_file(
+        file_path: str,
+        store_location: Literal[
+            "ROOT", "CA", "MY"] = "ROOT",
+        print_kwargs: dict = None
+):
+    """
+    The function will install the certificate from the file to the specified store location.
+    NEED ADMIN RIGHTS.
+
+    :param file_path: string, full file path to the certificate file.
+    :param store_location: string, store location to install the certificate. Default is "ROOT".
+    :param print_kwargs: dict, print_api kwargs.
+    """
 
-    return certificates_list
+    cert_store.install_certificate_file(file_path, store_location, print_kwargs)

atomicshop/config_init.py

@@ -2,13 +2,17 @@ import os
 
 from .file_io import tomls
 from . import filesystem
-from .print_api import print_api
+from . import print_api
 
 CONFIG_FILE_NAME = 'config.toml'
 CONFIG: dict = dict()
 
 
-def get_config(script_directory: str = None, config_file_name: str = CONFIG_FILE_NAME) -> dict:
+def get_config(
+        script_directory: str = None,
+        config_file_name: str = CONFIG_FILE_NAME,
+        print_kwargs: dict = None
+) -> dict:
     """
     Get the config file content.
 
@@ -16,6 +20,7 @@ def get_config(script_directory: str = None, config_file_name: str = CONFIG_FILE
         get the working directory instead.
     :param config_file_name: string, name of the config file. Default is 'config.toml' as specified in the constant:
         'CONFIG_FILE_NAME'.
+    :param print_kwargs: dict, additional arguments to pass to the print function. Default is None.
     :return: dict.
     """
 
@@ -25,7 +30,7 @@ def get_config(script_directory: str = None, config_file_name: str = CONFIG_FILE
     if not script_directory:
         script_directory = filesystem.get_working_directory()
 
-    CONFIG = tomls.read_toml_file(f'{script_directory}{os.sep}{config_file_name}')
+    CONFIG = tomls.read_toml_file(f'{script_directory}{os.sep}{config_file_name}', **(print_kwargs or {}))
     return CONFIG
 
 
@@ -45,7 +50,7 @@ def write_config(
         'CONFIG_FILE_NAME'.
     :param print_message: boolean, if True, the function will print the message about the created config file.
         Also, it will wait for the user to press Enter to exit the script.
-        If False, the function will not print anything and will not exit..
+        If False, the function will not print anything and will not exit.
     :return:
     """
 
@@ -58,11 +63,11 @@ def write_config(
 
     config_file_path = f'{script_directory}{os.sep}{config_file_name}'
 
-    if not filesystem.check_file_existence(config_file_path):
+    if not filesystem.is_file_exists(config_file_path):
         tomls.write_toml_file(config, f'{script_directory}{os.sep}{config_file_name}')
 
         if print_message:
-            print_api(f"Created config file: {config_file_path}", color="yellow")
-            print_api(f"You need to fill it with details.", color="yellow")
+            print_api.print_api(f"Created config file: {config_file_path}", color="yellow")
+            print_api.print_api(f"You need to fill it with details.", color="yellow")
             input("Press Enter to exit.")
             exit()

atomicshop/console_user_response.py

@@ -1,11 +1,12 @@
-# v1.0.2 - 26.03.2023 20:40
 import sys
 
 
-def query_positive_negative(question_string: str,
-                            add_first_values_to_question: bool = True,
-                            positive_answers: list = None,
-                            negative_answers: list = None) -> bool:
+def query_positive_negative(
+        question_string: str,
+        add_first_values_to_question: bool = True,
+        positive_answers: list = None,
+        negative_answers: list = None
+) -> bool:
     """
     Ask for "yes" / "no" input to a question that is passed as a "question_string".
     Returns 'True' for 'positive' answers and 'False' for 'negative' answers.
@@ -31,10 +32,8 @@ def query_positive_negative(question_string: str,
     if add_first_values_to_question:
         question_string = f'{question_string} [{positive_answers[0]}/{negative_answers[0]}]'
 
-    # Defining variable as False for While loop to run
-    right_answer = False
     # As long as "right_answer" is False the loop will execute again
-    while not right_answer:
+    while True:
         # Print the passed question
         print(question_string)
         # Get the input from the console in lowercase
@@ -42,22 +41,16 @@ def query_positive_negative(question_string: str,
 
         # If the gathered value is in "Yes" answers array
         if choice in positive_answers:
-            # "right_answer" variable is True, so the loop will not execute again
-            right_answer = True
             # Function will return True
             return True
         # Else If the gathered value is in "No" answers array
         elif choice in negative_answers:
-            # "right_answer" variable is True, so the loop will not execute again
-            right_answer = True
             # Function will return False
             return False
         # If the gathered input is not in the arrays
         else:
             # Then output to console the message
             print("Please respond with either:", positive_answers, negative_answers)
-            # "right_answer" variable stays False, so the loop will execute again
-            right_answer = False
 
 
 def do_you_want_to_continue_yn(message: str) -> None:

atomicshop/consoles.py

@@ -0,0 +1,9 @@
+import msvcrt
+
+
+# === WINDOWS ONLY FUNCTIONS ===========================================================================================
+def wait_any_key(prompt="Press any key to continue..."):
+    print(prompt, end="", flush=True)
+    msvcrt.getch()  # waits for one key press (no Enter needed)
+    print()         # move to next line
+# === EOF WINDOWS ONLY FUNCTIONS =======================================================================================