def _get_keyring_backend(self) -> KeyringBackend:
"""
Returns the keyring backend currently used. If none is used because we are not
yet linked, use the backend specified in the config file (if valid) or choose
the most secure of the available and supported keyring backends.
"""
import keyring.backends
keyring_class: str = self._conf.get("app", "keyring").strip()
if self._account_id and keyring_class != "automatic":
# We are already linked and have a keyring set. Insist on using
# the recorded backend.
try:
ring = load_keyring(keyring_class)
except Exception as exc:
# Bomb out with an exception.
title = f"Cannot load keyring {keyring_class}"
message = "Please relink Maestral to get a new access token."
new_exc = KeyringAccessError(title, message).with_traceback(
exc.__traceback__)
self._logger.error(title, exc_info=exc_info_tuple(new_exc))
raise new_exc
return ring
else:
# We are not yet linked. Try loading the preset or the preferred keyring
# backend for the platform.
try:
ring = load_keyring(keyring_class)
except Exception:
# get preferred keyring backends for platform
available_rings = keyring.backend.get_all_keyring()
supported_rings = [
k for k in available_rings
if isinstance(k, supported_keyring_backends)
]
ring = max(supported_rings, key=lambda x: x.priority)
self._conf.set(
"app",
"keyring",
f"{ring.__class__.__module__}.{ring.__class__.__name__}",
)
return ring
def main():
parser = \
argparse.ArgumentParser(description='Store a secret in local keychain')
parser.add_argument('--backend',
type=str,
nargs='?',
help='Keyring backend to use')
parser.add_argument('service',
type=str,
help='service to log into (e.g., URL)')
parser.add_argument('username', type=str, help='Username to use')
args = parser.parse_args()
service: str = args.service
username: str = args.username
backend: str = args.backend
if sys.stdin.isatty():
password: str = input('Password: ')
else:
password = input()
if backend is not None:
keyring.set_keyring(core.load_keyring(backend))
keyring.set_password(service, username, password)
def main():
parser: ArgumentParser =\
ArgumentParser(description='Retrieve a secret in local keychain')
parser.add_argument('--backend',
type=str,
nargs='?',
help='Keyring backend to use')
parser.add_argument('service',
type=str,
help='service to log into (e.g., URL)')
parser.add_argument('username', type=str, help='Username to use')
args: Namespace = parser.parse_args()
service: str = args.service
username: str = args.username
backend: str = args.backend
if backend is not None:
keyring.set_keyring(core.load_keyring(backend))
password: str = keyring.get_password(service, username)
if password is None:
exit(1)
else:
print(password)
def get_keyring_backend(config_name):
"""
Choose the most secure of the available and supported keyring backends or
use the backend specified in the config file (if valid).
:param str config_name: The config name.
"""
import keyring.backends
conf = MaestralConfig(config_name)
keyring_name = conf.get('app', 'keyring').strip()
if IS_MACOS_BUNDLE:
ring = keyring.backends.OS_X.Keyring()
else:
try:
ring = load_keyring(keyring_name)
except Exception:
# get preferred keyring backends for platform
available_rings = keyring.backend.get_all_keyring()
supported_rings = [
k for k in available_rings
if isinstance(k, _supported_keyring_backends)
]
ring = max(supported_rings, key=lambda x: x.priority)
return ring
def _keyring_from_config(self) -> KeyringBackend | None:
"""Initialise keyring specified in config."""
keyring_class: str = self._conf.get("auth", "keyring").strip()
if keyring_class == "automatic":
return None
try:
return load_keyring(keyring_class)
except Exception as exc:
# Bomb out with an exception.
title = f"Cannot load keyring {keyring_class}"
message = "Please relink Maestral to get a new access token."
new_exc = KeyringAccessError(title, message).with_traceback(
exc.__traceback__)
raise new_exc
def main() -> None:
desc = 'Remove a secret in local keychain'
parser = argparse.ArgumentParser(description=desc)
parser.add_argument('--backend', type=str, nargs='?',
help='Keyring backend to use')
parser.add_argument('service', type=str,
help='service to log into (e.g., URL)')
parser.add_argument('username', type=str,
help='Username to use')
args: argparse.Namespace = parser.parse_args()
service: str = args.service
username: str = args.username
backend: str = args.backend
if backend is not None:
keyring.set_keyring(core.load_keyring(backend))
keyring.delete_password(service, username)
from flask_assets import Environment
assets = Environment(app)
os.environ['PATH'] = \
'{}/.bin:{}'.format(app.config['GMP_NODE_MODULES_DIR'],
os.environ['PATH'])
else:
assets = None
if app.config['GMP_OFFLINE_MODE']:
music = None
else:
from gmusicapi import Mobileclient
from keyring.core import get_password, load_keyring, set_keyring
keyring_backend = app.config.get('KEYRING_BACKEND')
if keyring_backend:
set_keyring(load_keyring(keyring_backend))
music = Mobileclient()
email = app.config['GACCOUNT_EMAIL']
password = get_password('gmusicprocurator', email)
if password is None:
music = None
else:
music.login(email, password, app.config.get('GACCOUNT_DEVICE_ID'))
if app.debug and app.config['GMP_MEMORY_PROFILER']:
from guppy import hpy
heapy = hpy()
else:
heapy = None
__all__ = ('app', 'assets', 'heapy', 'music')
