rename modename -> mode_name

src/wakepy/__main__.py

@@ -43,9 +43,9 @@
 
 
 def main() -> None:
-    modename = parse_arguments(sys.argv[1:])
-    mode = Mode.from_name(modename, on_fail=handle_activation_error)
-    print(get_startup_text(mode=modename))
+    mode_name = parse_arguments(sys.argv[1:])
+    mode = Mode.from_name(mode_name, on_fail=handle_activation_error)
+    print(get_startup_text(mode=mode_name))
     with mode:
         if not mode.active:
             raise ModeExit
@@ -64,13 +64,13 @@ def _get_activation_error_text(result: ActivationResult) -> str:
     from wakepy import __version__
 
     error_text = f"""
-    Wakepy could not activate the "{result.modename}" mode. This might occur because of a bug or because your current platform is not yet supported or your system is missing required software.
+    Wakepy could not activate the "{result.mode_name}" mode. This might occur because of a bug or because your current platform is not yet supported or your system is missing required software.
 
     Check if there is already a related issue in the issue tracker at https://github.com/fohrloop/wakepy/issues/ and if not, please create a new one.
 
     Include the following:
     - wakepy version: {__version__}
-    - Mode: {result.modename}
+    - Mode: {result.mode_name}
     - Python version: {sys.version}
     - Operating system & version: [PLEASE FILL THIS]
     - Desktop Environment & version (if not default): [FILL OR REMOVE THIS LINE]

src/wakepy/core/activationresult.py

@@ -44,7 +44,7 @@ class ActivationResult:
     ----------
     results:
         The MethodActivationResults to be used to fill the ActivationResult
-    modename:
+    mode_name:
         Name of the Mode. Optional.
 
     """
@@ -54,9 +54,9 @@ class ActivationResult:
     # order the methods were tried (first = highest priority, last =
     # lowest priority)
 
-    modename: Optional[str] = None
+    mode_name: Optional[str] = None
     """Name of the :class:`Mode`. If the associated ``Mode`` does not have a
-    name, the ``modename`` will be ``None``."""
+    name, the ``mode_name`` will be ``None``."""
 
     active_method: str | None = field(init=False)
     """The name of the active (successful) :class`Method`. If no methods are
@@ -176,10 +176,10 @@ def get_failure_text(self) -> str:
         if self.success:
             return ""
         debug_info = str(self.query())
-        modename = self.modename or "[unnamed mode]"
+        mode_name = self.mode_name or "[unnamed mode]"
 
         return (
-            f'Could not activate Mode "{modename}"!\n\nMethod usage results, in '
+            f'Could not activate Mode "{mode_name}"!\n\nMethod usage results, in '
             f"order (highest priority first):\n{debug_info}"
         )
 

src/wakepy/core/method.py

@@ -62,10 +62,10 @@ class Method(ABC):
     is possible.
     """
 
-    modename: ModeName | str
+    mode_name: ModeName | str
     """The name of the mode which the Method implements. Each Method subclass
     implements a single mode, but multiple Methods may implement the same mode.
-    Setting ``Method.modename`` to `foo` on one or more ``Method`` subclasses
+    Setting ``Method.mode_name`` to `foo` on one or more ``Method`` subclasses
     defines the Mode `foo` (:class:`Mode` classes are themselves not defined or
     registered anywhere)"""
 

src/wakepy/core/mode.py

@@ -195,7 +195,7 @@ def __init__(
     @classmethod
     def from_name(
         cls,
-        modename: ModeName,
+        mode_name: ModeName,
         methods: Optional[StrCollection] = None,
         omit: Optional[StrCollection] = None,
         methods_priority: Optional[MethodsPriorityOrder] = None,
@@ -207,20 +207,20 @@ def from_name(
 
         Parameters
         ----------
-        modename: str
+        mode_name: str
             The name of the mode to create. Must be an existing Mode name;
             something that has used as Method.name attribute in a
             :class:`~wakepy.core.method.Method` subclass. Examples:
             "keep.running", "keep.presenting".
         methods: list, tuple or set of str
             The names of Methods to select from the mode defined with
-            `modename`; a "whitelist" filter. Means "use these and only these
+            `mode_name`; a "whitelist" filter. Means "use these and only these
             Methods". Any Methods in `methods` but not in the selected mode
             will raise a ValueError. Cannot be used same time with `omit`.
             Optional.
         omit: list, tuple or set of str or None
             The names of Methods to remove from the mode defined with
-            `modename`; a "blacklist" filter. Any Method in `omit` but not in
+            `mode_name`; a "blacklist" filter. Any Method in `omit` but not in
             the selected mode will be silently ignored. Cannot be used same
             time with `methods`. Optional.
         on_fail: "error" | "warn" | "pass" | Callable
@@ -248,10 +248,10 @@ def from_name(
             The context manager for the selected mode.
 
         """
