fujin-cli 0.8.0__py3-none-any.whl → 0.9.1__py3-none-any.whl

fujin/commands/_base.py

@@ -10,8 +10,8 @@ from fujin.connection import Connection
 from fujin.connection import host_connection
 from fujin.errors import ImproperlyConfiguredError
 from fujin.hooks import HookManager
-from fujin.process_managers import ProcessManager
 from fujin.proxies import WebProxy
+from fujin.systemd import ProcessManager
 
 
 @dataclass
@@ -66,15 +66,5 @@ class BaseCommand:
     def create_web_proxy(self, conn: Connection) -> WebProxy:
         return self.web_proxy_class.create(conn=conn, config=self.config)
 
-    @cached_property
-    def process_manager_class(self) -> type[ProcessManager]:
-        module = importlib.import_module(self.config.process_manager)
-        try:
-            return getattr(module, "ProcessManager")
-        except KeyError as e:
-            raise ImproperlyConfiguredError(
-                f"Missing ProcessManager class in {self.config.process_manager}"
-            ) from e
-
     def create_process_manager(self, conn: Connection) -> ProcessManager:
-        return self.process_manager_class.create(conn=conn, config=self.config)
+        return ProcessManager.create(conn=conn, config=self.config)

fujin/commands/config.py

@@ -37,9 +37,17 @@ class ConfigCMD(BaseCommand):
             )
         )
 
