osn-selenium 1.0.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

osn_selenium/executors/trio_threads/cdp/target.py

@@ -1,156 +0,0 @@
-import trio
-from osn_selenium.base_mixin import TrioThreadMixin
-from typing import (
-	Any,
-	Callable,
-	Dict,
-	List,
-	Optional
-)
-from osn_selenium.executors.unified.cdp.target import (
-	UnifiedTargetCDPExecutor
-)
-from osn_selenium.abstract.executors.cdp.target import (
-	AbstractTargetCDPExecutor
-)
-
-
-__all__ = ["TargetCDPExecutor"]
-
-
-class TargetCDPExecutor(UnifiedTargetCDPExecutor, TrioThreadMixin, AbstractTargetCDPExecutor):
-	def __init__(
-			self,
-			execute_function: Callable[[str, Dict[str, Any]], Any],
-			lock: trio.Lock,
-			limiter: trio.CapacityLimiter
-	):
-		UnifiedTargetCDPExecutor.__init__(self, execute_function=execute_function)
-		
-		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
-	
-	async def activate_target(self, target_id: str) -> None:
-		return await self.sync_to_trio(sync_function=self._activate_target_impl)(target_id=target_id)
-	
-	async def attach_to_browser_target(self) -> str:
-		return await self.sync_to_trio(sync_function=self._attach_to_browser_target_impl)()
-	
-	async def attach_to_target(self, target_id: str, flatten: Optional[bool] = None) -> str:
-		return await self.sync_to_trio(sync_function=self._attach_to_target_impl)(target_id=target_id, flatten=flatten)
-	
-	async def auto_attach_related(
-			self,
-			target_id: str,
-			wait_for_debugger_on_start: bool,
-			filter_: Optional[List[Dict[str, Any]]] = None
-	) -> None:
-		return await self.sync_to_trio(sync_function=self._auto_attach_related_impl)(
-				target_id=target_id,
-				wait_for_debugger_on_start=wait_for_debugger_on_start,
-				filter_=filter_
-		)
-	
-	async def close_target(self, target_id: str) -> bool:
-		return await self.sync_to_trio(sync_function=self._close_target_impl)(target_id=target_id)
-	
-	async def create_browser_context(
-			self,
-			dispose_on_detach: Optional[bool] = None,
-			proxy_server: Optional[str] = None,
-			proxy_bypass_list: Optional[str] = None,
-			origins_with_universal_network_access: Optional[List[str]] = None
-	) -> str:
-		return await self.sync_to_trio(sync_function=self._create_browser_context_impl)(
-				dispose_on_detach=dispose_on_detach,
-				proxy_server=proxy_server,
-				proxy_bypass_list=proxy_bypass_list,
-				origins_with_universal_network_access=origins_with_universal_network_access
-		)
-	
-	async def create_target(
-			self,
-			url: str,
-			left: Optional[int] = None,
-			top: Optional[int] = None,
-			width: Optional[int] = None,
-			height: Optional[int] = None,
-			window_state: Optional[str] = None,
-			browser_context_id: Optional[str] = None,
-			enable_begin_frame_control: Optional[bool] = None,
-			new_window: Optional[bool] = None,
-			background: Optional[bool] = None,
-			for_tab: Optional[bool] = None,
-			hidden: Optional[bool] = None
-	) -> str:
-		return await self.sync_to_trio(sync_function=self._create_target_impl)(
-				url=url,
-				left=left,
-				top=top,
-				width=width,
-				height=height,
-				window_state=window_state,
-				browser_context_id=browser_context_id,
-				enable_begin_frame_control=enable_begin_frame_control,
-				new_window=new_window,
-				background=background,
-				for_tab=for_tab,
-				hidden=hidden
-		)
-	
-	async def detach_from_target(self, session_id: Optional[str] = None, target_id: Optional[str] = None) -> None:
-		return await self.sync_to_trio(sync_function=self._detach_from_target_impl)(session_id=session_id, target_id=target_id)
-	
-	async def dispose_browser_context(self, browser_context_id: str) -> None:
-		return await self.sync_to_trio(sync_function=self._dispose_browser_context_impl)(browser_context_id=browser_context_id)
-	
-	async def expose_dev_tools_protocol(
-			self,
-			target_id: str,
-			binding_name: Optional[str] = None,
-			inherit_permissions: Optional[bool] = None
-	) -> None:
-		return await self.sync_to_trio(sync_function=self._expose_dev_tools_protocol_impl)(
-				target_id=target_id,
-				binding_name=binding_name,
-				inherit_permissions=inherit_permissions
-		)
-	
-	async def get_browser_contexts(self) -> List[str]:
-		return await self.sync_to_trio(sync_function=self._get_browser_contexts_impl)()
-	
-	async def get_target_info(self, target_id: Optional[str] = None) -> Dict[str, Any]:
-		return await self.sync_to_trio(sync_function=self._get_target_info_impl)(target_id=target_id)
-	
-	async def get_targets(self, filter_: Optional[List[Dict[str, Any]]] = None) -> List[Dict[str, Any]]:
-		return await self.sync_to_trio(sync_function=self._get_targets_impl)(filter_=filter_)
-	
-	async def open_dev_tools(self, target_id: str) -> str:
-		return await self.sync_to_trio(sync_function=self._open_dev_tools_impl)(target_id=target_id)
-	
-	async def send_message_to_target(
-			self,
-			message: str,
-			session_id: Optional[str] = None,
-			target_id: Optional[str] = None
-	) -> None:
-		return await self.sync_to_trio(sync_function=self._send_message_to_target_impl)(message=message, session_id=session_id, target_id=target_id)
-	
-	async def set_auto_attach(
-			self,
-			auto_attach: bool,
-			wait_for_debugger_on_start: bool,
-			flatten: Optional[bool] = None,
-			filter_: Optional[List[Dict[str, Any]]] = None
-	) -> None:
-		return await self.sync_to_trio(sync_function=self._set_auto_attach_impl)(
-				auto_attach=auto_attach,
-				wait_for_debugger_on_start=wait_for_debugger_on_start,
-				flatten=flatten,
-				filter_=filter_
-		)
-	
-	async def set_discover_targets(self, discover: bool, filter_: Optional[List[Dict[str, Any]]] = None) -> None:
-		return await self.sync_to_trio(sync_function=self._set_discover_targets_impl)(discover=discover, filter_=filter_)
-	
-	async def set_remote_locations(self, locations: List[Dict[str, Any]]) -> None:
-		return await self.sync_to_trio(sync_function=self._set_remote_locations_impl)(locations=locations)

