Commit `c8617ce8ae`

c8617ce8aecb40ccf1d13c02dcd7d7e74e79b56b

parent: 1fc982100a

Unregistered key

cmc <hello@cleberg.net> · 2025-04-05 18:36 UTC
committer: <noreply@github.com>

migrate from pylint to ruff-action (#4)

* migrate from pylint to ruff-action

* temporarily disable push param

* Commit from GitHub Actions (Pylint)

* re-enable push param

---------

Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>

Layout: unified · split

.github/workflows/pylint.yml +20 −6

 name: Pylint
-on: [push]
+on:
+  push:
+    paths:
+      - '**.py'
 jobs:
   build:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.8", "3.9", "3.10"]
+        python-version: ["3.x"]
     steps:
     - uses: actions/checkout@v4
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python-version }}
+        ref: ${{ github.event.pull_request.head.ref }}
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install pylint cryptography prettytable
+        pip install cryptography prettytable
-    - name: Analysing the code with pylint
+    - name: Install Ruff
+      uses: astral-sh/ruff-action@v3.2.2
+    - name: Ruff Actions
       run: |
-        pylint -d R0801 $(git ls-files '*.py')
+        ruff check --fix
+        ruff format
+    - name: Add and Commit
+      uses: EndBug/add-and-commit@v9
+      env:
+        GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        default_author: github_actions
+        pathspec_error_handling: ignore\ No newline at end of file

yoshi/__main__.py +1

	@@ -4,4 +4,5 @@ Entry point for the yoshi cli app.
4		4
5	if __name__ == "__main__":	5	if __name__ == "__main__":
6	from yoshi.cli import yoshi	6	from yoshi.cli import yoshi
		7
7	yoshi()	8	yoshi()

yoshi/account.py +15 −9

 class Account:
     """Represents a login account."""
-    def __init__(self, uuid: str, application: str, #pylint: disable=R0913,R0917
+    def __init__(
-                 username: str, #pylint: disable=R0913,R0917
+        self,
-                 password: str, url: str) -> None: #pylint: disable=R0913,R0917
+        uuid: str,
+        application: str,  # pylint: disable=R0913,R0917
+        username: str,  # pylint: disable=R0913,R0917
+        password: str,
+        url: str,
+    ) -> None:  # pylint: disable=R0913,R0917
         self.uuid = uuid
         self.application = application
         self.username = username
     def display_account(self) -> None:
         """Print the account details."""
