make profile_dir part of Profile

qpm/config.py

···
-from pathlib import Path
-
-from xdg import BaseDirectory  # type: ignore
-
-profiles_dir = Path(BaseDirectory.xdg_data_home) / "qutebrowser-profiles"

qpm/main.py

···
 import argparse
-import sys
+from argparse import Namespace
 from pathlib import Path
-from typing import Callable, Optional
+from typing import Callable, Optional, Set
 
-from qpm import config, operations, profiles
+from qpm import operations, profiles
 from qpm.profiles import Profile
-from qpm.utils import error
 
 
 def main() -> None:
-    parser = argparse.ArgumentParser(description="Qutebrowser profile manager")
-    parser.set_defaults(operation=lambda args: parser.print_help())
+    parser = argparse.ArgumentParser(description="qutebrowser profile manager")
+    parser.set_defaults(operation=parser.print_help)
     parser.add_argument(
         "-P",
         "--profile-dir",
···
 
     subparsers = parser.add_subparsers()
     new = subparsers.add_parser("new", help="create a new profile")
-    new.set_defaults(
-        operation=lambda args: wrap_op(args.profile_name, profiles.new_profile)
-    )
+    new.set_defaults(operation=wrap_op(profiles.new_profile, set()))
     new.add_argument("profile_name", metavar="name", help="name of the new profile")
     creator_args(new)
 
     session = subparsers.add_parser(
         "from-session", help="create a new profile from a qutebrowser session"
     )
-    session.set_defaults(
-        operation=lambda args: operations.from_session(args.session, args.profile_name),
-    )
+    session.set_defaults(operation=lambda args: operations.from_session(**vars(args)))
     session.add_argument(
         "session", help="session to create a new profile from",
     )
···
         "launch", aliases=["run"], help="launch qutebrowser with the given profile"
     )
     launch.set_defaults(
-        operation=lambda args: wrap_op(
-            args.profile_name,
-            lambda profile: operations.launch(
-                profile, args.strict, args.foreground, args.qb_args or []
-            ),
-        )
+        operation=wrap_op(operations.launch, {"strict", "foreground", "qb_args"})
     )
     launch.add_argument(
         "profile_name",
···
     raw_args = parser.parse_known_args()
     args = raw_args[0]
     args.qb_args = raw_args[1]
-    if args.profile_dir:
-        if not args.profile_dir.is_dir():
-            error(f"{args.profile_dir} is not a directory")
-            sys.exit(1)
-        config.profiles_dir = args.profile_dir
     args.operation(args)
 
 
···
     parser.set_defaults(
         strict=True, foreground=False,
     )
-
-
-def wrap_op(profile_name: str, op: Callable[[Profile], bool]) -> Optional[Profile]:
-    profile = Profile(profile_name)
-    return profile if op(profile) else None
 
 
 class ThenLaunchAction(argparse.Action):
···
     if profile:
         return operations.launch(profile, args.strict, args.foreground, [])
     return False
+
+
+def wrap_op(
+    op: Callable[..., bool], wanted: Set[str]
+) -> Callable[[Namespace], Optional[Profile]]:
+    def f(args) -> Optional[Profile]:
+        profile = Profile(args.profile_name, args.profile_dir)
+        kwargs = {k: v for (k, v) in vars(args).items() if k in wanted}
+        return profile if op(profile=profile, **kwargs) else None
+
+    return f
 
 
 if __name__ == "__main__":

qpm/operations.py

···
 import subprocess
 from typing import Iterable, Optional
 
-from qpm import config, profiles
+from qpm import profiles
 from qpm.profiles import Profile
 from qpm.utils import error
 
···
         error(f"{session} is not a file")
         return None
 
-    profile = Profile(profile_name or session_name)
+    profile = Profile(profile_name or session_name, None)
     if not profiles.new_profile(profile):
         return None
 
···
 
 
 def launch(
-    profile: Profile, strict: bool, foreground: bool, args: Iterable[str]
+    profile: Profile, strict: bool, foreground: bool, qb_args: Iterable[str]
 ) -> bool:
     if not profiles.ensure_profile_exists(profile, not strict):
         return False
 
     if foreground:
-        os.execlp("qutebrowser", "qutebrowser", "-B", str(profile.root), *args)
+        os.execlp("qutebrowser", "qutebrowser", "-B", str(profile.root), *qb_args)
     else:
         p = subprocess.Popen(
-            ["qutebrowser", "-B", str(profile.root), *args],
+            ["qutebrowser", "-B", str(profile.root), *qb_args],
             stdout=subprocess.DEVNULL,
             stderr=subprocess.PIPE,
         )

qpm/profiles.py

···
 import platform
 import sys
 from pathlib import Path
+from typing import Optional
 
 from xdg import BaseDirectory  # type: ignore
 
-from qpm import config
 from qpm.utils import error
 
 
 class Profile:
     name: str
+    profile_dir: Path
     root: Path
 
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str, profile_dir: Optional[Path]) -> None:
         self.name = name