osn_selenium/executors/trio_threads/cdp/tethering.py

@@ -1,34 +0,0 @@
-import trio
-from typing import Any, Callable, Dict
-from osn_selenium.base_mixin import TrioThreadMixin
-from osn_selenium.executors.unified.cdp.tethering import (
-	UnifiedTetheringCDPExecutor
-)
-from osn_selenium.abstract.executors.cdp.tethering import (
-	AbstractTetheringCDPExecutor
-)
-
-
-__all__ = ["TetheringCDPExecutor"]
-
-
-class TetheringCDPExecutor(
-		UnifiedTetheringCDPExecutor,
-		TrioThreadMixin,
-		AbstractTetheringCDPExecutor
-):
-	def __init__(
-			self,
-			execute_function: Callable[[str, Dict[str, Any]], Any],
-			lock: trio.Lock,
-			limiter: trio.CapacityLimiter
-	):
-		UnifiedTetheringCDPExecutor.__init__(self, execute_function=execute_function)
-		
-		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
-	
-	async def bind(self, port: int) -> None:
-		return await self.sync_to_trio(sync_function=self._bind_impl)(port=port)
-	
-	async def unbind(self, port: int) -> None:
-		return await self.sync_to_trio(sync_function=self._unbind_impl)(port=port)

osn_selenium/executors/trio_threads/cdp/tracing.py