-        print('ID:', self.uuid)
+        print("ID:", self.uuid)
-        print('Application:', self.application)
+        print("Application:", self.application)
-        print('Username:', self.username)
+        print("Username:", self.username)
-        print('Password:', self.password)
+        print("Password:", self.password)
-        print('URL:', self.url)
+        print("URL:", self.url)
     def save_account(self) -> None:
         """Save the account details to the database."""
         database.add_account(
-            self.uuid, self.application, self.username, self.password, self.url)
+            self.uuid, self.application, self.username, self.password, self.url
+        )
     def delete_account(self) -> bool:
         """Delete the account from the database.

yoshi/cli.py +38 −52

 import argparse
 from yoshi import crypto, database, process
 def yoshi():
     """
     CLI entry point logic, used to parse user inputs.
     """
     parser = argparse.ArgumentParser(
-        description='Manage your username and passwords via a convenient CLI vault.'
+        description="Manage your username and passwords via a convenient CLI vault."
     )
     # Top-level arguments
     group_one = parser.add_mutually_exclusive_group()
     group_one.add_argument(
-        '-n', '--new',
+        "-n", "--new", help="Create a new account.", action="store_true"
-        help='Create a new account.',
-        action='store_true'
     )
     group_one.add_argument(
-        '-l', '--list',
+        "-l", "--list", help="List all saved accounts.", action="store_true"
-        help='List all saved accounts.',
-        action='store_true'
     )
     group_one.add_argument(
-        '-e', '--edit',
+        "-e", "--edit", help="Edit a saved account.", action="store_true"
-        help='Edit a saved account.',
-        action='store_true'
     )
     group_one.add_argument(
-        '-d', '--delete',
+        "-d", "--delete", help="Delete a saved account.", action="store_true"
-        help='Delete a saved account.',
-        action='store_true'
     )
     group_one.add_argument(
-        '--purge',
+        "--purge",
         help=(
-            'Purge all accounts and delete the vault. '
+            "Purge all accounts and delete the vault. "
-            '(Caution: this will irreversibly destroy your data.)'
+            "(Caution: this will irreversibly destroy your data.)"
         ),
-        action='store_true'
+        action="store_true",
-    )
-    group_one.add_argument(
-        '--encrypt',
-        help='Encrypt the vault.',
-        action='store_true'
-    )
-    group_one.add_argument(
-        '--decrypt',
-        help='Decrypt the vault.',
-        action='store_true'
     )
+    group_one.add_argument("--encrypt", help="Encrypt the vault.", action="store_true")
+    group_one.add_argument("--decrypt", help="Decrypt the vault.", action="store_true")
     # Encryption flags
     group_two = parser.add_mutually_exclusive_group()
     group_two.add_argument(
-        '-g', '--generate',
+        "-g",
-        help=(
+        "--generate",
-            'When using the --encrypt option, generate a new encryption key.'
+        help=("When using the --encrypt option, generate a new encryption key."),
-        ),
+        action="store_true",
-        action='store_true'
     )
     group_two.add_argument(
-        '-k', '--keyfile',
+        "-k",
-        help='Path to existing key file.',
+        "--keyfile",
-        action='store',
+        help="Path to existing key file.",
+        action="store",
         nargs=1,
-        type=str
+        type=str,
     )
     # Edit flags
     group_three = parser.add_argument_group()
     group_three.add_argument(
-        '-u', '--uuid',
+        "-u",
-        help=(
+        "--uuid",
-            'When using the --edit or --delete options, provide the account UUID.'
+        help=("When using the --edit or --delete options, provide the account UUID."),
-        ),
+        action="store",
-        action='store',
         nargs=1,
-        type=str
+        type=str,
     )
     group_three.add_argument(
-        '-f', '--field',
+        "-f",
+        "--field",
         help=(
-            'When using the --edit option, specify the field to edit (integer index).'
+            "When using the --edit option, specify the field to edit (integer index)."
         ),
-        action='store',
+        action="store",
         nargs=1,
-        type=int
+        type=int,
     )
     args = parser.parse_args()
         if args.keyfile:
             key = crypto.load_key(args.keyfile[0])
         else:
-            key = input('Please enter your decryption key: ')
+            key = input("Please enter your decryption key: ")
         crypto.decrypt(key)
     elif args.encrypt:
         if args.generate:
             key = crypto.generate_key()
             print(
-                'WRITE THIS KEY DOWN SOMEWHERE SAFE. YOU WILL NOT BE ABLE TO DECRYPT '
+                "WRITE THIS KEY DOWN SOMEWHERE SAFE. YOU WILL NOT BE ABLE TO DECRYPT "
-                'YOUR DATA WITHOUT IT!'
+                "YOUR DATA WITHOUT IT!"
             )
             print(key.decode())
-            print('\n')
+            print("\n")
         else:
             if args.keyfile:
                 key = crypto.load_key(args.keyfile[0])
             else:
-                key = input('Please enter your encryption key: ')
+                key = input("Please enter your encryption key: ")
         crypto.encrypt(key)
     elif database.check_table():
         if args.new:
             process.purge_accounts()
         else:
             raise TypeError(
-                'Please specify a command or use the --help flag for more information.'
+                "Please specify a command or use the --help flag for more information."
             )
 if __name__ == "__main__":
     yoshi()

yoshi/crypto.py +6 −6

	@@ -6,7 +6,7 @@ It allows for secure encryption and decryption of data using a secret key.
6		6
7	from cryptography.fernet import Fernet	7	from cryptography.fernet import Fernet
8		8
9	VAULT_FILE = 'vault.sqlite'	9	VAULT_FILE = "vault.sqlite"
10		10
11		11
12	def generate_key() -> bytes:	12	def generate_key() -> bytes:
	@@ -21,25 +21,25 @@ def load_key(key_file: str) -> bytes:
21	Args:	21	Args:
22	key_file (str): Path to the key file.	22	key_file (str): Path to the key file.
23	"""	23	"""
24	with open(key_file, 'rb') as key:	24	with open(key_file, "rb") as key:
25	return key.read()	25	return key.read()
26		26
27		27
28	def encrypt(key: bytes, filename: str = VAULT_FILE) -> None:	28	def encrypt(key: bytes, filename: str = VAULT_FILE) -> None:
29	"""Encrypts the data in the specified file using the provided key."""	29	"""Encrypts the data in the specified file using the provided key."""
30	f = Fernet(key)	30	f = Fernet(key)
31	with open(filename, 'rb') as vault:	31	with open(filename, "rb") as vault:
32	data = vault.read()	32	data = vault.read()
33	encrypted_data = f.encrypt(data)	33	encrypted_data = f.encrypt(data)
34	with open(filename, 'wb') as vault:	34	with open(filename, "wb") as vault:
35	vault.write(encrypted_data)	35	vault.write(encrypted_data)
36		36
37		37
38	def decrypt(key: bytes, filename: str = VAULT_FILE) -> None:	38	def decrypt(key: bytes, filename: str = VAULT_FILE) -> None:
39	"""Decrypts the data in the specified file using the provided key."""	39	"""Decrypts the data in the specified file using the provided key."""
40	f = Fernet(key)	40	f = Fernet(key)
41	with open(filename, 'rb') as vault:	41	with open(filename, "rb") as vault:
42	encrypted_data = vault.read()	42	encrypted_data = vault.read()
43	decrypted_data = f.decrypt(encrypted_data)	43	decrypted_data = f.decrypt(encrypted_data)
44	with open(filename, 'wb') as vault:	44	with open(filename, "wb") as vault:
45	vault.write(decrypted_data)	45	vault.write(decrypted_data)

yoshi/database.py +31 −29

 import sys
 import os
-VAULT_DECRYPTED = 'vault.sqlite'
+VAULT_DECRYPTED = "vault.sqlite"
-VAULT_ENCRYPTED = 'vault.sqlite.aes'
+VAULT_ENCRYPTED = "vault.sqlite.aes"
 def create_table() -> None:
     db_connection = sqlite3.connect(VAULT_DECRYPTED)
     cursor = db_connection.cursor()
     cursor.execute(
-        ''' CREATE TABLE IF NOT EXISTS accounts (uuid text, application text,
+        """ CREATE TABLE IF NOT EXISTS accounts (uuid text, application text,
-            username text, password text, url text) '''
+            username text, password text, url text) """
     )
     db_connection.commit()
     db_connection.close()
     db_connection = sqlite3.connect(VAULT_DECRYPTED)
     cursor = db_connection.cursor()
     cursor.execute(
-        ''' SELECT count(name) FROM sqlite_master WHERE type='table'
+        """ SELECT count(name) FROM sqlite_master WHERE type='table'
-            AND name='accounts' '''
+            AND name='accounts' """
     )
     if cursor.fetchone()[0] != 1:
         user_choice = input(
-            'Password vault does not exist. Would you like to create it now? (y/n): ')
+            "Password vault does not exist. Would you like to create it now? (y/n): "
-        if user_choice.lower() == 'y':
+        )
+        if user_choice.lower() == "y":
             create_table()
             check = True
         else:
