vigilant-kit 1.2.9__py3-none-any.whl → 1.4.0__py3-none-any.whl

vigilant/driver/__init__.py

@@ -1,81 +1,24 @@
 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)
+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)
+
 
-env_variables = ['BASE_URL', 'SELENIUM_HOST', 'SELENIUM_BROWSER', 'WAIT_TIMEOUT', 'LOGGER_LEVEL']
-json_configuration_file = 'vigilant.json'
-env_configuration_file = '.vigilant.env'
+CONFIG_YAML_FILE = 'vgl_config.yaml'
 
-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)
+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("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.")
+    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/driver/vigilant_driver.py

@@ -7,57 +7,19 @@ 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.
+    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)
 
-        Returns:
-            Options: return default browser options according to value from SELENIUM_BROWSER variable.
-        """
+    def default_browser_options(self):
         options = None
         if self.SELENIUM_BROWSER.lower() == "firefox":
             options = webdriver.FirefoxOptions()
@@ -66,22 +28,18 @@ class VigilantDriver(VigilantActions):
         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
-        """
+    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}")
-
-        if browser_options is None:
-            browser_options = self.default_browser_options()
-
         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.2.9.dist-info → vigilant_kit-1.4.0.dist-info}/METADATA

@@ -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.4.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+vigilant/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vigilant/logger.py,sha256=euYrqEDMEWNo9Eak31_4eTQEVzLZBwR8YiArhOtI9uQ,191
+vigilant/actions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vigilant/actions/assertions.py,sha256=OF81tGjl7qrjKuV7613owsmNHTXqa_pbpZVF7jZp6ms,6201
+vigilant/actions/finder.py,sha256=Ibo1ltv2wzQ2Ol2pc_Lt2etKC08fjH3YSq1xhH0W8vg,2585
+vigilant/actions/vigilant_actions.py,sha256=3XdXLIKN82aovLEWc6ed_LBy0CJgAzl6UDO3QzDkneU,13552
+vigilant/actions/waiter.py,sha256=7S4BtffDR9jyue8lCw0_QsBfEERdXAVjkE-uepXffic,5064
+vigilant/driver/__init__.py,sha256=NfSrz8wAYadeee2hzGty10eN6pa3CZxOD-6AZ6WqBlI,795
+vigilant/driver/vigilant_driver.py,sha256=3iAdgcqut_q-IpBWIEuck8LhGbeMwCb8FSpmARZrXLA,1827
+vigilant_kit-1.4.0.dist-info/METADATA,sha256=p3nlT8ShmkZKU3DIgIowTCHx_r_-IfqMbnbm29ECdZw,3118
+vigilant_kit-1.4.0.dist-info/WHEEL,sha256=mRYSEL3Ih6g5a_CVMIcwiF__0Ae4_gLYh01YFNwiq1k,87
+vigilant_kit-1.4.0.dist-info/licenses/LICENSE,sha256=VQoL58PKrdEeZx2K4hXS7O6w4O_DMBB0XFE-GjK1CMo,35125
+vigilant_kit-1.4.0.dist-info/RECORD,,

{vigilant_kit-1.2.9.dist-info → vigilant_kit-1.4.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.18.0
+Generator: hatchling 1.21.0
 Root-Is-Purelib: true
 Tag: py3-none-any

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()

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()

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()

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.")

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.dist-info/RECORD

@@ -1,19 +0,0 @@
-vgl_cli/install_dev_kit_command.py,sha256=wVcUa0lHpu18zYMm0jO_ahuFEhmNwo9iVIKiMjH7j1Y,547
-vgl_cli/install_standalone_command.py,sha256=3E3WX2nqdGHz343dJGkBbboDl-JFzZsa56lna7kLwsU,1447
-vgl_cli/install_webdriver_command.py,sha256=xOljxceAVN1ZRkbyQNq55FbHXdKad2B4mNRBiS0fLHY,5032
-vgl_cli/selenium_commands.py,sha256=z-FfRAn95q5JeJmATBp8yknMGP_WVoBt7gzSBmoKMLY,2029
-vgl_cli/vgl.py,sha256=Ve-Z4d7zqzyGo88e7EpWEDYmRiOdxHsConmBMJ4F9YA,569
-vigilant/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vigilant/logger.py,sha256=euYrqEDMEWNo9Eak31_4eTQEVzLZBwR8YiArhOtI9uQ,191
-vigilant/actions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vigilant/actions/assertions.py,sha256=OF81tGjl7qrjKuV7613owsmNHTXqa_pbpZVF7jZp6ms,6201
-vigilant/actions/finder.py,sha256=Ibo1ltv2wzQ2Ol2pc_Lt2etKC08fjH3YSq1xhH0W8vg,2585
-vigilant/actions/vigilant_actions.py,sha256=3XdXLIKN82aovLEWc6ed_LBy0CJgAzl6UDO3QzDkneU,13552
-vigilant/actions/waiter.py,sha256=7S4BtffDR9jyue8lCw0_QsBfEERdXAVjkE-uepXffic,5064
-vigilant/driver/__init__.py,sha256=2NxWZ6OLLvGcrKRXvLtWPM1iGRE9zfIZtv_YUhNHj-I,2609
-vigilant/driver/vigilant_driver.py,sha256=rw5CfWfBWOIFPgnkmxTi7cSbrrxLtDtRlxg2FMfyEVw,3398
-vigilant_kit-1.2.9.dist-info/METADATA,sha256=70-QVoFw50-xBKoV4UoSln3b0Ku-0E7EWfY3p7lIfF4,3196
-vigilant_kit-1.2.9.dist-info/WHEEL,sha256=9QBuHhg6FNW7lppboF2vKVbCGTVzsFykgRQjjlajrhA,87
-vigilant_kit-1.2.9.dist-info/entry_points.txt,sha256=c_azSnuBSdtgwdPlioaG0n2gZOEhuPIzL9VQ8DeKTow,40
-vigilant_kit-1.2.9.dist-info/licenses/LICENSE,sha256=VQoL58PKrdEeZx2K4hXS7O6w4O_DMBB0XFE-GjK1CMo,35125
-vigilant_kit-1.2.9.dist-info/RECORD,,

vigilant_kit-1.2.9.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-vgl = vgl_cli.vgl:vgl