def _get_config_file():
# paths to config file, in the ordere they're checked
paths = [
os.environ.get(ENV_CONFIG),
os.path.join(xdg_config_home(), "arkiv/arkiv.conf"),
os.path.expanduser("~/.arkiv/arkiv.conf"),
os.path.expanduser("~/.arkiv"),
]
for p in paths:
if p and os.path.isfile(p):
return p # use the first valid config file
return os.path.join(xdg_config_home(), "arkiv/arkiv.conf")
def __init__(self):
config_dir = xdg_config_home().joinpath('fledgling')
config_file = config_dir.joinpath('config.ini')
print('config_file', config_file)
self.config = configparser.ConfigParser()
self.config_dir = config_dir
self.config_file = config_file
def _get_config_dir() -> Path:
if os.name == 'nt':
path = Path(os.path.expandvars('%AppData%/jcotton42/ficdl'))
else:
path = xdg_config_home().joinpath('jcotton42/ficdl')
path.mkdir(mode=0o770, parents=True, exist_ok=True)
return path
def _get_config_file():
# paths to config file, in the ordere they're checked
paths = [
os.environ.get(ENV_CONFIG),
os.path.join(xdg_config_home(), "jackup/jackup.conf"),
os.path.expanduser("~/.jackup/jackup.conf"),
os.path.expanduser("~/.jackup"),
]
for p in paths:
if p and os.path.isfile(p):
log.debug(f"{p}")
return p # use the first valid config file
# if no config file is found, default to XDG
return os.path.join(xdg_config_home(), "jackup/jackup.conf")
def __init__(self):
config_home = xdg_config_home() / "py3status-reddit"
config_home.mkdir(parents=True, exist_ok=True)
config_home.chmod(0o0700)
filename = config_home / "refresh_token"
filename.touch(0o0600, exist_ok=True)
filename.chmod(0o0600)
super().__init__(filename)
class AppConfig(GoodConf):
"Configuration for My App"
# GitHub
pat: str
hooksecret: str
# Runner
config_home: pathlib.Path = xdg.xdg_config_home() / appname
cache_home: pathlib.Path = xdg.xdg_cache_home() / appname
dirs: typing.Any = None
@validator('dirs', pre=True, always=True)
def default_dirs(cls, v, *, values, **kwargs):
return makepaths(values['config_home'], values['cache_home'])
prefix: str
remotes: typing.Dict[str, Remote]
runnermap: typing.List[RunnerConf]
web_host: IPvAnyAddress = ipaddress.IPv4Address('0.0.0.0')
web_port: int = 5000
web_tls: bool = True
cleanup: bool = True
# For testing
activecfg: typing.FrozenSet[str] = frozenset()
max_workers: int
def_repo_args: dict = {}
def_org_args: dict = {}
class Config:
default_files = def_configs
file_env_var = "LXDRCFG"
@root_validator
def check_image_sources(cls, values):
error = ""
for rc in values.get('runnermap'):
if ":" in rc.image:
rem = rc.image.split(":")[0]
if rem not in values.get("remotes"):
error += f"Remote '{rem}' is undefined\n"
if error:
raise ValueError(error)
return values
def key_pair_paths(self):
return (self.config_home / "client.crt",
self.config_home / "client.key")
def app_paths(self):
return [self.config_home, self.cache_home] + list(
self.dirs.dict().values())
def config_exists(self):
return [cfgfile for cfgfile in def_configs if cfgfile.exists()]
def __init__(self, app_name, config_dict):
self._config_dict = config_dict
self._app_name = app_name
self._file_name = self._app_name + ".conf"
self._config_file = os.path.join(xdg.xdg_config_home(),
self._file_name)
if not os.path.isfile(self._config_file):
self.write_config()
self.read_file()
def main():
"""the main function, to test the config manager"""
app_name = "maximus"
conf_stub = app_name + ".conf"
conf_path = os.path.join(xdg.xdg_config_home(), conf_stub)
conf_salt = uuid.uuid4().hex
config_dict = {'path': conf_path, 'salt': conf_salt}
the_config = ConfigController(app_name, config_dict)
print("The app_name is: ", app_name)
print("conf_path is: ", conf_path, "\n")
print(the_config.get())
sys.exit(0)
def __get_confdir__():
"""
Configuration directory is specified through:
.env
WAVY_CONFIG environment variable
XDG configuration directory (wavy)
"""
c = os.getenv('WAVY_CONFIG', None)
if c is None:
c = os.path.join(xdg.xdg_config_home(), 'wavy')
if not os.path.exists(c):
c = None
logger.debug('config directory: %s' % c)
return c
def get_global_config_path() -> Path:
"""Get global config path."""
return xdg.xdg_config_home() / "autoimport" / "config.toml"
# Copyright 2021 Robert Schroll
# This file is part of rmcl and is distributed under the MIT license.
import json
from xdg import xdg_config_home
CONFIG_FILE = xdg_config_home() / 'rmcl' / 'config.json'
class Config(dict):
def __init__(self):
super().__init__()
if CONFIG_FILE.exists():
super().update(json.load(CONFIG_FILE.open('r')))
else:
CONFIG_FILE.parent.mkdir(parents=True, exist_ok=True)
def _save(self):
json.dump(self, CONFIG_FILE.open('w'), indent=2)
def __setitem__(self, key, value):
super().__setitem__(key, value)
self._save()
def update(self, other):
super().update(other)
self._save()
def __delitem__(self, key):
super().__delitem__(key)
self._save()
def get_user_config_dir(user: str = None) -> Path:
if _use_xdg(user):
return xdg.xdg_config_home()
return get_user_home(user) / ".config"
import toml
import typer
from xdg import (
xdg_config_home,
xdg_data_dirs,
xdg_data_home,
)
from infod.filesystem import InfoFs
from infod import logging
from infod.config import InfodConfig, CommandSpec
app = typer.Typer()
default_mount = xdg_data_home() / Path('infod/mnt')
default_config = xdg_config_home() / Path('infod/config.toml')
@app.command()
def serve(config: Path = default_config,
mountpoint: typing.Optional[Path] = typer.Argument(None),
debug: bool = False,
debug_fuse: bool = False):
config = toml.load(config)
if not mountpoint:
mountpoint = Path(config.get('mountpoint', default_mount))
mountpoint.mkdir(parents=True, exist_ok=True)
try:
clean(mountpoint)
except:
class Config(ConfigTree):
DEFAULT_PROFILE = "default"
DEFAULT_CONFIG_FILE = "config.yaml"
PACKAGE_HOME = os.path.join(xdg.xdg_config_home(), PACKAGE_NAME)
DEFAULT_CONFIG_PATH = os.path.expanduser(
os.path.join(PACKAGE_HOME, DEFAULT_CONFIG_FILE))
def __init__(self, config_file=None, merge_default=False, *args, **kwargs):
super(Config, self).__init__(*args, **kwargs)
self.__exclude_keys__ |= {
"_config_file", "_config_dir", "include_profile", "_profile_tree"
}
self._config_file = config_file or self.DEFAULT_CONFIG_PATH
self._config_dir = os.path.dirname(self._config_file) or "."
self.load()
self._profile_tree = ProfileTree(**self.profiles,
merge_default=merge_default)
@property
def config_file(self):
return self._config_file
@property
def CONFIG_DIR(self):
return self._config_dir
@property
def LOG_FILE(self):
return os.path.join(self.CONFIG_DIR, f"{PACKAGE_NAME}.log")
@property
def profile(self):
return self._profile_tree.profile
@property
def profiles(self):
return self._profile_tree
@property
def profile_names(self):
return self._profile_tree.profile_names
def include_profile(self, profile):
self._profile_tree.include_profile(profile)
def exclude_profile(self, profile):
self._profile_tree.exclude_profile(profile)
def toggle_profile(self, profile):
self._profile_tree.toggle_profile(profile)
def load(self):
if not os.path.exists(self.config_file):
raise Exception(f"config file {self.config_file} not found")
loader = yaml_loader(ConfigTree, self._config_dir)
config = yaml.load(open(self.config_file), Loader=loader)
self.update(config.items())
def save(self):
d = Tree([(k, v) for k, v in self.items()])
d.update({"profiles": self._profile_tree})
with open(self._config_file, 'w') as outfile:
yaml.dump(d, outfile, default_flow_style=False, indent=4)
import time
import pathlib
import typing
import pendulum
import click
import xdg
from .api import RepublikApi, TokenType, RepublikCDN
API_URL_REPUBLIK = "https://api.republik.ch/graphql"
POLL_FREQUENCY = pendulum.duration(seconds=3)
TOKENS_DIR = xdg.xdg_config_home() / "repyblik" / "tokens"
@click.group()
@click.option(
"--email",
"-m",
prompt="Your email address",
help="The email address you registered with the REPUBLIK",
required=True,
type=str,
)
@click.pass_context
def cli(ctx, email):
click.echo(f"Using '{email}' for this session...")
ctx.ensure_object(dict)
ctx.obj["EMAIL"] = email
ctx.obj["TOKEN_FILE"] = TOKENS_DIR / email
import sqlite3
import os
import pathlib
import sys
from query import Query, QueryColumn
from xdg import xdg_config_home
from typing import Iterator
from user_types import MetaDict, MetaValue
path = pathlib.Path(os.path.abspath(os.path.dirname(sys.argv[0])))
sql_path = path.joinpath("sql")
db_dir = pathlib.Path(xdg_config_home()).joinpath("daifukusan", "bpm_playlist")
db_path = db_dir.joinpath("database.db")
db_dir.mkdir(parents=True, exist_ok=True)
class __Database:
__db_columns = [
"path",
"title",
"albumartist",
"artist",
"composer",
"genre",
"artistsort",
"album",
"bpm",
"length",
"year",
]
def cmd_main(
ctx: click.Context,
user_configs: typing.Iterator[typing.TextIO],
root_stream_log_level: int,
logfiles: typing.Iterable[typing.Tuple[int, pathlib.Path]],
):
"""A CLI toolkit to generate and manupilate the ABC Treebank.
\f
:param ctx: The context argument that is used by Click.
:param user_configs:
List of streams of configuration files.
Each file is opened beforehand
and will be closed properly by Click.
:param root_stream_log_level:
The log level for the root logger. Specified in integer.
:param logfiles:
List of additional log handlers.
Each item consists of a tuple of a log level and an output path.
"""
ctx.ensure_object(dict)
# ====================
# Configure logging
# ====================
# Adjust the root stream handler
logger_root = logging.getLogger()
logger_root.setLevel(root_stream_log_level)
logging.info(
f"The log level of the root logger is set to {logger_root.level}")
# Add file handlers to the root
for level, hpath in logfiles:
hd = logging.FileHandler(hpath)
hd.setLevel(level)
logger_root.addHandler(hd)
# === END FOR level, hpath ===
logger_root.info(
f"The handler(s) of the root logger is/are: {logging.root.handlers}")
# ====================
# Build config
# ====================
from dictknife import deepmerge
import ruamel.yaml
yaml = ruamel.yaml.YAML()
import xdg
import os
CONFIG: typing.Dict[str, typing.Any] = CONF.CONF_DEFAULT
path_config_user: pathlib.Path = xdg.xdg_config_home() / "ABCTreebank.yaml"
if os.path.exists(path_config_user):
with open(path_config_user, "r") as cu:
CONFIG = deepmerge(CONFIG, cu, method="merge")
# === END WITH cu ===
# === END IF ===
for h_cf in user_configs:
CONFIG = deepmerge(CONFIG, yaml.load(h_cf), method="merge")
# === END IF ===
ctx.obj["CONFIG"] = CONFIG
# Great setup for local developers, just need to enable DEBUG in local.env
env = environ.Env(
DEBUG=(bool, False),
SECRET_KEY=(str, "lih*)#c#npi*(tgw8xs-@4a-%k*1tnd4uqo)zy!rzzx5sc#-+d"),
ADMIN=(tuple, []), # Tuple of ONE admin (name, email)
ALLOWED_HOSTS=(list, []),
STATIC_URL=(
str, "/static/"), # URL path that server will server static files from
STATIC_ROOT=(str, None), # Collect static files here
DATABASE=(str, "sqlite:///" + repo_root("db.sqlite3")),
OMDB_API_KEY=(str, ""), # REQUIRED if omdb is used
SENTRY_DSN=(str, ""), # REQUIRED if sentry is used
SENTRY_TRACE_RATE=(float, 0.01),
)
if (xdg_config_home() / "vote4film/local.env").exists():
config_file = str(
environ.Path(xdg_config_home() / "vote4film/local.env", required=True))
else:
config_file = repo_root("local.env", required=True)
# Read environment configuration (it must exist even for local developers)
try:
environ.Env.read_env(config_file)
except ImproperlyConfigured:
print("-" * 80)
print("Are you a developer running this locally?")
print(
'You must create local.env in repository root with "DEBUG=on" inside.')
print("-" * 80)
sys.exit(1)
def test_xdg_config_home_unset(monkeypatch: MonkeyPatch) -> None:
"""Test xdg_config_home when XDG_CONFIG_HOME is unset."""
monkeypatch.delenv("XDG_CONFIG_HOME", raising=False)
monkeypatch.setenv("HOME", os.fspath(HOME_DIR))
assert xdg.xdg_config_home() == HOME_DIR / ".config"
def main():
cache = f'{xdg.xdg_cache_home()}/raccoon-entries'
excludes = ['exo-open', 'steam://', '/usr/bin/wine', '/opt/google/chrome/google-chrome']
def refresh_cache():
dirs = xdg.xdg_data_dirs() + [xdg.xdg_data_home()]
dirs = [dir/'applications' for dir in dirs]
def walk(path):
try:
return next(os.walk(path))[2]
except StopIteration:
return []
files = [ [ f'{path}/{f}'
for f
in walk(path)
if f.endswith('.desktop')
]
for path
in dirs
]
files = [f for dir in files for f in dir]
entries = {}
for f in files:
parser = ConfigParser(strict=False, interpolation=None)
parser.read(f)
try:
entry = parser['Desktop Entry']
except KeyError:
continue
if entry.get('Type') == 'Application' and entry.get('Name') and entry.get('Exec'):
cmd = entry['Exec']
while True:
n = cmd.find('%')
if n == -1:
break
cmd = cmd[:n] + cmd[n+2:]
cmd = ' '.join(cmd.split())
if all(exclude not in cmd for exclude in excludes):
entries[f'{entry["Name"]} ({cmd})'] = cmd
with open(cache, 'w') as f:
json.dump(entries, f)
def entries():
while True:
try:
with open(cache) as f:
return json.load(f)
except FileNotFoundError:
refresh_cache()
preferred_entries = {}
try:
with open(xdg.xdg_config_home()/'raccoon-dmenu-desktop/preferred.list') as f:
for line in f.readlines():
l = line.split('=')
try:
preferred_entries[l[0]] = l[1].rstrip()
except IndexError:
print(f'bad preferred.list entry: {line}')
except FileNotFoundError:
print('no preferred.list')
def preferred(k):
for j in preferred_entries.keys():
if k.startswith(j):
k = preferred_entries[j]+' '+k
print(k)
return k.lower()
dmenu = sys.argv
dmenu[0] = 'dmenu'
entries = entries()
out = run(dmenu, input='\n'.join(sorted(entries.keys(), key=preferred)), capture_output=True, text=True).stdout
try:
cmd = entries[out.rstrip()]
except KeyError:
sys.exit(1)
Popen(cmd, shell=True)
def test_xdg_config_home_set(monkeypatch: MonkeyPatch) -> None:
"""Test xdg_config_home when XDG_CONFIG_HOME is set."""
monkeypatch.setenv("XDG_CONFIG_HOME", "/xdg_config_home")
assert xdg.xdg_config_home() == Path("/xdg_config_home")
def test_xdg_config_home_empty(monkeypatch: MonkeyPatch) -> None:
"""Test xdg_config_home when XDG_CONFIG_HOME is empty."""
monkeypatch.setenv("HOME", os.fspath(HOME_DIR))
monkeypatch.setenv("XDG_CONFIG_HOME", "")
assert xdg.xdg_config_home() == HOME_DIR / ".config"
from urllib import request, parse
import os.path
import json
import spotipy
from Xlib.display import Display
from spotipy.oauth2 import SpotifyClientCredentials
from xdg import xdg_cache_home, xdg_config_home
from pathlib import Path
import tempfile
player = Playerctl.Player()
playing = False
previousAlbumArt = None #Used to not reblur if you're listening to an album
cachedir = xdg_cache_home().joinpath("background-media")
configdir = xdg_config_home().joinpath("background-media")
tempdir = Path(os.path.join(tempfile.gettempdir(),"background-media"))
#setup dirs
cachedir.mkdir(parents=True, exist_ok=True)
configdir.mkdir(parents=True, exist_ok=True)
tempdir.mkdir(parents=True, exist_ok=True)
def getResolution():
screen = Display(':0').screen()
return "{}x{}".format(screen.width_in_pixels,screen.height_in_pixels)
def squareResolution():
screen = Display(':0').screen()
x = screen.width_in_pixels
y = screen.height_in_pixels
if x >= y:
class Config:
DEFAULT_CONFIG = {
'broker': {
'url': 'amqp://localhost:5672/%2F'
},
'api': {
'enabled': True,
'port': 8089
},
'components': [],
# 'workdir': '/var/villas/controller/simulators/'
'workdir': os.getcwd(),
'uuid': str(uuid.uuid4())
}
DEFAULT_PATHS = xdg_config_dirs() + [
xdg_config_home(),
getcwd(),
os.path.join(getcwd(), 'etc'), '/etc/villas/controller/'
]
def __init__(self, fp=None):
if fp is None:
fn = self.find_default_path()
if fn:
with open(fn) as fp:
self.load(fp)
else:
self.config = {} # Start without config
else:
self.load(fp)
def load(self, fp):
config = yaml.load(fp, Loader=yaml.FullLoader)
merged = merge(self.DEFAULT_CONFIG, config)
self.config = dotmap.DotMap(merged)
def find_default_path(self,
filename='config',
suffixes=['json', 'yaml', 'yml']):
for path in Config.DEFAULT_PATHS:
for suffix in suffixes:
fn = os.path.join(path, f'{filename}.{suffix}')
if os.access(fn, os.R_OK):
return fn
@property
def components(self) -> List[Component]:
return [Component.from_dict(c) for c in self.config.components]
def __getattr__(self, attr):
return self.config.get(attr)
def check(self):
uuids = [c.uuid for c in self.components]
dups_uuids = set([u for u in uuids if uuids.count(u) > 1])
if len(dups_uuids) > 0:
raise RuntimeError('Duplicate UUIDs: ' + dups_uuids)
import typing
import urllib.parse
import xdg
from goodconf import GoodConf
from pydantic import (BaseModel, IPvAnyAddress, constr, root_validator,
validator)
with importlib.resources.path('lxdrunner.scripts', 'setuprunner.sh') as path:
def_script = path
appname = "lxdrunner"
def_configs = [
pathlib.Path("config.yml"),
xdg.xdg_config_home() / f"{appname}/config.yml"
]
class RunnerConf(BaseModel):
name: str
labels: frozenset
image: str
profiles: typing.List[str] = ['default']
runner_os: typing.Literal['linux', 'win', 'osx']
runner_arch: typing.Literal['x64', 'arm', 'arm64']
type: typing.Literal['container', 'virtual-machine']
setup_script: pathlib.Path = def_script
max_workers: int = 10
worksem: threading.BoundedSemaphore = None
from sds011 import SDS011 # py-sds011
import aqi # python-aqi
from xdg import xdg_config_home, xdg_config_dirs, xdg_state_home
NOTION_BASE_URL = "https://api.getnotion.com/api"
# The temperature that the purpleair sensor gathers is higher than the ambient
# temperature due to the heat generated by the sensor
# https://www.facebook.com/groups/purpleair/permalink/722201454903597/?comment_id=722420321548377
# https://www.reddit.com/r/PurpleAir/comments/imvepg/just_got_my_purpleair_to_measure_aqi_i_didnt/g45uonx
# pa.js widget has a "temperatureOffset" variable with a value I don't know yet
OBSERVED_ADDITIONAL_PURPLE_AIR_TEMP_OFFSET = 1
PURPLE_AIR_TEMP_OFFSET = -9.43 + OBSERVED_ADDITIONAL_PURPLE_AIR_TEMP_OFFSET
filename = 'monitor_air_quality_config.yaml'
dirs = [xdg_config_home()]
dirs.extend((xdg_config_dirs()))
config_files = [
PosixPath(x, filename) for x in dirs if PosixPath(x, filename).exists()
]
if not config_files:
config = dict()
else:
with config_files[0].open() as f:
config = yaml.safe_load(f)
def celsius_to_fahrenheit(degrees_c):
return 32.0 + (float(degrees_c) * 1.8)
color = "#ffff00"
else:
color = "#ff0000"
delayStr = "({:+.0f})".format(delay)
else:
delayStr = ""
if isinstance(predicted_arrival_timestamp, int):
predicted_arrival_time = datetime.fromtimestamp(
predicted_arrival_timestamp)
else:
# We assume it's datetime already.
predicted_arrival_time = predicted_arrival_timestamp
return f'{stop_name} at <span fgcolor="{color}">{predicted_arrival_time:%H:%M}{delayStr}</span>'
api_key_path = Path(xdg.xdg_config_home(), "travelynx.conf")
if api_key_path.exists():
with api_key_path.open("r") as f:
api_key = f.read().strip()
else:
print(
f"Could not find Travelynx API key at {api_key_path}.",
file=sys.stderr,
)
sys.exit(1)
api_base = f"https://travelynx.de/api/v1/status/{api_key}"
try:
res = requests.get(api_base)
except requests.exceptions.ConnectionError:
print(
# Copyright 2021 Robert Schroll
# This file is part of RMfuse and is distributed under the MIT license.
import ast
from configparser import ConfigParser
import enum
import inspect
import logging
import sys
from xdg import xdg_config_home
from rmrl import render
log = logging.getLogger(__name__)
CONFIG_FILE = xdg_config_home() / 'rmfuse' / 'config.ini'
class FSMode(enum.Enum):
meta = 'meta'
raw = 'raw'
orig = 'orig'
annot = 'annot'
def __str__(self):
return self.name
def _get_render_defaults():
defaults = inspect.getfullargspec(render).kwonlydefaults
del defaults['progress_cb']
TIME_ZONE = "UTC"
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.1/howto/static-files/
STATICFILES_DIRS = [os.path.join(BASE_DIR, "assets")]
STATIC_ROOT = os.path.join(BASE_DIR, "static")
STATIC_URL = "/static/"
AUTH_USER_MODEL = "st_web.User"
# ----- Syncthing settings -----
st_config_path = os.path.join(xdg_config_home(), "syncthing/config.xml")
parsed_xml = ElementTree.parse(st_config_path)
folders = parsed_xml.findall("folder")
ST_CONFIG = []
for folder in folders:
ST_CONFIG.append({
"id": folder.get("id"),
"label": folder.get("label"),
"path": folder.get("path"),
})
PACKAGE_PATH = Path(module_path).parent
PACKAGE_STATIC_PATH = PACKAGE_PATH / "static"
PACKAGE_SCRIPTS_PATH = PACKAGE_PATH / "scripts"
BASE_DATA_PATH = (
Path(os.environ["FT_DATA_PATH"])
if "FT_DATA_PATH" in os.environ
else Path(xdg_data_home(), "footron")
)
BASE_CONFIG_PATH = (
Path(os.environ["FT_CONFIG_PATH"])
if "FT_CONFIG_PATH" in os.environ
else Path(xdg_config_home(), "footron")
)
BASE_MESSAGING_URL = (
os.environ["FT_MSG_URL"]
if "FT_MSG_URL" in os.environ
else "ws://localhost:8088/messaging/out/"
)
BASE_BIN_PATH = BASE_DATA_PATH / "bin"
ROLLBAR_TOKEN = os.environ["FT_ROLLBAR"] if "FT_ROLLBAR" in os.environ else None
STABILITY_CHECK = (
bool(int(os.environ["FT_CHECK_STABILITY"]))
if "FT_CHECK_STABILITY" in os.environ