+        host_config = {
+            f: getattr(self.config.host, f) for f in self.config.host.__struct_fields__
+        }
+        host_config.pop("_key_filename")
+        host_config.pop("_env_file")
+        host_config.pop("env_content")
+        if self.config.host.key_filename:
+            host_config["key_filename"] = self.config.host.key_filename
+        host_config["env_content"] = self.config.host.env_content
         host_config_text = "\n".join(
-            f"[dim]{key}:[/dim] {value}"
-            for key, value in self.config.host.to_dict().items()
+            f"[dim]{key}:[/dim] {value}" for key, value in host_config.items()
         )
         console.print(
             Panel(

fujin/commands/deploy.py

@@ -52,15 +52,15 @@ class Deploy(BaseCommand):
         return f"{self.app_dir}/v{self.config.version}"
 
     def parse_envfile(self) -> str:
-        if not self.config.host.envfile.exists():
-            raise cappa.Exit(f"{self.config.host.envfile} not found", code=1)
         if self.config.secret_config:
             self.stdout.output("[blue]Reading secrets....[/blue]")
-            return resolve_secrets(self.config.host.envfile, self.config.secret_config)
-        return self.config.host.envfile.read_text()
+            return resolve_secrets(
+                self.config.host.env_content, self.config.secret_config
+            )
+        return self.config.host.env_content
 
     def transfer_files(
-            self, conn: Connection, env: str, skip_requirements: bool = False
+        self, conn: Connection, env: str, skip_requirements: bool = False
     ):
         conn.run(f"echo '{env}' > {self.app_dir}/.env")
         distfile_path = self.config.get_distfile_path()
@@ -78,7 +78,7 @@ class Deploy(BaseCommand):
             )
 
     def install_project(
-            self, conn: Connection, version: str | None = None, *, skip_setup: bool = False
+        self, conn: Connection, version: str | None = None, *, skip_setup: bool = False
     ):
         version = version or self.config.version
         if self.config.installation_mode == InstallationMode.PY_PACKAGE:
@@ -87,7 +87,7 @@ class Deploy(BaseCommand):
             self._install_binary(conn, version)
 
     def _install_python_package(
-            self, conn: Connection, version: str, skip_setup: bool = False
+        self, conn: Connection, version: str, skip_setup: bool = False
     ):
         appenv = f"""
 set -a  # Automatically export all variables

fujin/commands/init.py

@@ -31,7 +31,7 @@ class Init(BaseCommand):
         }
         app_name = Path().resolve().stem.replace("-", "_").replace(" ", "_").lower()
         config = profile_to_func[self.profile](app_name)
-        fujin_toml.write_text(tomli_w.dumps(config))
+        fujin_toml.write_text(tomli_w.dumps(config, multiline_strings=True))
         self.stdout.output(
             "[green]Sample configuration file generated successfully![/green]"
         )
@@ -57,7 +57,7 @@ def simple_config(app_name) -> dict:
         "host": {
             "user": "root",
             "domain_name": f"{app_name}.com",
-            "envfile": ".env.prod",
+            "env_content": f"DEBUG=False\nALLOWED_HOSTS={app_name}.com\n",
         },
     }
     if not Path(".python-version").exists():

fujin/commands/printenv.py

@@ -11,8 +11,8 @@ class Printenv(BaseCommand):
     def __call__(self):
         if self.config.secret_config:
             result = resolve_secrets(
-                self.config.host.envfile, self.config.secret_config
+                self.config.host.env_content, self.config.secret_config
             )
         else:
-            result = self.config.host.envfile.read_text()
+            result = self.config.host.env_content
         self.stdout.output(result)

fujin/commands/redeploy.py

@@ -34,8 +34,8 @@ class Redeploy(BaseCommand):
 
     def _copy_requirements_if_needed(self, conn: Connection) -> bool:
         if (
-                not self.config.requirements
-                or self.config.installation_mode == InstallationMode.BINARY
+            not self.config.requirements
+            or self.config.installation_mode == InstallationMode.BINARY
         ):
             return False
         local_requirements = hashlib.md5(

fujin/config.py

@@ -116,6 +116,11 @@ Example:
 .. note::
 
     Commands are relative to your ``app_dir``. When generating systemd service files, the full path is automatically constructed.
+    Here are the templates for the service files:
+
+    - `web.service <https://github.com/falcopackages/fujin/blob/main/src/fujin/templates/web.service>`_
+    - `web.socket <https://github.com/falcopackages/fujin/blob/main/src/fujin/templates/web.socket>`_
+    - `simple.service <https://github.com/falcopackages/fujin/blob/main/src/fujin/templates/simple.service>`_ (for all additional processes)
 
 Host Configuration
 -------------------
@@ -136,10 +141,18 @@ The login user for running remote tasks. Should have passwordless sudo access fo
 
     You can create a user with these requirements using the ``fujin server create-user`` command.
 
-envfile
-~~~~~~~
+env_file
+~~~~~~~~
 Path to the production environment file that will be copied to the host.
 
+env_content
+~~~~~~~~~~~
+A string containing the production environment variables, ideal for scenarios where most variables are retrieved from secrets and you prefer not to use a separate file.
+
+.. important::
+
+    ``env_file`` and ``env_content`` are mutually exclusive—you can define only one.
+
 apps_dir
 ~~~~~~~~
 
@@ -178,7 +191,7 @@ Example:
 
 hooks
 -----
-Run custom scripts at specific points with hooks. Check out the `secrets </hooks.html>`_ page for more information.
+Run custom scripts at specific points with hooks. Check out the `hooks </hooks.html>`_ page for more information.
 
 """
 
@@ -227,7 +240,6 @@ class Config(msgspec.Struct, kw_only=True):
     aliases: dict[str, str] = msgspec.field(default_factory=dict)
     host: HostConfig
     processes: dict[str, str] = msgspec.field(default_factory=dict)
-    process_manager: str = "fujin.process_managers.systemd"
     webserver: Webserver
     requirements: str | None = None
     hooks: HooksDict = msgspec.field(default_factory=dict)
@@ -271,28 +283,27 @@ class HostConfig(msgspec.Struct, kw_only=True):
     ip: str | None = None
     domain_name: str
     user: str
-    _envfile: str = msgspec.field(name="envfile")
+    _env_file: str = msgspec.field(name="envfile", default="")
+    env_content: str = ""
     apps_dir: str = ".local/share/fujin"
     password_env: str | None = None
     ssh_port: int = 22
     _key_filename: str | None = msgspec.field(name="key_filename", default=None)
 
     def __post_init__(self):
+        if self._env_file and self.env_content:
+            raise ImproperlyConfiguredError(
+                "Cannot set both 'env_content' and 'env_file' properties."
+            )
+        if not self.env_content:
+            envfile = Path(self._env_file)
+            if not envfile.exists():
+                raise ImproperlyConfiguredError(f"{self._env_file} not found")
+            self.env_content = envfile.read_text()
+        self.env_content = self.env_content.strip()
         self.apps_dir = f"/home/{self.user}/{self.apps_dir}"
         self.ip = self.ip or self.domain_name
 
-    def to_dict(self):
-        d = {f: getattr(self, f) for f in self.__struct_fields__}
-        d.pop("_key_filename")
-        d.pop("_envfile")
-        d["key_filename"] = self.key_filename
-        d["envfile"] = self.envfile
-        return d
-
-    @property
-    def envfile(self) -> Path:
-        return Path(self._envfile)
-
     @property
     def key_filename(self) -> Path | None:
         if self._key_filename:

fujin/proxies/caddy.py

@@ -166,7 +166,8 @@ class WebProxy(msgspec.Struct):
         new_routes = [r for r in existing_routes if r.get("group") != self.app_name]
         current_config["routes"] = new_routes
         self.conn.run(
-            f"curl localhost:2019/config/apps/http/servers/srv0 -H 'Content-Type: application/json' -d '{json.dumps(current_config)}'"
+            f"curl localhost:2019/config/apps/http/servers/srv0 -H 'Content-Type: application/json' -d '{json.dumps(current_config)}'",
+            hide="out",
         )
 
     def start(self) -> None:

fujin/secrets/__init__.py

@@ -1,19 +1,19 @@
 from __future__ import annotations
 
-from pathlib import Path
-from typing import Callable
+from contextlib import closing
+from io import StringIO
+from typing import Callable, ContextManager
 
 import gevent
 from dotenv import dotenv_values
 
-from .bitwarden import bitwarden
-from .onepassword import one_password
 from fujin.config import SecretAdapter
 from fujin.config import SecretConfig
-
+from .bitwarden import bitwarden
+from .onepassword import one_password
 
 secret_reader = Callable[[str], str]
-secret_adapter_context = Callable[[SecretConfig], secret_reader]
+secret_adapter_context = Callable[[SecretConfig], ContextManager[secret_reader]]
 
 adapter_to_context: dict[SecretAdapter, secret_adapter_context] = {
     SecretAdapter.BITWARDEN: bitwarden,
@@ -21,14 +21,17 @@ adapter_to_context: dict[SecretAdapter, secret_adapter_context] = {
 }
 
 
-def resolve_secrets(envfile: Path, secret_config: SecretConfig) -> str:
-    env_dict = dotenv_values(envfile)
+def resolve_secrets(env_content: str, secret_config: SecretConfig) -> str:
+    with closing(StringIO(env_content)) as buffer:
+        env_dict = dotenv_values(stream=buffer)
     secrets = {key: value for key, value in env_dict.items() if value.startswith("$")}
+    if not secrets:
+        return env_content
     adapter_context = adapter_to_context[secret_config.adapter]
     parsed_secrets = {}
-    with adapter_context(secret_config) as secret_reader:
+    with adapter_context(secret_config) as reader:
         for key, secret in secrets.items():
-            parsed_secrets[key] = gevent.spawn(secret_reader, secret[1:])
+            parsed_secrets[key] = gevent.spawn(reader, secret[1:])
         gevent.joinall(parsed_secrets.values())
     env_dict.update({key: thread.value for key, thread in parsed_secrets.items()})
     return "\n".join(f'{key}="{value}"' for key, value in env_dict.items())

fujin/{process_managers/systemd.py → systemd.py}

@@ -4,6 +4,8 @@ import importlib.util
 from dataclasses import dataclass
 from pathlib import Path
 
+import gevent
+
 from fujin.config import Config
 from fujin.connection import Connection
 
@@ -54,11 +56,23 @@ class ProcessManager:
                 hide="out",
             )
 
+        threads = []
         for name in self.processes:
             if name == "web" and self.is_using_unix_socket:
-                self.run_pty(f"sudo systemctl enable --now {self.app_name}.socket")
+                threads.append(
+                    gevent.spawn(
+                        self.run_pty,
+                        f"sudo systemctl enable --now {self.app_name}.socket",
+                    )
+                )
             else:
-                self.run_pty(f"sudo systemctl enable {self.get_service_name(name)}")
+                threads.append(
+                    gevent.spawn(
+                        self.run_pty,
+                        f"sudo systemctl enable {self.get_service_name(name)}",
+                    )
+                )
+        gevent.joinall(threads)
 
     def get_configuration_files(
         self, ignore_local: bool = False
@@ -105,47 +119,68 @@ class ProcessManager:
 
     def uninstall_services(self) -> None:
         self.stop_services()
-        for name in self.service_names:
-            self.run_pty(f"sudo systemctl disable {name}", warn=True)
-            self.run_pty(f"sudo rm /etc/systemd/system/{name}", warn=True)
+        threads = [
+            gevent.spawn(self.run_pty, f"sudo systemctl disable {name}", warn=True)
+            for name in self.service_names
+        ]
+        gevent.joinall(threads)
+        files_to_delete = [f"/etc/systemd/system/{name}" for name in self.service_names]
+        self.run_pty(f"sudo rm {' '.join(files_to_delete)}", warn=True)
 
     def start_services(self, *names) -> None:
         names = names or self.service_names
-        for name in names:
-            if name in self.service_names:
-                self.run_pty(f"sudo systemctl start {name}")
+        threads = [
+            gevent.spawn(self.run_pty, f"sudo systemctl start {name}")
+            for name in names
+            if name in self.service_names
+        ]
+        gevent.joinall(threads)
 
     def restart_services(self, *names) -> None:
         names = names or self.service_names
-        for name in names:
-            if name in self.service_names:
-                self.run_pty(f"sudo systemctl restart {name}")
+        threads = [
+            gevent.spawn(self.run_pty, f"sudo systemctl restart {name}")
+            for name in names
+            if name in self.service_names
+        ]
+        gevent.joinall(threads)
 
     def stop_services(self, *names) -> None:
         names = names or self.service_names
-        for name in names:
-            if name in self.service_names:
-                self.run_pty(f"sudo systemctl stop {name}")
+        threads = [
+            gevent.spawn(self.run_pty, f"sudo systemctl stop {name}")
+            for name in names
+            if name in self.service_names
+        ]
+        gevent.joinall(threads)
 
     def is_enabled(self, *names) -> dict[str, bool]:
         names = names or self.service_names
-        return {
-            name: self.run_pty(
-                f"sudo systemctl is-enabled {name}", warn=True, hide=True
-            ).stdout.strip()
-            == "enabled"
+        threads = {
+            name: gevent.spawn(
+                self.run_pty, f"sudo systemctl is-enabled {name}", warn=True, hide=True
+            )
             for name in names
         }
+        gevent.joinall(threads.values())
+        return {
+            name: thread.value.stdout.strip() == "enabled"
+            for name, thread in threads.items()
+        }
 
     def is_active(self, *names) -> dict[str, bool]:
         names = names or self.service_names
-        return {
-            name: self.run_pty(
-                f"sudo systemctl is-active {name}", warn=True, hide=True
-            ).stdout.strip()
-            == "active"
+        threads = {
+            name: gevent.spawn(
+                self.run_pty, f"sudo systemctl is-active {name}", warn=True, hide=True
+            )
             for name in names
         }
+        gevent.joinall(threads.values())
+        return {
+            name: thread.value.stdout.strip() == "active"
+            for name, thread in threads.items()
+        }
 
     def service_logs(self, name: str, follow: bool = False):
         # TODO: add more options here

{fujin_cli-0.8.0.dist-info → fujin_cli-0.9.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: fujin-cli
-Version: 0.8.0
+Version: 0.9.1
 Summary: Get your project up and running in a few minutes on your own vps.
 Project-URL: Documentation, https://github.com/falcopackages/fujin#readme
 Project-URL: Issues, https://github.com/falcopackages/fujin/issues

{fujin_cli-0.8.0.dist-info → fujin_cli-0.9.1.dist-info}/RECORD

@@ -1,38 +1,37 @@
 fujin/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fujin/__main__.py,sha256=VJMBzuQuxkQaAKNEySktGnms944bkRsrIAjj-XeaWR8,1813
-fujin/config.py,sha256=FDHCkfAEt6sEjdK1szSCRqCvBfH7LMs_DQeAFHuR6wg,10540
+fujin/config.py,sha256=jE5iAu1ouHgv2eTut6CRBiKIzK-vxJqVtZuOr6NICEM,11365
 fujin/connection.py,sha256=LL7LhX9p0X9FmiGdlSroD3Ht216QY0Kd51xkSrXmM3s,2479
 fujin/errors.py,sha256=74Rh-Sgql1YspPdR_akQ2G3xZ48zecyafYCptpaFo1A,73
 fujin/hooks.py,sha256=EDVYNozlDJ5kc1xHtZrXgtuKplUMEMPTp65TLMP02Ek,1449
+fujin/systemd.py,sha256=aWfN3CDl_NACjsfzyiVmO2h0-VTgc7y3g8RMG2jVsb4,6640
 fujin/commands/__init__.py,sha256=g0b13vzidPUbxne_Zo_Wv5jpEmwCiSK4AokCinH9uo4,39
-fujin/commands/_base.py,sha256=Rtf7kcO_Pg2JxPNKsXEx0UdhqfzYU6g7IiezC8cqEPQ,2610
+fujin/commands/_base.py,sha256=2k9HGcxskFZQ7qYw8hcJh_73EZ_qVngLot7lOo2hQuw,2193
 fujin/commands/app.py,sha256=mazb4dCTdR5juh79bL3a9b68Nd6O8u_nR9IgYqQlqWE,5279
-fujin/commands/config.py,sha256=xdfd1OZLxw2YZldiAbW5rq5EBXEaXbUC-I7FKLRfzIQ,2387
-fujin/commands/deploy.py,sha256=UFWraUDx2EmfD_riGq79fCWNGfytCJ9UR_eYKOfDYXY,5945
+fujin/commands/config.py,sha256=WymGla-H2yduhLcYE1Nb6IJaFIj0S0KIhV9fBDCKsAw,2779
+fujin/commands/deploy.py,sha256=AylcVNX47ekf-AFfQrYcSh86I3qltADEgjPtV9lQAfE,5831
 fujin/commands/docs.py,sha256=b5FZ8AgoAfn4q4BueEQvM2w5HCuh8-rwBqv_CRFVU8E,349
 fujin/commands/down.py,sha256=aw_mxl_TMC66plKTXwlYP1W2XQBmHeROltQqOpQssyE,1577
-fujin/commands/init.py,sha256=zREfkIQyC6etqqQ6hgvDqpNNWQT4bk_8IOPBBT5-YUE,3983
-fujin/commands/printenv.py,sha256=bpGmOfc1t_dKWb8gy7EILYtwEyI9pIwhKg2XPKyJ9cQ,527
+fujin/commands/init.py,sha256=AHAZeYkSk-zShF288Zs4rCfVwalCUqeMXWR6GTks2v0,4046
+fujin/commands/printenv.py,sha256=bS2mIgk7zd_w3yDhZLTa1PkHIzuSbBWjnYyM8CUjX0k,523
 fujin/commands/proxy.py,sha256=ajXwboS0gDDiMWW7b9rtWU6WPF1h7JYYeycDyU-hQfg,3053
 fujin/commands/prune.py,sha256=C2aAN6AUS84jgRg1eiCroyiuZyaZDmf5yvGAQY9xkcg,1517
-fujin/commands/redeploy.py,sha256=PuXgrEc4fj_88WQXXBBvEtD46IeqzbPeMo-5pDlAuJQ,2363
+fujin/commands/redeploy.py,sha256=491Mzz0qiaHqcI7BFUtZq-M34WQkiBd2ZgQbLRLp8T8,2355
 fujin/commands/rollback.py,sha256=JsocJzQcdQelSnYD94klhjBh8UKkkdiRD9shfUfo4FI,2032
 fujin/commands/server.py,sha256=-3-PyBNR0fGm-RYE3fz50kP-LSDYGU9BzUxrbGZEghc,3312
 fujin/commands/up.py,sha256=OEK_n-6-mnnIUffFpR7QtVunr1V1F04pxlAAS1U62BY,419
-fujin/process_managers/__init__.py,sha256=MhhfTBhm64zWRAKgjvsZRIToOUJus60vGScbAjqpQ6Y,994
-fujin/process_managers/systemd.py,sha256=qG_4Ew8SEWtaTFOAW_XZXsMO2WjFWZ4dp5nBwAPBObk,5603
 fujin/proxies/__init__.py,sha256=UuWYU175tkdaz1WWRCDDpQgGfFVYYNR9PBxA3lTCNr0,695
-fujin/proxies/caddy.py,sha256=dzLD8s664_kIK-1hCE3y50JIwBd8kK9yS1LynUDRVSE,7908
+fujin/proxies/caddy.py,sha256=H52D7cGEEGcxDaXxvClnny9lAat_h1G9dYlIlf6gwKo,7933
 fujin/proxies/dummy.py,sha256=qBKSn8XNEA9SVwB7GzRNX2l9Iw6tUjo2CFqZjWi0FjY,465
 fujin/proxies/nginx.py,sha256=BNJNLxLLRVAmBIGVCk8pb16iiSJsOI9jXOZhdSQGtX8,4151
-fujin/secrets/__init__.py,sha256=p4rY4J7yRoEEz6OXkomJ_Ov2AaaQ37-Zd_TJGpUDPgQ,1217
+fujin/secrets/__init__.py,sha256=hiNZIBtOwM0WQbvAF3GhuMMCsQCjXjiSr5gTLAGN-VI,1375
 fujin/secrets/bitwarden.py,sha256=01GZL5hYwZzL6yXy5ab3L3kgBFBeOT8i3Yg9GC8YwFU,2008
 fujin/secrets/onepassword.py,sha256=6Xj3XWttKfcjMbcoMZvXVpJW1KHxlD785DysmX_mqvk,654
 fujin/templates/simple.service,sha256=-lyKjmSyfHGucP4O_vRQE1NNaHq0Qjsc0twdwoRLgI0,321
 fujin/templates/web.service,sha256=NZ7ZeaFvV_MZTBn8QqRQeu8PIrWHf3aWYWNzjOQeqCw,685
 fujin/templates/web.socket,sha256=2lJsiOHlMJL0YlN7YBLLnr5zqsytPEt81yP34nk0dmc,173
-fujin_cli-0.8.0.dist-info/METADATA,sha256=S-SNZujrKy0Omj5KlcHlWSCPynXWrrm-HtLc9fo17BA,4576
-fujin_cli-0.8.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-fujin_cli-0.8.0.dist-info/entry_points.txt,sha256=Y_TBtKt3j11qhwquMexZR5yqnDEqOBDACtresqQFE-s,46
-fujin_cli-0.8.0.dist-info/licenses/LICENSE.txt,sha256=0QF8XfuH0zkIHhSet6teXfiCze6JSdr8inRkmLLTDyo,1099
-fujin_cli-0.8.0.dist-info/RECORD,,
+fujin_cli-0.9.1.dist-info/METADATA,sha256=5mtskwHoka7b0M4fs897ic7prKs3NgTBrdeMSWlfKBk,4576
+fujin_cli-0.9.1.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+fujin_cli-0.9.1.dist-info/entry_points.txt,sha256=Y_TBtKt3j11qhwquMexZR5yqnDEqOBDACtresqQFE-s,46
+fujin_cli-0.9.1.dist-info/licenses/LICENSE.txt,sha256=0QF8XfuH0zkIHhSet6teXfiCze6JSdr8inRkmLLTDyo,1099
+fujin_cli-0.9.1.dist-info/RECORD,,

fujin/process_managers/__init__.py

@@ -1,40 +0,0 @@
-from __future__ import annotations
-
-from typing import Protocol
-from typing import TYPE_CHECKING
-
-from fujin.connection import Connection
-
-if TYPE_CHECKING:
-    from fujin.config import Config
-
-
-class ProcessManager(Protocol):
-    service_names: list[str]
-
-    @classmethod
-    def create(cls, config: Config, conn: Connection) -> ProcessManager: ...
-
-    def get_service_name(self, process_name: str): ...
-
-    def install_services(self) -> None: ...
-
-    def uninstall_services(self) -> None: ...
-
-    def start_services(self, *names) -> None: ...
-
-    def restart_services(self, *names) -> None: ...
-
-    def stop_services(self, *names) -> None: ...
-
-    def is_enabled(self, *names) -> dict[str, bool]: ...
-
-    def is_active(self, *names) -> dict[str, bool]: ...
-
-    def service_logs(self, name: str, follow: bool = False): ...
-
-    def reload_configuration(self) -> None: ...
-
-    def get_configuration_files(
-        self, ignore_local: bool = False
-    ) -> list[tuple[str, str]]: ...