olog/symconf
1
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases 1 Wiki Activity

add py execution support to templates, loosen generate matches

Browse Source
This commit is contained in:
Sam G.
2024-08-18 11:56:28 -07:00
parent 017f1c5b1c
commit 2553bc14af
9 changed files with 195 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
symconf/__main__.py
View File

@@ -50,6 +50,7 @@ def add_config_subparser(subparsers):
apps=args.apps,
scheme=args.mode,
style=args.style,
**args.template_vars
)
parser = subparsers.add_parser(
@@ -81,6 +82,7 @@ def add_config_subparser(subparsers):
'-T', '--template-vars',
required = False,
nargs='+',
default = {},
action=util.KVPair,
help='Groups to use when populating templates, in the form group=value'
)
@@ -90,8 +92,11 @@ def add_generate_subparser(subparsers):
def generate_apps(args):
cm = ConfigManager(args.config_dir)
cm.generate_app_templates(
gen_dir=args.gen_dir,
gen_dir=args.output_dir,
apps=args.apps,
scheme=args.mode,
style=args.style,
**args.template_vars
)
parser = subparsers.add_parser(
@@ -99,11 +104,24 @@ def add_generate_subparser(subparsers):
description='Generate all template config files for specified apps'
)
parser.add_argument(
'-g', '--gen-dir',
'-o', '--output-dir',
required = True,
type = util.absolute_path,
help = 'Path to write generated template files'
)
parser.add_argument(
'-s', '--style',
required = False,
default = 'any',
help = 'Style indicator (often a color palette) capturing thematic details in '
'a config file'
)
parser.add_argument(
'-m', '--mode',
required = False,
default = "any",
help = 'Preferred lightness mode/scheme, either "light," "dark," "any," or "none."'
)
parser.add_argument(
'-a', '--apps',
required = False,
@@ -112,6 +130,14 @@ def add_generate_subparser(subparsers):
help = 'Application target for theme. App must be present in the registry. ' \
+ 'Use "*" to apply to all registered apps'
)
parser.add_argument(
'-T', '--template-vars',
required = False,
nargs = '+',
default = {},
action = util.KVPair,
help = 'Groups to use when populating templates, in the form group=value'
)
parser.set_defaults(func=generate_apps)

98
symconf/config.py
View File