@@ -1,71 +0,0 @@
-import trio
-from osn_selenium.base_mixin import TrioThreadMixin
-from typing import (
-	Any,
-	Callable,
-	Dict,
-	List,
-	Optional,
-	Tuple
-)
-from osn_selenium.executors.unified.cdp.tracing import (
-	UnifiedTracingCDPExecutor
-)
-from osn_selenium.abstract.executors.cdp.tracing import (
-	AbstractTracingCDPExecutor
-)
-
-
-__all__ = ["TracingCDPExecutor"]
-
-
-class TracingCDPExecutor(UnifiedTracingCDPExecutor, TrioThreadMixin, AbstractTracingCDPExecutor):
-	def __init__(
-			self,
-			execute_function: Callable[[str, Dict[str, Any]], Any],
-			lock: trio.Lock,
-			limiter: trio.CapacityLimiter
-	):
-		UnifiedTracingCDPExecutor.__init__(self, execute_function=execute_function)
-		
-		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
-	
-	async def end(self) -> None:
-		return await self.sync_to_trio(sync_function=self._end_impl)()
-	
-	async def get_categories(self) -> List[str]:
-		return await self.sync_to_trio(sync_function=self._get_categories_impl)()
-	
-	async def record_clock_sync_marker(self, sync_id: str) -> None:
-		return await self.sync_to_trio(sync_function=self._record_clock_sync_marker_impl)(sync_id=sync_id)
-	
-	async def request_memory_dump(
-			self,
-			deterministic: Optional[bool] = None,
-			level_of_detail: Optional[str] = None
-	) -> Tuple[str, bool]:
-		return await self.sync_to_trio(sync_function=self._request_memory_dump_impl)(deterministic=deterministic, level_of_detail=level_of_detail)
-	
-	async def start(
-			self,
-			categories: Optional[str] = None,
-			options: Optional[str] = None,
-			buffer_usage_reporting_interval: Optional[float] = None,
-			transfer_mode: Optional[str] = None,
-			stream_format: Optional[str] = None,
-			stream_compression: Optional[str] = None,
-			trace_config: Optional[Dict[str, Any]] = None,
-			perfetto_config: Optional[str] = None,
-			tracing_backend: Optional[str] = None
-	) -> None:
-		return await self.sync_to_trio(sync_function=self._start_impl)(
-				categories=categories,
-				options=options,
-				buffer_usage_reporting_interval=buffer_usage_reporting_interval,
-				transfer_mode=transfer_mode,
-				stream_format=stream_format,
-				stream_compression=stream_compression,
-				trace_config=trace_config,
-				perfetto_config=perfetto_config,
-				tracing_backend=tracing_backend
-		)

osn_selenium/executors/trio_threads/cdp/web_audio.py

@@ -1,37 +0,0 @@
-import trio
-from typing import Any, Callable, Dict
-from osn_selenium.base_mixin import TrioThreadMixin
-from osn_selenium.executors.unified.cdp.web_audio import (
-	UnifiedWebAudioCDPExecutor
-)
-from osn_selenium.abstract.executors.cdp.web_audio import (
-	AbstractWebAudioCDPExecutor
-)
-
-
-__all__ = ["WebAudioCDPExecutor"]
-
-
-class WebAudioCDPExecutor(
-		UnifiedWebAudioCDPExecutor,
-		TrioThreadMixin,
-		AbstractWebAudioCDPExecutor
-):
-	def __init__(
-			self,
-			execute_function: Callable[[str, Dict[str, Any]], Any],
-			lock: trio.Lock,
-			limiter: trio.CapacityLimiter
-	):
-		UnifiedWebAudioCDPExecutor.__init__(self, execute_function=execute_function)
-		
-		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
-	
-	async def disable(self) -> None:
-		return await self.sync_to_trio(sync_function=self._disable_impl)()
-	
-	async def enable(self) -> None:
-		return await self.sync_to_trio(sync_function=self._enable_impl)()
-	
-	async def get_realtime_data(self, context_id: str) -> Dict[str, Any]:
-		return await self.sync_to_trio(sync_function=self._get_realtime_data_impl)(context_id=context_id)

osn_selenium/executors/trio_threads/cdp/web_authn.py

