vigilant-kit 1.2.9__tar.gz → 1.4.0__tar.gz

{vigilant_kit-1.2.9 → vigilant_kit-1.4.0}/CHANGELOG.md

@@ -1,4 +1,26 @@
 # Changelog for Vigilant Kit
+## Version 1.4.0
+
+### Code Refactoring
+- Removed `vgl` CLI.
+- Updated `VigilantDriver` class, now scripts can be run without Selenium server, only using local browser.
+- Updated documentation related to new configuration.
+
+### Dependencies
+
+- Removed pacakge: `click`.
+
+
+## Version 1.3.0
+
+### New Features
+
+- Changed way of configuration for local development. Introduced `vgl_config.yaml` file.
+- Updated documentation related to new configuration.
+
+### Dependencies
+
+- Added new dependency: `pyyaml`.
 
 ## Version 1.2.9
 

{vigilant_kit-1.2.9 → vigilant_kit-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vigilant_kit
-Version: 1.2.9
+Version: 1.4.0
 Summary: Library that makes functional testing with Selenium WebDriver fast and easy. 
 Project-URL: Homepage, https://github.com/ivpel/vigilant
 Project-URL: Bug Tracker, https://github.com/ivpel/vigilant/issues
@@ -8,9 +8,9 @@ Author-email: Pelykh Ivan <ivan.pelykh@protonmail.com>
 License-File: LICENSE
 Keywords: bdd,functional,functional-testing,pytest,selenium,tdd,testing,unittest,webdriver
 Requires-Python: >=3.7
-Requires-Dist: click
 Requires-Dist: psutil
 Requires-Dist: python-dotenv
+Requires-Dist: pyyaml
 Requires-Dist: requests
 Requires-Dist: selenium
 Description-Content-Type: text/markdown
@@ -22,17 +22,17 @@ Vigilant, you can start writing complex test cases in a minute.
 ## Why Vigilant?
 * **Easy to start & Fast To Write**: Vigilant provides you with methods that help you write functional tests quickly 
 without spending time on writing boilerplate code every time you start a new project.
-* **Flexible Framework Usage**: Usage is not limited to a single testing framework; you can use Vigilant with unittest,
-  pytest, or anything else.
-* **Stability**: We use Selenium WebDriver. It is a W3C Recommendation.
+* **No limit in usage**: You are not limited to a single testing framework; you can use Vigilant with **unittest**,
+  **pytest**, or for **scrapping data**. It's just a tool, use it as you want.
+* **Stability**: We use Selenium WebDriver. It is a **W3C standard**.
    - WebDriver drives a browser natively, as a user would, either locally or on a remote machine using the Selenium server.
    - WebDriver is designed as a simple and more concise programming interface.
    - WebDriver is a compact object-oriented API.
    - It drives the browser effectively.
 
 ## What it includes?
-Vigilant include methods for interacting with browser,  for asserting conditions and also methods for waiting 
-those conditions.
+Vigilant provide a suite of methods designed for efficient browser interaction, robust assertion of various 
+conditions, and adaptive waiting mechanisms to accommodate different states and conditions.
 
 **Interacting with WebBrowser** 
    - `click()`
@@ -59,11 +59,6 @@ those conditions.
 And much more! Check list of all available - [Actions](docs/actions.md)
 
 
-Also, CLI scripts included, to make your life easier!
-
-Use `vgl --help` to see all available commands.
-
-
 ## Extending Functionality
 If you need something that is not covered in this library, you still have access to all native `Selenium WebDriver` 
 methods. You can create your own methods or use native `WebDriver` methods and share them on one browser session.
@@ -74,8 +69,6 @@ pip install vigilant-kit
 ```
 
 ## Docs
-### Install
-- [How to install Selenium server & browser drivers](docs/selenium_install.md)
 
 ### Configuration
 - [Vigilant configuration](docs/configuration.md)

{vigilant_kit-1.2.9 → vigilant_kit-1.4.0}/README.md

@@ -5,17 +5,17 @@ Vigilant, you can start writing complex test cases in a minute.
 ## Why Vigilant?
 * **Easy to start & Fast To Write**: Vigilant provides you with methods that help you write functional tests quickly 
 without spending time on writing boilerplate code every time you start a new project.
-* **Flexible Framework Usage**: Usage is not limited to a single testing framework; you can use Vigilant with unittest,
-  pytest, or anything else.
-* **Stability**: We use Selenium WebDriver. It is a W3C Recommendation.
+* **No limit in usage**: You are not limited to a single testing framework; you can use Vigilant with **unittest**,
+  **pytest**, or for **scrapping data**. It's just a tool, use it as you want.
+* **Stability**: We use Selenium WebDriver. It is a **W3C standard**.
    - WebDriver drives a browser natively, as a user would, either locally or on a remote machine using the Selenium server.
    - WebDriver is designed as a simple and more concise programming interface.
    - WebDriver is a compact object-oriented API.
    - It drives the browser effectively.
 
 ## What it includes?
-Vigilant include methods for interacting with browser,  for asserting conditions and also methods for waiting 
-those conditions.
+Vigilant provide a suite of methods designed for efficient browser interaction, robust assertion of various 
+conditions, and adaptive waiting mechanisms to accommodate different states and conditions.
 
 **Interacting with WebBrowser** 
    - `click()`
@@ -42,11 +42,6 @@ those conditions.
 And much more! Check list of all available - [Actions](docs/actions.md)
 
 
-Also, CLI scripts included, to make your life easier!
-
-Use `vgl --help` to see all available commands.
-
-
 ## Extending Functionality
 If you need something that is not covered in this library, you still have access to all native `Selenium WebDriver` 
 methods. You can create your own methods or use native `WebDriver` methods and share them on one browser session.
@@ -57,8 +52,6 @@ pip install vigilant-kit
 ```
 
 ## Docs
-### Install
-- [How to install Selenium server & browser drivers](docs/selenium_install.md)
 
 ### Configuration
 - [Vigilant configuration](docs/configuration.md)

vigilant_kit-1.4.0/docs/configuration.md

@@ -0,0 +1,58 @@
+# Vigilant Configuration
+
+Vigilant is a Selenium-based library that allows you to automate web testing tasks. The configuration of Vigilant is 
+available through simple `vgl_config.yaml` file.
+
+## Configuration Options
+
+Vigilant can be configured with the following options:
+
+**BASE_URL**
+
+- Description: The base URL of the website to be tested.
+- YAML Path: selenium-configuration.BASE_URL
+- Example: BASE_URL: http://www.python.org
+
+**SELENIUM_HOST**
+
+- Description: The Selenium server host URL.
+- YAML Path: vgl-configuration.SELENIUM_HOST
+- Example: SELENIUM_HOST: http://127.0.0.1:4444/wd/hub
+
+When use **SELENIUM_HOST**: local - local installed browser will be used.
+
+**SELENIUM_BROWSER**
+
+- Description: The browser to be used for testing.
+- YAML Path: selenium-configuration.SELENIUM_BROWSER
+- Example: SELENIUM_BROWSER: firefox
+
+**WAIT_TIMEOUT**
+
+- Description: The timeout duration (in seconds) for wait operations.
+- YAML Path: selenium-configuration.WAIT_TIMEOUT
+- Example: WAIT_TIMEOUT: 10
+
+**LOGGER_LEVEL**
+
+- Description: The logging level for Vigilant.
+- YAML Path: selenium-configuration.LOGGER_LEVEL
+- Example: LOGGER_LEVEL: INFO
+
+## Configuration File
+
+The configuration file `vgl_config.yaml` should be structured as follows:
+
+```yaml
+vgl-configuration:
+  BASE_URL: http://www.python.org
+  SELENIUM_HOST: http://127.0.0.1:4444/wd/hub
+  SELENIUM_BROWSER: firefox
+  WAIT_TIMEOUT: 10
+  LOGGER_LEVEL: INFO
+```
+You can modify the values in the YAML file to suit your specific configuration requirements.
+
+## Environment Variables
+Vigilant will automatically load these settings as environment variables at runtime. There's no need to manually set 
+environment variables if they are defined in the `vgl_config.yaml` file.

{vigilant_kit-1.2.9 → vigilant_kit-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "vigilant_kit"
-version = "1.2.9"
+version = "1.4.0"
 authors = [
   { name="Pelykh Ivan", email="ivan.pelykh@protonmail.com" },
 ]
@@ -14,15 +14,15 @@ requires-python = ">=3.7"
 dependencies = [
     "selenium",
     "python-dotenv",
-    "click",
     "requests",
-    "psutil"
+    "psutil",
+    "pyyaml"
 ]
 
 keywords = ["testing", "selenium", "webdriver", "pytest", "unittest", "bdd", "tdd", "functional", "functional-testing"]
 
 [tool.hatch.build.targets.wheel]
-packages = ["src/vigilant", "src/vgl_cli"]
+packages = ["src/vigilant"]
 
 classifiers = [
     "Programming Language :: Python :: 3",
@@ -33,6 +33,3 @@ classifiers = [
 [project.urls]
 "Homepage" = "https://github.com/ivpel/vigilant"
 "Bug Tracker" = "https://github.com/ivpel/vigilant/issues"
-
-[project.scripts]
-vgl = "vgl_cli.vgl:vgl"

vigilant_kit-1.4.0/src/vigilant/driver/__init__.py

@@ -0,0 +1,24 @@
+import os
+import yaml
+from pathlib import Path
+
+def set_env_variables_from_dict(data):
+    for key, value in data.items():
+        os.environ[key] = str(value)
+
+def set_env_variables_from_yaml(yaml_path):
+    with open(yaml_path, 'r') as file:
+        configs = yaml.safe_load(file)
+
+    selenium_config = configs.get('vgl-configuration', {})
+    set_env_variables_from_dict(selenium_config)
+
+
+CONFIG_YAML_FILE = 'vgl_config.yaml'
+
+if Path(CONFIG_YAML_FILE).exists():
+    print(f"Setting configuration from {CONFIG_YAML_FILE} file.")
+    set_env_variables_from_yaml(CONFIG_YAML_FILE)
+else:
+    print(f"Could not find `{CONFIG_YAML_FILE}` configuration file.")
+    print("If you don't want to use the yaml configuration file, ensure you provide all configuration data as environment variables.")

vigilant_kit-1.4.0/src/vigilant/driver/vigilant_driver.py

@@ -0,0 +1,45 @@
+import os
+
+from selenium import webdriver
+
+from vigilant.actions.vigilant_actions import VigilantActions
+from vigilant.logger import logger as log
+
+
+class VigilantDriver(VigilantActions):
+
+    SELENIUM_HOST = os.environ.get("SELENIUM_HOST")
+    SELENIUM_BROWSER = os.environ.get("SELENIUM_BROWSER")
+
+    def __init__(self):
+        browser_options = self.default_browser_options()
+        if self.SELENIUM_HOST in ["local", None, ""]:
+            self.driver = self.create_local_driver_session(browser_options)
+        else:
+            self.driver = self.create_remote_driver_session(browser_options)
+        VigilantActions.__init__(self, self.driver)
+
+    def default_browser_options(self):
+        options = None
+        if self.SELENIUM_BROWSER.lower() == "firefox":
+            options = webdriver.FirefoxOptions()
+        elif self.SELENIUM_BROWSER.lower() == "chrome":
+            options = webdriver.ChromeOptions()
+        log.info(f"Setting default browser options: {self.SELENIUM_BROWSER}")
+        return options
+
+    def create_remote_driver_session(self, browser_options):
+        log.info("Creating remote session.\n"
+                 f"Command executor: {self.SELENIUM_HOST}\n"
+                 f"Browser: {self.SELENIUM_BROWSER}")
+        return webdriver.Remote(command_executor=self.SELENIUM_HOST,
+                                options=browser_options)
+
+    def create_local_driver_session(self, browser_options):
+        log.info("Creating local session.\n"
+                 f"Browser: {self.SELENIUM_BROWSER}")
+        if self.SELENIUM_BROWSER.lower() == "firefox":
+            return webdriver.Firefox(options=browser_options)
+        elif self.SELENIUM_BROWSER.lower() == "chrome":
+            return webdriver.Chrome(options=browser_options)
+        raise ValueError("Unsupported browser specified")

vigilant_kit-1.4.0/vgl_config.yaml.example

@@ -0,0 +1,8 @@
+selenium-configuration:
+  BASE_URL: http://www.python.org
+  SELENIUM_HOST: local #http://127.0.0.1:4444/wd/hub
+  SELENIUM_BROWSER: firefox
+  WAIT_TIMEOUT: 10
+  LOGGER_LEVEL: INFO
+test-credentials:
+  file: credentials.yaml

vigilant_kit-1.2.9/.vigilant.env.example

@@ -1,5 +0,0 @@
-BASE_URL=http://www.python.org
-SELENIUM_HOST=http://127.0.0.1:4444/wd/hub
-SELENIUM_BROWSER=firefox
-WAIT_TIMEOUT=10
-LOGGER_LEVEL=INFO

vigilant_kit-1.2.9/docs/configuration.md

@@ -1,76 +0,0 @@
-# Vigilant Configuration
-
-Vigilant is a Selenium-based library that allows you to automate web testing tasks. The configuration of Vigilant can be
-customized using environment variables. You have the option to configure Vigilant using either a `.vigilant.env` file or
-a `vigilant.json` file. Alternatively, you can directly set the configuration using environment variables of your choice.
-
-## Configuration Options
-**BASE_URL**
-
-    Description: The base URL of the website to be tested.
-    Environment Variable: BASE_URL
-    Example: BASE_URL=http://www.python.org
-
-**SELENIUM_HOST**
-
-    Description: The Selenium server host URL.
-    Environment Variable: SELENIUM_HOST
-    Example: SELENIUM_HOST=http://127.0.0.1:4444/wd/hub
-
-**SELENIUM_BROWSER**
-
-    Description: The browser to be used for testing.
-    Environment Variable: SELENIUM_BROWSER
-    Example: SELENIUM_BROWSER=firefox
-
-**WAIT_TIMEOUT**
-
-    Description: The timeout duration (in seconds) for wait operations.
-    Environment Variable: WAIT_TIMEOUT
-    Example: WAIT_TIMEOUT=10
-
-**LOGGER_LEVEL**
-
-    Description: The logging level for Vigilant.
-    Environment Variable: LOGGER_LEVEL
-    Example: LOGGER_LEVEL=INFO
-
-## Configuration Files
-**vigilant.json**
-
-The `vigilant.json` file allows you to define the configuration options in a JSON format. Here's an example of the 
-`vigilant.json` file:
-```json
-{
-  "BASE_URL": "http://www.python.org",
-  "SELENIUM_HOST": "http://127.0.0.1:4444/wd/hub",
-  "SELENIUM_BROWSER": "firefox",
-  "WAIT_TIMEOUT": 10,
-  "LOGGER_LEVEL": "INFO"
-}
-```
-
-You can modify the values in the JSON file to suit your specific configuration requirements.
-`.vigilant.env`
-
-The `.vigilant.env` file allows you to define the configuration options in a key-value format. Each configuration option
-is set as an environment variable. Here's an example of the `.vigilant.env` file:
-```shell
-BASE_URL=http://www.python.org
-SELENIUM_HOST=http://127.0.0.1:4444/wd/hub
-SELENIUM_BROWSER=firefox
-WAIT_TIMEOUT=10
-LOGGER_LEVEL=INFO
-
-```
-Each line represents a configuration option in the format **KEY=VALUE**.
-
-## Environment Variables
-
-Alternatively, you can directly set the configuration options using environment variables of your choice. Simply set the desired environment variables with the appropriate values.
-
-## Note
-
-Ensure that you have the required dependencies and tools installed for Vigilant, such as Selenium and the corresponding browser drivers.
-
-By configuring Vigilant using the methods mentioned above, you can customize its behavior to suit your testing needs and automate web testing tasks effectively.

vigilant_kit-1.2.9/src/vgl_cli/install_dev_kit_command.py

@@ -1,14 +0,0 @@
-import click
-from .install_webdriver_command import check_version_and_download_driver
-from .install_standalone_command import check_req_and_install_selenium_server
-
-
-@click.command(name='install:dev-kit', help="Install local development kit (Webdriver, Selenium Server, etc)")
-@click.option('-b', '--browser', type=click.Choice(['chrome', 'firefox', 'edge']), required=True)
-def install_dev_kit(browser):
-    check_req_and_install_selenium_server()
-    check_version_and_download_driver(browser)
-
-
-if __name__ == "__main__":
-    install_dev_kit()

vigilant_kit-1.2.9/src/vgl_cli/install_standalone_command.py

@@ -1,44 +0,0 @@
-import click
-import os
-import requests
-
-SELENIUM_SERVER_URL = "https://selenium-release.storage.googleapis.com/3.141/selenium-server-standalone-3.141.59.jar"
-SELENIUM_SERVER_FILE = "selenium-server/selenium-server-standalone.jar"
-
-
-def check_selenium_requirements():
-    java_path = os.popen("which java").read().strip()
-    if not java_path:
-        click.secho("Java is not installed on this machine.", fg="red")
-        return False
-
-    java_version = os.popen("java -version 2>&1 | awk -F '\"' '/version/ {print $2}'").read().strip()
-    major_version = java_version.split('.')[0]
-    if int(major_version) < 9:
-        click.secho(f"Java version {java_version} is not supported. Please install Java 9 or higher.", fg="red")
-        return False
-
-    return True
-
-
-def download_selenium_server():
-    response = requests.get(SELENIUM_SERVER_URL)
-    os.makedirs("selenium-server", exist_ok=True)
-    with open(SELENIUM_SERVER_FILE, "wb") as f:
-        f.write(response.content)
-
-
-def check_req_and_install_selenium_server():
-    if check_selenium_requirements():
-        click.secho("Downloading Selenium Standalone server ...", nl=False)
-        download_selenium_server()
-        click.secho("OK", fg="green")
-
-
-@click.command(name="install:standalone", help="Install Selenium Standalone server.")
-def install_selenium_standalone():
-    check_req_and_install_selenium_server()
-
-
-if __name__ == "__main__":
-    install_selenium_standalone()

vigilant_kit-1.2.9/src/vgl_cli/install_webdriver_command.py

@@ -1,111 +0,0 @@
-import click
-import os
-import platform
-import requests
-import tarfile
-import zipfile
-
-BROWSER_VERSIONS = {
-    "chrome": "https://chromedriver.storage.googleapis.com/LATEST_RELEASE",
-    "firefox": "https://api.github.com/repos/mozilla/geckodriver/releases/latest",
-    "edge": "https://msedgedriver.azureedge.net/LATEST_RELEASE"
-}
-
-
-def get_browser_version(browser):
-    if browser == "chrome":
-        # Get the latest version of Chrome from the output of the "google-chrome --version" command
-        chrome_version = os.popen("google-chrome --version").read().strip().split()[-1]
-        return chrome_version
-    elif browser == "firefox":
-        # Get the latest version of Firefox from the output of the "firefox --version" command
-        firefox_version = os.popen("firefox --version").read().strip().split()[-1]
-        return firefox_version.split('.')[0]
-    elif browser == "edge":
-        try:
-            # Get the latest version of Edge from the output of the "msedge --version" command
-            edge_version = os.popen("msedge --version").read().strip().split()[-1]
-            return edge_version.split('.')[0]
-        except IndexError:
-            click.echo(f"Failed to get {browser} version")
-            return None
-    else:
-        click.echo(f"{browser} is not a supported browser")
-        return None
-
-
-def download_driver(browser, version):
-    download_url = None
-    if browser in BROWSER_VERSIONS:
-        if browser == "chrome":
-            # Get the major version of the Chrome browser installed on the machine
-            chrome_version = get_browser_version(browser)
-            if chrome_version is None:
-                click.secho(f"{browser} is not installed on this machine.", fg="red")
-                return
-            # Use the ChromeDriver API to get the latest version of the ChromeDriver that is compatible with the installed Chrome browser
-            response = requests.get(f"https://chromedriver.storage.googleapis.com/LATEST_RELEASE_{chrome_version.split('.')[0]}")
-            if response.status_code == 200:
-                latest_version = response.text
-                download_url = f"https://chromedriver.storage.googleapis.com/{latest_version}/chromedriver_{platform.system().lower()}64.zip"
-            else:
-                click.secho(f"Could not find latest {browser} driver version.", fg="red")
-        elif browser == "firefox":
-            r = requests.get(BROWSER_VERSIONS[browser])
-            release_info = r.json()
-            for asset in release_info["assets"]:
-                if platform.system().lower() in asset["name"] and "tar.gz" in asset["name"]:
-                    download_url = asset["browser_download_url"]
-                    break
-            else:
-                click.secho(f"Could not find latest {browser} driver version... Fail", fg="red")
-        elif browser == "edge":
-            download_url = f"https://msedgedriver.azureedge.net/{version}/edgedriver_{platform.system().lower()}.zip"
-        else:
-            click.secho(f"Invalid browser name '{browser}'", fg="red")
-            return
-    else:
-        click.secho(f"Could not find browser '{browser}'.", fg="red")
-        return
-
-    if download_url is not None:
-        response = requests.get(download_url)
-        if download_url.endswith(".zip"):
-            with open(f"selenium-server/{browser}_driver.zip", "wb") as f:
-                f.write(response.content)
-            with zipfile.ZipFile(f"selenium-server/{browser}_driver.zip", 'r') as zip_ref:
-                for member in zip_ref.namelist():
-                    zip_ref.extract(member, f"selenium-server/")
-        elif download_url.endswith(".tar.gz"):
-            with open(f"selenium-server/{browser}_driver.tar.gz", "wb") as f:
-                f.write(response.content)
-            with tarfile.open(f"selenium-server/{browser}_driver.tar.gz", 'r:gz') as tar_ref:
-                tar_ref.extractall(f"selenium-server/")
-    else:
-        click.secho(f"Could not find download URL for {browser} driver.", fg="red")
-
-
-def check_version_and_download_driver(browser):
-    version = get_browser_version(browser)
-    if version is None:
-        click.secho(f"{browser} is not installed on this machine", fg="red")
-    else:
-        click.secho(f"Found: {browser} browser, version {version}.", fg="cyan")
-        # Download the driver for the browser
-        click.echo(f"Downloading driver for {browser} browser ... ", nl=False)
-        download_driver(browser, version)
-        click.secho("OK", fg="green")
-
-
-@click.command(name='install:webdriver', help="Install the webdriver for a chosen browser.")
-@click.option('-b', '--browser', type=click.Choice(['chrome', 'firefox', 'edge']), required=True)
-def install_webdriver(browser):
-    # Create the selenium-server directory if it doesn't exist
-    os.makedirs("selenium-server", exist_ok=True)
-
-    # Check if the browser is installed and get its version
-    check_version_and_download_driver(browser)
-
-
-if __name__ == "__main__":
-    install_webdriver()

vigilant_kit-1.2.9/src/vgl_cli/selenium_commands.py

@@ -1,47 +0,0 @@
-import subprocess
-import click
-import psutil
-
-SELENIUM_SERVER_JAR = "selenium-server/selenium-server-standalone.jar"
-
-
-def find_selenium_server_process():
-    for process in psutil.process_iter(['pid', 'name', 'cmdline']):
-        if process.info['name'] == 'java' and SELENIUM_SERVER_JAR in process.info['cmdline']:
-            return process
-    return None
-
-
-@click.command(name='server:run', help="Run Selenium Server JAR file")
-@click.option('--port', '-p', type=int, default=4444, help="Port number for the server")
-@click.option('--driver', '-D', multiple=True,
-              help="Specify driver options (e.g. -Dwebdriver.chrome.driver=chromedriver)")
-@click.option('--daemon', '-d', is_flag=True, help="Run the server as a daemon")
-def run_selenium_server(port, driver, daemon):
-    driver_options = " ".join(driver)
-    cmd = ["java", "-jar", SELENIUM_SERVER_JAR, "-port", str(port)]
-    cmd.extend(driver_options.split())
-
-    click.echo(f"Running Selenium Server with command:\n {' '.join(cmd)}")
-
-    if daemon:
-        # Start the process in the background (daemon mode) using subprocess.Popen
-        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=False)
-        click.echo(f"Selenium Server is running in daemon mode with PID: {process.pid}")
-    else:
-        # Start the process in the foreground and wait for it to finish using subprocess.run
-        subprocess.run(cmd)
-
-
-@click.command(name='server:stop', help="Stop the running Selenium Server")
-def stop_selenium_server():
-    selenium_server_process = find_selenium_server_process()
-    if selenium_server_process:
-        pid = selenium_server_process.info['pid']
-        try:
-            selenium_server_process.terminate()
-            click.echo(f"Selenium Server with PID {pid} has been stopped.")
-        except psutil.NoSuchProcess:
-            click.echo(f"Failed to stop Selenium Server. Process with PID {pid} does not exist.")
-    else:
-        click.echo("Selenium Server is not running in daemon mode.")

vigilant_kit-1.2.9/src/vgl_cli/vgl.py

@@ -1,26 +0,0 @@
-#!/usr/bin/env python
-
-import click
-from .install_webdriver_command import install_webdriver
-from .install_standalone_command import install_selenium_standalone
-from .install_dev_kit_command import install_dev_kit
-
-from .selenium_commands import run_selenium_server, stop_selenium_server
-
-
-@click.group(name="vgl.py")
-def vgl():
-    pass
-
-
-vgl.add_command(run_selenium_server)
-vgl.add_command(stop_selenium_server)
-
-
-vgl.add_command(install_webdriver)
-vgl.add_command(install_selenium_standalone)
-vgl.add_command(install_dev_kit)
-
-
-if __name__ == '__main__':
-    vgl()

vigilant_kit-1.2.9/src/vigilant/driver/__init__.py

@@ -1,81 +0,0 @@
-import os
-import json
-from dotenv import load_dotenv, find_dotenv
-
-
-def check_env_variables_exist(variables):
-    missing_variables = []
-    for variable in variables:
-        if variable not in os.environ:
-            missing_variables.append(variable)
-
-    if missing_variables:
-        raise ValueError(f"Environment variables are missing: {', '.join(missing_variables)}")
-
-    return True
-
-
-def check_json_file_exist(filename):
-    current_dir = os.getcwd()
-
-    while True:
-        for root, dirs, files in os.walk(current_dir):
-            if filename in files:
-                return True
-
-        parent_dir = os.path.dirname(current_dir)
-        # Check if reached the root directory
-        if current_dir == parent_dir:
-            break
-        current_dir = parent_dir
-
-    return False
-
-
-def find_json_file(filename):
-    current_dir = os.getcwd()
-
-    while True:
-        for root, dirs, files in os.walk(current_dir):
-            if filename in files:
-                return os.path.join(root, filename)
-
-        parent_dir = os.path.dirname(current_dir)
-        # Check if reached the root directory
-        if current_dir == parent_dir:
-            break
-        current_dir = parent_dir
-
-    return None
-
-
-def set_env_variables_from_json(filename):
-    json_file_path = find_json_file(filename)
-    if json_file_path is None:
-        print(f"JSON file '{filename}' not found in the project's root directory or its subdirectories.")
-        return
-
-    with open(json_file_path, 'r') as file:
-        data = json.load(file)
-
-    for key, value in data.items():
-        os.environ[key] = str(value)
-
-
-env_variables = ['BASE_URL', 'SELENIUM_HOST', 'SELENIUM_BROWSER', 'WAIT_TIMEOUT', 'LOGGER_LEVEL']
-json_configuration_file = 'vigilant.json'
-env_configuration_file = '.vigilant.env'
-
-if find_dotenv(env_configuration_file):
-    print("Setting configuration from .vigilant.env file.")
-    load_dotenv(env_configuration_file)
-elif check_json_file_exist(json_configuration_file):
-    print("Setting configuration from .vigilant.json file.")
-    set_env_variables_from_json(json_configuration_file)
-else:
-    print("Could not find nor `.vigilant.env` nor `vigilant.json` configuration files.")
-    print("If you don't want to use `.vigilant.env` nor `vigilant.json` configuration files - make sure, "
-          "that you provide all configuration data as environment variables through  the way that is acceptable for "
-          "you (pipeline configuration, custom bash script, etc.).")
-    if check_env_variables_exist(env_variables):
-        print("All mandatory environment variables exist.")

vigilant_kit-1.2.9/src/vigilant/driver/vigilant_driver.py

@@ -1,87 +0,0 @@
-import os
-
-from selenium import webdriver
-
-from vigilant.actions.vigilant_actions import VigilantActions
-from vigilant.logger import logger as log
-
-
-class VigilantDriver(VigilantActions):
-    """
-    VigilantDriver class provide methods for running WebDriver instance from scratch using configuration
-    from .vigilant.env file
-
-    .vigilant.env configuration items:
-    ----------------------------------
-    SELENIUM_HOST - is used as command_executor, it is Selenium Server URI;
-
-    SELENIUM_BROWSER - used as entity that show which browser options to use FirefoxOptions(),
-        ChromeOptions, etc. (DesiredCapabilities is now deprecated, we should use Options() class).
-
-    BASE_URL - the root URL of the application under test
-
-    WAIT_TIMEOUT - configuration for the default amount of time (in seconds) that a
-        test will wait while trying to interact with web element.
-
-    LOGGER_LEVEL - level of verbosity that will be printed in to the console;
-    """
-
-    def __init__(self, browser_options=None):
-        """
-        `driver` - if you want access native Selenium WebDriver methods;
-        VigilantActions - allow you to use custom methods for interaction with browser directly from VigilantDriver
-        class instance;
-
-        Examples:
-            How to use VigilantActions methods;
-
-                act = VigilantDriver()
-                act.get_page('/')
-                act.assertions.see_text('Some Text')
-
-            How to access native Selenium WebDriver methods;
-
-                act = VigilantDriver()
-                act.driver.get('https://python.org') // Here we use Selenium WebDriver get() method
-        """
-        self.driver = self.create_remote_driver_session(browser_options)
-        VigilantActions.__init__(self, self.driver)
-
-    SELENIUM_HOST = os.environ.get("SELENIUM_HOST")
-    SELENIUM_BROWSER = os.environ.get("SELENIUM_BROWSER")
-
-    def default_browser_options(self):
-        """
-        Set browser options according to browser name provided in .vigilant.env file.
-        It can be overwritten when user create new Selenium session by providing options as argument.
-
-        Returns:
-            Options: return default browser options according to value from SELENIUM_BROWSER variable.
-        """
-        options = None
-        if self.SELENIUM_BROWSER.lower() == "firefox":
-            options = webdriver.FirefoxOptions()
-        elif self.SELENIUM_BROWSER.lower() == "chrome":
-            options = webdriver.ChromeOptions()
-        log.info(f"Setting default browser options: {self.SELENIUM_BROWSER}")
-        return options
-
-    def create_remote_driver_session(self, browser_options=None):
-        """
-        Create a new WebDriver instance that will issue commands using the wire protocol.
-
-         Args:
-            browser_options: browser options instance is required as it determines which browser will be used
-
-        Returns:
-            Remote: remote driver session based on configuration from .vigilant.env file
-        """
-        log.info("Creating remote session.\n"
-                 f"Command executor: {self.SELENIUM_HOST}\n"
-                 f"Browser: {self.SELENIUM_BROWSER}")
-
-        if browser_options is None:
-            browser_options = self.default_browser_options()
-
-        return webdriver.Remote(command_executor=self.SELENIUM_HOST,
-                                options=browser_options)

vigilant_kit-1.2.9/vigilant.json.example

@@ -1,7 +0,0 @@
-{
-  "BASE_URL": "http://www.python.org",
-  "SELENIUM_HOST": "http://127.0.0.1:4444/wd/hub",
-  "SELENIUM_BROWSER": "firefox",
-  "WAIT_TIMEOUT": 10,
-  "LOGGER_LEVEL": "INFO"
-}