@@ -1,19 +1,19 @@
'''
Get the config map for a provided app.
Primary config management abstractions
The config map is a dict mapping from config file **path names** to their absolute
path locations. That is,
```sh
<config_path_name> -> <config_dir>/apps/<app_name>/<subdir>/<palette>-<scheme>.<config_path_name>
```
.. code-block:: sh
<config_path_name> -> <config_dir>/apps/<app_name>/<subdir>/<palette>-<scheme>.<config_path_name>
For example,
```
palette1-light.conf.ini -> ~/.config/symconf/apps/user/palette1-light.conf.ini
palette2-dark.app.conf -> ~/.config/symconf/apps/generated/palette2-dark.app.conf
```
.. code-block:: sh
palette1-light.conf.ini -> ~/.config/symconf/apps/user/palette1-light.conf.ini
palette2-dark.app.conf -> ~/.config/symconf/apps/generated/palette2-dark.app.conf
This ensures we have unique config names pointing to appropriate locations (which
is mostly important when the same config file names are present across ``user``
@@ -220,16 +220,16 @@ class ConfigManager:
files just the same as we do for non-template config files. That is, we will look
for files of the format
```sh
<style>-<scheme>.toml
```
.. code-block:: sh
<style>-<scheme>.toml
The only difference is that, while ``style`` can still include arbitrary style
variants, it *must* have the form
```sh
<variant-1>-...-<variant-N>-<palette>
```
.. code-block:: sh
<variant-1>-...-<variant-N>-<palette>
if you want to match a ``palette`` template. Palettes are like regular template
groups, and should be placed in their own template folder. But when applying those
@@ -346,7 +346,11 @@ class ConfigManager:
return template_dict, relaxed_theme_matches
def _prepare_all_templates(self) -> dict[str, dict]:
def _prepare_all_templates(
self,
scheme = 'any',
style = 'any',
) -> dict[str, dict]:
palette_map = {}
palette_group_dir = Path(self.group_dir, 'palette')
if palette_group_dir.exists():
@@ -358,30 +362,37 @@ class ConfigManager:
palette_base.append(palette_map['none'])
# then palette-scheme groups (require 2-combo logic)
theme_map = {}
theme_matches = []
theme_group_dir = Path(self.group_dir, 'theme')
if theme_group_dir.exists():
for theme_toml in theme_group_dir.iterdir():
fp = FilePart(theme_toml)
theme_matches = self.matcher.match_paths(
theme_group_dir.iterdir(), # match files in groups/theme/
self.matcher.prefix_order( # reg non-template order
scheme, style, strict=True # set strict=True to ignore "nones"
)
)
theme_matches = self.matcher.match_paths(
theme_group_dir.iterdir(), # match files in groups/theme/
self.matcher.prefix_order(fp.scheme, fp.style) # reg non-template order
)
relaxed_theme_matches = self.matcher.relaxed_match(theme_matches)
theme_map = {}
for fp in theme_matches:
# still look through whole theme dir here (eg to match nones)
theme_matches = self.matcher.match_paths(
theme_group_dir.iterdir(), # match files in groups/theme/
self.matcher.prefix_order(fp.scheme, fp.style) # reg non-template order
)
relaxed_theme_matches = self.matcher.relaxed_match(theme_matches)
palette = fp.style.split('-')[-1]
palette_paths = [*palette_base]
if palette in palette_map:
palette_paths.append(palette_map[palette])
palette = fp.style.split('-')[-1]
palette_paths = [*palette_base]
if palette in palette_map:
palette_paths.append(palette_map[palette])
theme_dict = {}
palette_dict = TOMLTemplate.stack_toml(palette_paths)
for file_part in relaxed_theme_matches:
toml_dict = TOMLTemplate(file_part.path).fill(palette_dict)
theme_dict = util.deep_update(theme_dict, toml_dict)
theme_dict = {}
palette_dict = TOMLTemplate.stack_toml(palette_paths)
for file_part in relaxed_theme_matches:
toml_dict = TOMLTemplate(file_part.path).fill(palette_dict)
theme_dict = util.deep_update(theme_dict, toml_dict)
theme_map[fp.path.stem] = {'theme': theme_dict}
theme_map[fp.path.stem] = {'theme': theme_dict}
return theme_map
@@ -406,7 +417,7 @@ class ConfigManager:
``none-<scheme>`` and ``<style>-none`` are both available, in which case the latter
will overwrite the former).
.. admonition: Edge cases
.. admonition:: Edge cases
There are a few quirks to this matching scheme that yield potentially
unintuitive results. As a recap:
@@ -515,9 +526,9 @@ class ConfigManager:
Scripts need to be placed in
```sh
<config_dir>/apps/<app_name>/call/<style>-<scheme>.sh
```
.. code-block:: sh
<config_dir>/apps/<app_name>/call/<style>-<scheme>.sh
and are matched using the same heuristic employed by config file symlinking
procedure (see ``get_matching_configs()``), albeit with a forced ``prefix_order``,
@@ -808,6 +819,9 @@ class ConfigManager:
self,
gen_dir : str | Path,
apps : str | list[str] = '*',
scheme : str = 'any',
style : str = 'any',
**kw_groups,
):
if apps == '*':
app_list = list(self.app_registry.keys())
@@ -823,7 +837,7 @@ class ConfigManager:
print(f'> Writing templates...')
gen_dir = util.absolute_path(gen_dir)
theme_map = self._prepare_all_templates()
theme_map = self._prepare_all_templates(scheme, style)
for app_name in app_list:
app_template_dir = Path(self.apps_dir, app_name, 'templates')
@@ -831,6 +845,12 @@ class ConfigManager:
continue
app_template_files = list(app_template_dir.iterdir())
self.get_matching_templates(
app_name,
scheme=scheme,
style=style,
**kw_groups
)
num_temps = len(app_template_files)
num_themes = len(theme_map)
@@ -855,5 +875,5 @@ class ConfigManager:
print(
color_text("│", Fore.BLUE),
f'> generating "{tgt_template_path.name}"'
f'> generating "{tgt_template_path.name}"'
)

42
symconf/matching.py
View File

@@ -1,9 +1,11 @@
'''
Top-level definitions
Generic combinatorial name-matching subsystem
Config files are expected to have names matching the following spec:
<style>-<scheme>.<config_pathname>
.. code-block:: sh
<style>-<scheme>.<config_pathname>
- ``config_pathname``: refers to a concrete filename, typically that which is expected by
the target app (e.g., ``kitty.conf``). In the context of ``config_map`` in the registry,
@@ -15,17 +17,17 @@ Config files are expected to have names matching the following spec:
For example
```sh
soft-gruvbox-dark.kitty.conf
```
.. code-block:: sh
soft-gruvbox-dark.kitty.conf
gets mapped to
```sh
style -> "soft-gruvbox"
scheme -> "dark"
pathname -> "kitty.conf"
```
.. code-block:: sh
style -> "soft-gruvbox"
scheme -> "dark"
pathname -> "kitty.conf"
'''
from pathlib import Path
@@ -64,9 +66,9 @@ class Matcher:
Pathnames should be of the format
```sh
<style>-<scheme>.<config_pathname>
```
.. code-block:: sh
<style>-<scheme>.<config_pathname>
where ``style`` is typically itself of the form ``<variant>-<palette>``.
'''
@@ -151,12 +153,12 @@ class Matcher:
"consistent" with some user input (and is computed external to this method). For
example, it could be
```py
[
('none', 'none')
('none', 'dark')
]
```
.. code-block:: python
[
('none', 'none')
('none', 'dark')
]
indicating that either ``none-none.<config>`` or ``none-dark.<config>`` would be
considered matching pathnames, with the latter being preferred.
@@ -166,7 +168,7 @@ class Matcher:
will be available, so we consider each file for each of the prefixes, and take the
latest/best match for each unique config pathname (allowing for a "soft" match).
.. admonition: Checking for matches
.. admonition:: Checking for matches
When thinking about how best to structure this method, it initially felt like
indexing factors of the FileParts would make the most sense, preventing the