-        methods_for_mode = get_methods_for_mode(modename)
+        methods_for_mode = get_methods_for_mode(mode_name)
         selected_methods = select_methods(methods_for_mode, use_only=methods, omit=omit)
         return cls(
-            name=modename,
+            name=mode_name,
             method_classes=selected_methods,
             methods_priority=methods_priority,
             on_fail=on_fail,
@@ -325,7 +325,7 @@ def _activate(self) -> ActivationResult:
             )
         )
 
-        self.activation_result = ActivationResult(methodresults, modename=self.name)
+        self.activation_result = ActivationResult(methodresults, mode_name=self.name)
         self.active = self.activation_result.success
         self._used_method = self._active_method
 

src/wakepy/core/registry.py

@@ -63,7 +63,7 @@ def register_method(method_class: Type[Method]) -> None:
 
     logging.debug("Registering Method %s (name: %s)", method_class, method_class.name)
 
-    method_dict: MethodDict = _method_registry.get(method_class.modename, dict())
+    method_dict: MethodDict = _method_registry.get(method_class.mode_name, dict())
 
     if method_class.name in method_dict:
         if method_dict[method_class.name] is not method_class:
@@ -80,11 +80,11 @@ def register_method(method_class: Type[Method]) -> None:
 
     # Register a new method class
     method_dict[method_class.name] = method_class
-    _method_registry.setdefault(method_class.modename, method_dict)
+    _method_registry.setdefault(method_class.mode_name, method_dict)
 
 
 def get_method(
-    method_name: str, mode: Optional[ModeNameValue | str] = None
+    method_name: str, mode_name: Optional[ModeNameValue | str] = None
 ) -> MethodCls:
     """Get a Method class based on its name and optionally the mode.
 
@@ -94,7 +94,7 @@ def get_method(
         The name of the wakepy.Method. The method must be registered which
         means that the module containing the subclass definition must have
         been imported.
-    mode: str | None
+    mode_name: str | None
         If the method_name is registered to methods belonging to multiple
         Modes, you must provide the mode name, to make the selection
         unambiguous. Typical mode names are "keep.running" and
@@ -115,8 +115,8 @@ def get_method(
         " the class is being imported."
     )
 
-    if mode is not None:
-        method_dict = _method_registry.get(mode, dict())
+    if mode_name is not None:
+        method_dict = _method_registry.get(mode_name, dict())
         if method_name not in method_dict:
             raise notfound
         return method_dict[method_name]
@@ -132,7 +132,7 @@ def get_method(
         raise notfound
     elif len(methods_from_all_modes) > 1:
         n = len(methods_from_all_modes)
-        modes = tuple(m.modename for m in methods_from_all_modes)
+        modes = tuple(m.mode_name for m in methods_from_all_modes)
         raise ValueError(
             f'Multiple ({n}) Methods with name "{method_name}" found! '
             f"The selection is unambiguous. Found modes: {modes}"
@@ -143,18 +143,20 @@ def get_method(
 
 @overload
 def get_methods(
-    names: List[str], mode: Optional[ModeName] = None
+    names: List[str], mode_name: Optional[ModeName] = None
 ) -> List[MethodCls]: ...
 @overload
 def get_methods(
-    names: Tuple[str, ...], mode: Optional[ModeName] = None
+    names: Tuple[str, ...], mode_name: Optional[ModeName] = None
 ) -> Tuple[MethodCls, ...]: ...
 @overload
-def get_methods(names: Set[str], mode: Optional[ModeName] = None) -> Set[MethodCls]: ...
+def get_methods(
+    names: Set[str], mode_name: Optional[ModeName] = None
+) -> Set[MethodCls]: ...
 
 
 def get_methods(
-    names: Collection[str], mode: Optional[ModeName] = None
+    names: Collection[str], mode_name: Optional[ModeName] = None
 ) -> Collection[MethodCls]:
     """Get a collection (list, tuple or set) of Method classes based on their
     names, and optionally the mode name.