-            sys.exit('Program aborted upon user request.')
+            sys.exit("Program aborted upon user request.")
     else:
         check = True
     db_connection.commit()
     return check
-def add_account(uuid: str, application: str, username: str, password: str,
+def add_account(
-                   url: str) -> None:
+    uuid: str, application: str, username: str, password: str, url: str
+) -> None:
     """Add a new account within the vault database."""
     db_connection = sqlite3.connect(VAULT_DECRYPTED)
     cursor = db_connection.cursor()
     cursor.execute(
-        ''' INSERT INTO accounts VALUES (:uuid,:application,:username,
+        """ INSERT INTO accounts VALUES (:uuid,:application,:username,
-            :password,:url) ''', {
+            :password,:url) """,
-            'uuid': uuid, 'application': application, 'username': username,
+        {
-            'password': password, 'url': url
+            "uuid": uuid,
-        }
+            "application": application,
+            "username": username,
+            "password": password,
+            "url": url,
+        },
     )
     db_connection.commit()
     db_connection.close()
     """Delete an account within the vault database by its unique ID."""
     db_connection = sqlite3.connect(VAULT_DECRYPTED)
     cursor = db_connection.cursor()
-    cursor.execute(
+    cursor.execute(""" DELETE FROM accounts WHERE uuid = :uuid """, {"uuid": uuid})
-        ''' DELETE FROM accounts WHERE uuid = :uuid ''', {'uuid': uuid}
-    )
     db_connection.commit()
     db_connection.close()
     """Find an account within the vault database by its unique ID."""
     db_connection = sqlite3.connect(VAULT_DECRYPTED)
     cursor = db_connection.cursor()
-    cursor.execute(
+    cursor.execute(""" SELECT * FROM accounts WHERE uuid = :uuid """, {"uuid": uuid})
-        ''' SELECT * FROM accounts WHERE uuid = :uuid ''', {'uuid': uuid}
-    )
     account = cursor.fetchall()
     db_connection.close()
     return account
     """Return all accounts stored within the vault database."""
     db_connection = sqlite3.connect(VAULT_DECRYPTED)
     cursor = db_connection.cursor()
-    cursor.execute(''' SELECT * FROM accounts ''')
+    cursor.execute(""" SELECT * FROM accounts """)
     accounts = cursor.fetchall()
     db_connection.close()
     return accounts
 def update_account(field_name: str, new_value: str, uuid: str) -> None:
     """Update an account within the vault database by its unique ID."""
     queries = {
-        'application': 'UPDATE accounts SET application = :new_value WHERE uuid = :uuid',
+        "application": "UPDATE accounts SET application = :new_value WHERE uuid = :uuid",
-        'username': 'UPDATE accounts SET username = :new_value WHERE uuid = :uuid',
+        "username": "UPDATE accounts SET username = :new_value WHERE uuid = :uuid",
-        'password': 'UPDATE accounts SET password = :new_value WHERE uuid = :uuid',
+        "password": "UPDATE accounts SET password = :new_value WHERE uuid = :uuid",
-        'url': 'UPDATE accounts SET url = :new_value WHERE uuid = :uuid'
+        "url": "UPDATE accounts SET url = :new_value WHERE uuid = :uuid",
     }
     db_connection = sqlite3.connect(VAULT_DECRYPTED)
     cursor = db_connection.cursor()
-    cursor.execute(queries[field_name], {'new_value': new_value, 'uuid': uuid})
+    cursor.execute(queries[field_name], {"new_value": new_value, "uuid": uuid})
     db_connection.commit()
     db_connection.close()
     """Purge the 'accounts' table within the vault database."""
     db_connection = sqlite3.connect(VAULT_DECRYPTED)
     cursor = db_connection.cursor()
-    cursor.execute(''' DROP TABLE accounts ''')
+    cursor.execute(""" DROP TABLE accounts """)
     db_connection.commit()
     db_connection.close()

yoshi/process.py +58 −47

 from yoshi import database
 from yoshi.wordlist import WORDLIST
 def generate_characters(n: int) -> list:
     """
     Generates a list of n random characters from the set of ASCII letters,
         str: A string representation of the shuffled characters
     """
     random.shuffle(characters)
-    character_string = ''.join(characters)
+    character_string = "".join(characters)
     return character_string
         None
     """
     accounts = database.find_accounts()
-    t = PrettyTable(['UUID', 'Application', 'Username', 'Password', 'URL'])
+    t = PrettyTable(["UUID", "Application", "Username", "Password", "URL"])
     for account in accounts:
         t.add_row([account[0], account[1], account[2], account[3], account[4]])
     print(t)
         None
     """
     account_record = database.find_account(account_uuid)
-    account = Account(account_record[0][0],
+    account = Account(
-                               account_record[0][1],
+        account_record[0][0],
-                               account_record[0][2],
+        account_record[0][1],
-                               account_record[0][3],
+        account_record[0][2],
-                               account_record[0][4])
+        account_record[0][3],
+        account_record[0][4],
+    )
     if account.delete_account():
-        print('Account successfully deleted.')
+        print("Account successfully deleted.")
 def purge_accounts() -> None:
         None
     """
     check = input(
-        '''Are you absolutely sure you want to delete your password vault?
+        """Are you absolutely sure you want to delete your password vault?
-        This action is irreversible. (y/n): ''')
+        This action is irreversible. (y/n): """
-    if check.lower() == 'y':
+    )
+    if check.lower() == "y":
         database.purge_table()
         database.purge_database()
-        print('The password vault has been purged. You may now exit or create a new one.')
+        print(
+            "The password vault has been purged. You may now exit or create a new one."
+        )
 def create_account() -> None:
     Returns:
         None
     """
-    application_string = input('Please enter a name for this account: ')
+    application_string = input("Please enter a name for this account: ")
-    username_string = input('Please enter your username for this account: ')
+    username_string = input("Please enter your username for this account: ")
-    url_string = input('(Optional) Please enter a URL for this account: ')
+    url_string = input("(Optional) Please enter a URL for this account: ")
     password_type = input(
-        '''Do you want a random character password (p), an XKCD-style passphrase
+        """Do you want a random character password (p), an XKCD-style passphrase
-(x), or a custom password (c)? (p|x|c): '''
+(x), or a custom password (c)? (p|x|c): """
     )
-    if password_type not in ['p', 'x', 'c']:
+    if password_type not in ["p", "x", "c"]:
-        print('Error: Invalid choice. Please choose p, x, or c.')
+        print("Error: Invalid choice. Please choose p, x, or c.")
         return
-    if password_type == 'x':
+    if password_type == "x":
         password_length = int(
-            input('Please enter number of words to include (min. 2): ')
+            input("Please enter number of words to include (min. 2): ")
         )
         if password_length < 3:
-            print('Error: Your passphrase length must be at least 3 words.')
+            print("Error: Your passphrase length must be at least 3 words.")
             return
         password_separator = input(
-            'Please enter your desired separator symbol (_,-, ~, etc.): '
+            "Please enter your desired separator symbol (_,-, ~, etc.): "
         )
         password_string = generate_passphrase(password_length, password_separator)
-    elif password_type == 'p':
+    elif password_type == "p":
         password_length = int(
-            input('Please enter your desired password length (min. 8): ')
+            input("Please enter your desired password length (min. 8): ")
         )
         if password_length < 8:
-            print('Error: Your password length must be at least 8 characters.')
+            print("Error: Your password length must be at least 8 characters.")
             return
         password_characters = generate_characters(password_length)
         password_string = shuffle_characters(password_characters)
     else:
-        password_string = input('Please enter your desired password: ')
+        password_string = input("Please enter your desired password: ")
-    account = Account(str(uuid.uuid4()), application_string,
+    account = Account(
-                      username_string, password_string, url_string)
+        str(uuid.uuid4()),
+        application_string,
+        username_string,
+        password_string,
+        url_string,
+    )
     account.save_account()
-    print('Account saved to the vault. Use `--list` to see all saved accounts.')
+    print("Account saved to the vault. Use `--list` to see all saved accounts.")
 def edit_account(account_uuid: str, edit_parameter: int) -> None:
             Valid values are 1 for application name, 2 for username,
             3 for password, and 4 for URL.
     """
-    field_name, new_value = ''
+    field_name, new_value = ""
     if edit_parameter == 1:
-        field_name = 'application'
+        field_name = "application"
-        new_value = input('Please enter your desired Application name: ')
+        new_value = input("Please enter your desired Application name: ")
     elif edit_parameter == 2:
-        field_name = 'username'
+        field_name = "username"
-        new_value = input('Please enter your desired username: ')
+        new_value = input("Please enter your desired username: ")
     elif edit_parameter == 3:
-        field_name = 'password'
+        field_name = "password"
         type_check = input(
-            'Do you want a new random password or to enter a custom password? '
+            "Do you want a new random password or to enter a custom password? "
-            '(random/custom): ').lower()
+            "(random/custom): "
-        if type_check == 'random':
+        ).lower()
-            password_length = int(input('Please enter your desired password length: '))
+        if type_check == "random":
+            password_length = int(input("Please enter your desired password length: "))
             if password_length < 8:
-                print('Error: Your password length must be at least 8 characters.')
+                print("Error: Your password length must be at least 8 characters.")
             else:
                 password_characters = generate_characters(password_length)
                 new_value = shuffle_characters(password_characters)
         else:
-            new_value = input('Please enter your desired password: ')
+            new_value = input("Please enter your desired password: ")
     elif edit_parameter == 4:
-        field_name = 'url'
+        field_name = "url"
-        new_value = input('Please enter your desired URL: ')
+        new_value = input("Please enter your desired URL: ")
     database.update_account(field_name, new_value, account_uuid)
-    print('Account successfully updated.')
+    print("Account successfully updated.")

Commit c8617ce8ae

Commit `c8617ce8ae`