3
symconf/reader.py
View File

@@ -1,3 +1,6 @@
'''
Simplified management for nested dictionaries
'''
import copy
import pprint
import tomllib

3
symconf/runner.py
View File

@@ -1,3 +1,6 @@
'''
Handle job/script execution
'''
import stat
import subprocess
from pathlib import Path

61
symconf/template.py
View File

@@ -1,3 +1,6 @@
'''
Support for basic config templates
'''
import re
import tomllib
from pathlib import Path
@@ -10,10 +13,12 @@ class Template:
def __init__(
self,
template_str : str,
pattern : str = r'f{{(\S+?)}}',
key_pattern : str = r'f{{(\S+?)}}',
exe_pattern : str = r'x{{(.*)}}',
):
self.template_str = template_str
self.pattern = pattern
self.key_pattern = key_pattern
self.exe_pattern = exe_pattern
def fill(
self,
@@ -21,32 +26,66 @@ class Template:
) -> str:
dr = DictReader.from_dict(template_dict)
return re.sub(
self.pattern,
lambda m: str(dr.get(m.group(1))),
exe_filled = re.sub(
self.exe_pattern,
lambda m: self._exe_fill(m, dr),
self.template_str
)
key_filled = re.sub(
self.key_pattern,
lambda m: self._key_fill(m, dr),
exe_filled
)
return key_filled
def _key_fill(
self,
match,
dict_reader: DictReader,
) -> str:
key = match.group(1)
return str(dict_reader.get(key))
def _exe_fill(
self,
match,
dict_reader: DictReader,
) -> str:
key_fill = re.sub(
self.key_pattern,
lambda m: f'"{self._key_fill(m, dict_reader)}"',
match.group(1)
)
return str(eval(key_fill))
class FileTemplate(Template):
def __init__(
self,
path : Path,
pattern : str = r'f{{(\S+)}}',
path: Path,
key_pattern: str = r'f{{(\S+?)}}',
exe_pattern: str = r'x{{(.*)}}',
):
super().__init__(
path.open('r').read(),
pattern=pattern
key_pattern=key_pattern,
exe_pattern=exe_pattern,
)
class TOMLTemplate(FileTemplate):
def __init__(
self,
toml_path : Path,
pattern : str = r'f{{(\S+)}}',
toml_path: Path,
key_pattern: str = r'f{{(\S+?)}}',
exe_pattern: str = r'x{{(.*)}}',
):
super().__init__(
toml_path,
pattern=pattern
key_pattern=key_pattern,
exe_pattern=exe_pattern,
)
def fill(

2
symconf/util.py
View File

@@ -14,7 +14,7 @@ def color_text(text, *colorama_args):
Note: we attempt to preserve expected nested behavior by only resetting the groups
(Fore, Back, Style) affected the styles passed in. This works when an outer call is
changing styles in one group, and an inner call is changing styles in another, but
_not_ when affected groups overlap.
*not* when affected groups overlap.
For example, if an outer call is setting the foreground color (e.g., ``Fore.GREEN``),
nested calls on the text being passed into the function can modify and reset the