@@ -165,7 +167,7 @@ def get_methods(
         The names of the wakepy.Methods to get. The methods must be registered
         which means that the modules containing the subclass definitions must
         have been imported.
-    mode: str | None
+    mode_name: str | None
         If a string, only gets methods for the given mode. If None, searches
         the methods from all the modes. In this case, each Method must be found
         only in one mode. Otherwise raises ValueError.
@@ -179,20 +181,20 @@ def get_methods(
     """
 
     if isinstance(names, list):
-        return [get_method(name, mode) for name in names]
+        return [get_method(name, mode_name) for name in names]
     elif isinstance(names, tuple):
-        return tuple(get_method(name, mode) for name in names)
+        return tuple(get_method(name, mode_name) for name in names)
     elif isinstance(names, set):
-        return set(get_method(name, mode) for name in names)
+        return set(get_method(name, mode_name) for name in names)
     else:
         raise TypeError("`names` must be a list, tuple or set")
 
 
 def get_methods_for_mode(
-    mode: ModeName | str,
+    mode_name: ModeName | str,
 ) -> List[MethodCls]:
-    """Get the Method classes belonging to a Mode; Methods with Method.modename
-     = `mode`.
+    """Get the Method classes belonging to a Mode; Methods with
+    Method.mode_name = `mode_name`.
 
     Parameters
     ----------
@@ -204,4 +206,4 @@ def get_methods_for_mode(
     methods: list[MethodCls]
         The Method classes for the Mode.
     """
-    return [m for m in _method_registry.get(mode, dict()).values()]
+    return [m for m in _method_registry.get(mode_name, dict()).values()]

src/wakepy/methods/_testing.py

@@ -15,7 +15,7 @@ class WakepyFakeSuccess(Method):
     """
 
     name = WAKEPY_FAKE_SUCCESS
-    modename = "_fake"
+    mode_name = "_fake"
     supported_platforms = (CURRENT_PLATFORM,)
 
     def enter_mode(self) -> None:

src/wakepy/methods/freedesktop.py

@@ -25,7 +25,7 @@ class FreedesktopScreenSaverInhibit(Method):
     """
 
     name = "org.freedesktop.ScreenSaver"
-    modename = ModeName.KEEP_PRESENTING
+    mode_name = ModeName.KEEP_PRESENTING
 
     screen_saver = DBusAddress(
         bus=BusType.SESSION,

src/wakepy/methods/gnome.py

@@ -99,11 +99,11 @@ def exit_mode(self) -> None:
 
 class GnomeSessionManagerNoSuspend(_GnomeSessionManager):
     name = "org.gnome.SessionManager"
-    modename = ModeName.KEEP_RUNNING
+    mode_name = ModeName.KEEP_RUNNING
     flags = GnomeFlag.INHIBIT_SUSPEND
 
 
 class GnomeSessionManagerNoIdle(_GnomeSessionManager):
     name = "org.gnome.SessionManager"
-    modename = ModeName.KEEP_PRESENTING
+    mode_name = ModeName.KEEP_PRESENTING
     flags = GnomeFlag.INHIBIT_IDLE

src/wakepy/methods/macos.py

@@ -43,13 +43,13 @@ def command(self) -> str: ...
 
 
 class CaffeinateKeepRunning(_MacCaffeinate):
-    modename = ModeName.KEEP_RUNNING
+    mode_name = ModeName.KEEP_RUNNING
     command = "caffeinate"
     name = "caffeinate"
 
 
 class CaffeinateKeepPresenting(_MacCaffeinate):
-    modename = ModeName.KEEP_PRESENTING
+    mode_name = ModeName.KEEP_PRESENTING
     # -d:  Create an assertion to prevent the display from sleeping.
     command = "caffeinate -d"
     name = "caffeinate"

src/wakepy/methods/windows.py

@@ -48,12 +48,12 @@ def flags(self) -> Flags: ...
 
 
 class WindowsKeepRunning(WindowsSetThreadExecutionState):
-    modename = ModeName.KEEP_RUNNING
+    mode_name = ModeName.KEEP_RUNNING
     flags = Flags.KEEP_RUNNING
     name = "SetThreadExecutionState"
 
 
 class WindowsKeepPresenting(WindowsSetThreadExecutionState):
-    modename = ModeName.KEEP_PRESENTING
+    mode_name = ModeName.KEEP_PRESENTING
     flags = Flags.KEEP_PRESENTING
     name = "SetThreadExecutionState"

tests/unit/test_core/conftest.py

@@ -69,26 +69,26 @@ def provide_methods_a_f(monkeypatch, testutils):
 
     class MethodA(TestMethod):
         name = "A"
-        modename = SECOND_MODE
+        mode_name = SECOND_MODE
 
     class MethodB(TestMethod):
         name = "B"
-        modename = FIRST_MODE
+        mode_name = FIRST_MODE
 
     class MethodC(TestMethod):
         name = "C"
 
     class MethodD(TestMethod):
         name = "D"
-        modename = FIRST_MODE
+        mode_name = FIRST_MODE
 
     class MethodE(TestMethod):
         name = "E"
-        modename = FIRST_MODE
+        mode_name = FIRST_MODE
 
     class MethodF(TestMethod):
         name = "F"
-        modename = SECOND_MODE
+        mode_name = SECOND_MODE
 
 
 @pytest.fixture

tests/unit/test_core/test_activationresult.py

@@ -301,7 +301,7 @@ def test_get_failure_text_failure(
         mr_requirements_fail: MethodActivationResult,
     ):
         ar = ActivationResult(
-            [mr_platform_support_fail, mr_requirements_fail], modename="SomeMode"
+            [mr_platform_support_fail, mr_requirements_fail], mode_name="SomeMode"
         )
         assert ar.get_failure_text() == (
             'Could not activate Mode "SomeMode"!\n\nMethod usage results, in order '
@@ -350,17 +350,17 @@ def test__eq__(
         self, method_activation_results: List[MethodActivationResult], request
     ):
         method_activation_results = request.getfixturevalue(method_activation_results)
-        ar1 = ActivationResult(method_activation_results, modename="foo")
-        ar2 = ActivationResult(method_activation_results, modename="foo")
+        ar1 = ActivationResult(method_activation_results, mode_name="foo")
+        ar2 = ActivationResult(method_activation_results, mode_name="foo")
 
         assert ar1 is not ar2
         assert ar1 == ar2
 
     def test__repr__(self, method_activation_results1: List[MethodActivationResult]):
-        ar1 = ActivationResult(method_activation_results1, modename="foo")
+        ar1 = ActivationResult(method_activation_results1, mode_name="foo")
         assert (
             ar1.__repr__()
-            == """ActivationResult(modename='foo', active_method='a-successful-method', success=True, real_success=True, failure=False, _method_results=[(FAIL @PLATFORM_SUPPORT, fail-platform, "Platform XYZ not supported!"), (FAIL @REQUIREMENTS, fail-requirements, "Missing requirement: Some SW v.1.2.3"), (SUCCESS, a-successful-method), (UNUSED, some-unused-method)])"""  # noqa: E501
+            == """ActivationResult(mode_name='foo', active_method='a-successful-method', success=True, real_success=True, failure=False, _method_results=[(FAIL @PLATFORM_SUPPORT, fail-platform, "Platform XYZ not supported!"), (FAIL @REQUIREMENTS, fail-requirements, "Missing requirement: Some SW v.1.2.3"), (SUCCESS, a-successful-method), (UNUSED, some-unused-method)])"""  # noqa: E501
         )
 
 

tests/unit/test_core/test_constants.py

@@ -6,7 +6,7 @@ def test_platformname(assert_strenum_values):
     assert_strenum_values(PlatformName, PlatformNameValue)
 
 
-def test_modename(assert_strenum_values):
+def test_mode_name(assert_strenum_values):
     assert_strenum_values(ModeName, ModeNameValue)