@@ -1,95 +0,0 @@
-import trio
-from osn_selenium.base_mixin import TrioThreadMixin
-from typing import (
-	Any,
-	Callable,
-	Dict,
-	List,
-	Optional
-)
-from osn_selenium.executors.unified.cdp.web_authn import (
-	UnifiedWebAuthnCDPExecutor
-)
-from osn_selenium.abstract.executors.cdp.web_authn import (
-	AbstractWebAuthnCDPExecutor
-)
-
-
-__all__ = ["WebAuthnCDPExecutor"]
-
-
-class WebAuthnCDPExecutor(
-		UnifiedWebAuthnCDPExecutor,
-		TrioThreadMixin,
-		AbstractWebAuthnCDPExecutor
-):
-	def __init__(
-			self,
-			execute_function: Callable[[str, Dict[str, Any]], Any],
-			lock: trio.Lock,
-			limiter: trio.CapacityLimiter
-	):
-		UnifiedWebAuthnCDPExecutor.__init__(self, execute_function=execute_function)
-		
-		TrioThreadMixin.__init__(self, lock=lock, limiter=limiter)
-	
-	async def add_credential(self, authenticator_id: str, credential: Dict[str, Any]) -> None:
-		return await self.sync_to_trio(sync_function=self._add_credential_impl)(authenticator_id=authenticator_id, credential=credential)
-	
-	async def add_virtual_authenticator(self, options: Dict[str, Any]) -> str:
-		return await self.sync_to_trio(sync_function=self._add_virtual_authenticator_impl)(options=options)
-	
-	async def clear_credentials(self, authenticator_id: str) -> None:
-		return await self.sync_to_trio(sync_function=self._clear_credentials_impl)(authenticator_id=authenticator_id)
-	
-	async def disable(self) -> None:
-		return await self.sync_to_trio(sync_function=self._disable_impl)()
-	
-	async def enable(self, enable_ui: Optional[bool] = None) -> None:
-		return await self.sync_to_trio(sync_function=self._enable_impl)(enable_ui=enable_ui)
-	
-	async def get_credential(self, authenticator_id: str, credential_id: str) -> Dict[str, Any]:
-		return await self.sync_to_trio(sync_function=self._get_credential_impl)(authenticator_id=authenticator_id, credential_id=credential_id)
-	
-	async def get_credentials(self, authenticator_id: str) -> List[Dict[str, Any]]:
-		return await self.sync_to_trio(sync_function=self._get_credentials_impl)(authenticator_id=authenticator_id)
-	
-	async def remove_credential(self, authenticator_id: str, credential_id: str) -> None:
-		return await self.sync_to_trio(sync_function=self._remove_credential_impl)(authenticator_id=authenticator_id, credential_id=credential_id)
-	
-	async def remove_virtual_authenticator(self, authenticator_id: str) -> None:
-		return await self.sync_to_trio(sync_function=self._remove_virtual_authenticator_impl)(authenticator_id=authenticator_id)
-	
-	async def set_automatic_presence_simulation(self, authenticator_id: str, enabled: bool) -> None:
-		return await self.sync_to_trio(sync_function=self._set_automatic_presence_simulation_impl)(authenticator_id=authenticator_id, enabled=enabled)
-	
-	async def set_credential_properties(
-			self,
-			authenticator_id: str,
-			credential_id: str,
-			backup_eligibility: Optional[bool] = None,
-			backup_state: Optional[bool] = None
-	) -> None:
-		return await self.sync_to_trio(sync_function=self._set_credential_properties_impl)(
-				authenticator_id=authenticator_id,
-				credential_id=credential_id,
-				backup_eligibility=backup_eligibility,
-				backup_state=backup_state
-		)
-	
-	async def set_response_override_bits(
-			self,
-			authenticator_id: str,
-			is_bogus_signature: Optional[bool] = None,
-			is_bad_uv: Optional[bool] = None,
-			is_bad_up: Optional[bool] = None
-	) -> None:
-		return await self.sync_to_trio(sync_function=self._set_response_override_bits_impl)(
-				authenticator_id=authenticator_id,
-				is_bogus_signature=is_bogus_signature,
-				is_bad_uv=is_bad_uv,
-				is_bad_up=is_bad_up
-		)
-	
-	async def set_user_verified(self, authenticator_id: str, is_user_verified: bool) -> None:
-		return await self.sync_to_trio(sync_function=self._set_user_verified_impl)(authenticator_id=authenticator_id, is_user_verified=is_user_verified)

osn_selenium/executors/unified/cdp/accessibility.py