-        self.root = config.profiles_dir / name
+        self.profile_dir = profile_dir or Path(
+            BaseDirectory.save_data_path("qutebrowser-profiles")
+        )
+        self.root = self.profile_dir / name
+
+    def check(self) -> Optional["Profile"]:
+        if not self.profile_dir.resolve().is_dir():
+            error("{self.profile_dir} is not a directory")
+            return None
+        if self.profile_dir.resolve() not in self.root.resolve().parents:
+            error("will not create profile outside of profile dir. consider using -P")
+            return None
+        if self.root.exists():
+            error(f"{self.root} already exists")
+            return None
+        for parent in self.root.parents:
+            if parent == self.profile_dir:
+                break
+            if parent.exists():
+                error(f"{parent} already exists")
+                return None
+        return self
 
 
 main_config_dir = Path(BaseDirectory.xdg_data_home) / "qutebrowser"
···
     sys.exit(1)
 
 
-def check_profile(profile_root: Path) -> bool:
-    if config.profiles_dir.resolve() not in profile_root.resolve().parents:
-        error("will not create profile outside of profile dir. consider using -P")
-        return False
-    if profile_root.exists():
-        error(f"{profile_root} already exists")
-        return False
-    for parent in profile_root.parents:
-        if parent == config.profiles_dir:
-            break
-        if parent.exists():
-            error(f"{parent} already exists")
-            return False
-    return True
-
-
 def create_profile(profile: Profile) -> bool:
-    if not check_profile(profile.root):
+    if not profile.check():
         return False
 
     config_dir = profile.root / "config"

tests/test_profiles.py

···
 from pathlib import Path
 from typing import Optional
 
-from qpm import config, profiles
+from qpm import profiles
 from qpm.profiles import Profile
 
 
···
 
 
 def test_set_profile(tmp_path: Path):
-    config.profiles_dir = tmp_path
-    assert Profile("test").root == tmp_path / "test"
+    assert Profile("test", tmp_path).root == tmp_path / "test"
 
 
 def test_create_profile(tmp_path: Path):
-    config.profiles_dir = tmp_path
-    profile = Profile("test")
+    profile = Profile("test", tmp_path)
     assert profiles.create_profile(profile)
     assert list(tmp_path.iterdir()) == [profile.root]
     check_empty_profile(profile)
 
 
 def test_create_profile_conflict(tmp_path: Path):
-    config.profiles_dir = tmp_path
     (tmp_path / "test").touch()
-    profile = Profile("test")
+    profile = Profile("test", tmp_path)
     assert not profiles.create_profile(profile)
 
 
 def test_create_profile_parent(tmp_path: Path):
-    config.profiles_dir = tmp_path / "profiles"
-    profile = Profile("../test")
+    profile = Profile("../test", tmp_path / "profiles")
     assert not profiles.create_profile(profile)
     assert not (tmp_path / "test").exists()
 
 
 def test_create_profile_nested_conflict(tmp_path: Path):
-    config.profiles_dir = tmp_path
-    assert profiles.create_profile(Profile("test"))
-    assert not profiles.create_profile(Profile("test/a"))
+    assert profiles.create_profile(Profile("test", tmp_path))
+    assert not profiles.create_profile(Profile("test/a", tmp_path))
 
 
 def test_create_config(tmp_path: Path):
-    config.profiles_dir = tmp_path
-    profile = Profile("test")
+    profile = Profile("test", tmp_path)
     config_dir = profile.root / "config"
     config_dir.mkdir(parents=True)
     profiles.create_config(profile)
···
 
 
 def test_ensure_profile_exists_exists(tmp_path: Path):
-    config.profiles_dir = tmp_path
-    profile = Profile("test")
+    profile = Profile("test", tmp_path)
     profile.root.mkdir()
     assert profiles.ensure_profile_exists(profile, False)
     assert profiles.ensure_profile_exists(profile, True)
···
 
 
 def test_ensure_profile_exists_does_not_exist(tmp_path: Path):
-    config.profiles_dir = tmp_path
-    assert not profiles.ensure_profile_exists(Profile("test"), False)
+    assert not profiles.ensure_profile_exists(Profile("test", tmp_path), False)
     check_is_empty(tmp_path)
 
 
 def test_ensure_profile_exists_not_dir(tmp_path: Path):
-    config.profiles_dir = tmp_path
-    profile = Profile("test")
+    profile = Profile("test", tmp_path)
     profile.root.touch()
     assert not profiles.ensure_profile_exists(profile, False)
     assert not profiles.ensure_profile_exists(profile, True)
 
 
 def test_ensure_profile_exists_create(tmp_path: Path):
-    config.profiles_dir = tmp_path
-    profile = Profile("test")
+    profile = Profile("test", tmp_path)
     assert profiles.ensure_profile_exists(profile, True)
     check_new_profile(profile)
 
 
 def test_new_profile(tmp_path: Path):
-    config.profiles_dir = tmp_path
-    profile = Profile("test")
+    profile = Profile("test", tmp_path)
     assert profiles.new_profile(profile)
     check_new_profile(profile)