@@ -1,81 +0,0 @@
-from typing import (
-	Any,
-	Callable,
-	Dict,
-	List,
-	Optional
-)
-
-
-__all__ = ["UnifiedAccessibilityCDPExecutor"]
-
-
-class UnifiedAccessibilityCDPExecutor:
-	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
-		self._execute_function = execute_function
-	
-	def _disable_impl(self) -> None:
-		return self._execute_function("Accessibility.disable", {})
-	
-	def _enable_impl(self) -> None:
-		return self._execute_function("Accessibility.enable", {})
-	
-	def _get_ax_node_and_ancestors_impl(
-			self,
-			node_id: Optional[int] = None,
-			backend_node_id: Optional[int] = None,
-			object_id: Optional[str] = None
-	) -> List[Dict[str, Any]]:
-		return self._execute_function(
-				"Accessibility.getAXNodeAndAncestors",
-				{
-					"node_id": node_id,
-					"backend_node_id": backend_node_id,
-					"object_id": object_id
-				}
-		)
-	
-	def _get_child_ax_nodes_impl(self, id_: str, frame_id: Optional[str] = None) -> List[Dict[str, Any]]:
-		return self._execute_function("Accessibility.getChildAXNodes", {"id_": id_, "frame_id": frame_id})
-	
-	def _get_full_ax_tree_impl(self, depth: Optional[int] = None, frame_id: Optional[str] = None) -> List[Dict[str, Any]]:
-		return self._execute_function("Accessibility.getFullAXTree", {"depth": depth, "frame_id": frame_id})
-	
-	def _get_partial_ax_tree_impl(
-			self,
-			node_id: Optional[int] = None,
-			backend_node_id: Optional[int] = None,
-			object_id: Optional[str] = None,
-			fetch_relatives: Optional[bool] = None
-	) -> List[Dict[str, Any]]:
-		return self._execute_function(
-				"Accessibility.getPartialAXTree",
-				{
-					"node_id": node_id,
-					"backend_node_id": backend_node_id,
-					"object_id": object_id,
-					"fetch_relatives": fetch_relatives
-				}
-		)
-	
-	def _get_root_ax_node_impl(self, frame_id: Optional[str] = None) -> Dict[str, Any]:
-		return self._execute_function("Accessibility.getRootAXNode", {"frame_id": frame_id})
-	
-	def _query_ax_tree_impl(
-			self,
-			node_id: Optional[int] = None,
-			backend_node_id: Optional[int] = None,
-			object_id: Optional[str] = None,
-			accessible_name: Optional[str] = None,
-			role: Optional[str] = None
-	) -> List[Dict[str, Any]]:
-		return self._execute_function(
-				"Accessibility.queryAXTree",
-				{
-					"node_id": node_id,
-					"backend_node_id": backend_node_id,
-					"object_id": object_id,
-					"accessible_name": accessible_name,
-					"role": role
-				}
-		)

osn_selenium/executors/unified/cdp/animation.py

@@ -1,50 +0,0 @@
-from typing import (
-	Any,
-	Callable,
-	Dict,
-	List
-)
-
-
-__all__ = ["UnifiedAnimationCDPExecutor"]
-
-
-class UnifiedAnimationCDPExecutor:
-	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
-		self._execute_function = execute_function
-	
-	def _disable_impl(self) -> None:
-		return self._execute_function("Animation.disable", {})
-	
-	def _enable_impl(self) -> None:
-		return self._execute_function("Animation.enable", {})
-	
-	def _get_current_time_impl(self, id_: str) -> float:
-		return self._execute_function("Animation.getCurrentTime", {"id_": id_})
-	
-	def _get_playback_rate_impl(self) -> float:
-		return self._execute_function("Animation.getPlaybackRate", {})
-	
-	def _release_animations_impl(self, animations: List[str]) -> None:
-		return self._execute_function("Animation.releaseAnimations", {"animations": animations})
-	
-	def _resolve_animation_impl(self, animation_id: str) -> Dict[str, Any]:
-		return self._execute_function("Animation.resolveAnimation", {"animation_id": animation_id})
-	
-	def _seek_animations_impl(self, animations: List[str], current_time: float) -> None:
-		return self._execute_function(
-				"Animation.seekAnimations",
-				{"animations": animations, "current_time": current_time}
-		)
-	
-	def _set_paused_impl(self, animations: List[str], paused: bool) -> None:
-		return self._execute_function("Animation.setPaused", {"animations": animations, "paused": paused})
-	
-	def _set_playback_rate_impl(self, playback_rate: float) -> None:
-		return self._execute_function("Animation.setPlaybackRate", {"playback_rate": playback_rate})
-	
-	def _set_timing_impl(self, animation_id: str, duration: float, delay: float) -> None:
-		return self._execute_function(
-				"Animation.setTiming",
-				{"animation_id": animation_id, "duration": duration, "delay": delay}
-		)

osn_selenium/executors/unified/cdp/audits.py

@@ -1,45 +0,0 @@
-from typing import (
-	Any,
-	Callable,
-	Dict,
-	List,
-	Optional,
-	Tuple
-)
-
-
-__all__ = ["UnifiedAuditsCDPExecutor"]
-
-
-class UnifiedAuditsCDPExecutor:
-	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
-		self._execute_function = execute_function
-	
-	def _check_contrast_impl(self, report_aaa: Optional[bool] = None) -> None:
-		return self._execute_function("Audits.checkContrast", {"report_aaa": report_aaa})
-	
-	def _check_forms_issues_impl(self) -> List[Dict[str, Any]]:
-		return self._execute_function("Audits.checkFormsIssues", {})
-	
-	def _disable_impl(self) -> None:
-		return self._execute_function("Audits.disable", {})
-	
-	def _enable_impl(self) -> None:
-		return self._execute_function("Audits.enable", {})
-	
-	def _get_encoded_response_impl(
-			self,
-			request_id: str,
-			encoding: str,
-			quality: Optional[float] = None,
-			size_only: Optional[bool] = None
-	) -> Tuple[Optional[str], int, int]:
-		return self._execute_function(
-				"Audits.getEncodedResponse",
-				{
-					"request_id": request_id,
-					"encoding": encoding,
-					"quality": quality,
-					"size_only": size_only
-				}
-		)

osn_selenium/executors/unified/cdp/autofill.py

@@ -1,41 +0,0 @@
-from typing import (
-	Any,
-	Callable,
-	Dict,
-	List,
-	Optional
-)
-
-
-__all__ = ["UnifiedAutofillCDPExecutor"]
-
-
-class UnifiedAutofillCDPExecutor:
-	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
-		self._execute_function = execute_function
-	
-	def _disable_impl(self) -> None:
-		return self._execute_function("Autofill.disable", {})
-	
-	def _enable_impl(self) -> None:
-		return self._execute_function("Autofill.enable", {})
-	
-	def _set_addresses_impl(self, addresses: List[Dict[str, Any]]) -> None:
-		return self._execute_function("Autofill.setAddresses", {"addresses": addresses})
-	
-	def _trigger_impl(
-			self,
-			field_id: int,
-			frame_id: Optional[str] = None,
-			card: Optional[Dict[str, Any]] = None,
-			address: Optional[Dict[str, Any]] = None
-	) -> None:
-		return self._execute_function(
-				"Autofill.trigger",
-				{
-					"field_id": field_id,
-					"frame_id": frame_id,
-					"card": card,
-					"address": address
-				}
-		)

osn_selenium/executors/unified/cdp/background_service.py

@@ -1,24 +0,0 @@
-from typing import Any, Callable, Dict
-
-
-__all__ = ["UnifiedBackgroundServiceCDPExecutor"]
-
-
-class UnifiedBackgroundServiceCDPExecutor:
-	def __init__(self, execute_function: Callable[[str, Dict[str, Any]], Any]):
-		self._execute_function = execute_function
-	
-	def _clear_events_impl(self, service: str) -> None:
-		return self._execute_function("BackgroundService.clearEvents", {"service": service})
-	
-	def _set_recording_impl(self, should_record: bool, service: str) -> None:
-		return self._execute_function(
-				"BackgroundService.setRecording",
-				{"should_record": should_record, "service": service}
-		)
-	
-	def _start_observing_impl(self, service: str) -> None:
-		return self._execute_function("BackgroundService.startObserving", {"service": service})
-	
-	def _stop_observing_impl(self, service: str) -> None:
-		return self._execute_function("BackgroundService.stopObserving", {"service": service})