switcher-client 0.1.2__py3-none-any.whl

switcher_client/lib/utils/timed_match/worker.py

@@ -0,0 +1,100 @@
+import re
+import multiprocessing
+
+from enum import Enum
+from typing import List, Optional
+from dataclasses import dataclass
+
+class TaskType(Enum):
+    """Types of tasks that can be sent to the worker process."""
+    MATCH = "match"
+    SHUTDOWN = "shutdown"
+
+@dataclass
+class WorkerTask:
+    """Task sent to the worker process."""
+    task_type: TaskType
+    patterns: Optional[List[str]] = None
+    input_value: Optional[str] = None
+    use_fullmatch: Optional[bool] = None
+    task_id: Optional[str] = None
+
+@dataclass
+class WorkerResult:
+    """Result returned from the worker process."""
+    success: bool
+    result: Optional[bool] = None
+    task_id: Optional[str] = None
+    error: Optional[str] = None
+
+def persistent_regex_worker(task_queue: multiprocessing.Queue, result_queue: multiprocessing.Queue):
+    """
+    Persistent worker function that processes regex matching tasks in a loop.
+
+    This worker runs continuously, processing tasks from the task queue until
+    it receives a shutdown signal or encounters an error.
+
+    Args:
+        task_queue: Queue to receive WorkerTask objects
+        result_queue: Queue to send WorkerResult objects back to main process
+    """
+    try:
+        while True:
+            try:
+                task = task_queue.get(timeout=30.0)
+
+                if task.task_type == TaskType.SHUTDOWN:
+                    result_queue.put(WorkerResult(success=True, task_id=task.task_id))
+                    break
+                if task.task_type == TaskType.MATCH:
+                    result = _process_match_task(task)
+                    result_queue.put(result)
+
+            except Exception:  # pylint: disable=broad-exception-caught
+                # Timeout or other error getting task, continue
+                continue
+
+    except Exception:  # pylint: disable=broad-exception-caught
+        # Worker process error, exit
+        result_queue.put(WorkerResult(success=False, error="Worker process error"))
+
+def _process_match_task(task: WorkerTask) -> WorkerResult:
+    """
+    Process a regex matching task.
+
+    Args:
+        task: WorkerTask containing the matching parameters
+
+    Returns:
+        WorkerResult with the matching result
+    """
+    try:
+        if not task.patterns or not task.input_value:
+            return WorkerResult(
+                success=False,
+                error="Invalid task parameters",
+                task_id=task.task_id
+            )
+
+        match_result = False
+        for pattern in task.patterns:
+            if task.use_fullmatch:
+                if re.fullmatch(pattern, task.input_value):
+                    match_result = True
+                    break
+            else:
+                if re.search(pattern, task.input_value):
+                    match_result = True
+                    break
+
+        return WorkerResult(
+            success=True,
+            result=match_result,
+            task_id=task.task_id
+        )
+    except Exception as e:  # pylint: disable=broad-exception-caught
+        return WorkerResult(
+            success=False,
+            error=str(e),
+            task_id=task.task_id
+        )

switcher_client/switcher.py

@@ -0,0 +1,188 @@
+from concurrent.futures import ThreadPoolExecutor
+from datetime import datetime
+from typing import Optional
+
+from switcher_client.lib.globals.global_context import Context
+from switcher_client.lib.globals.global_snapshot import GlobalSnapshot
+from switcher_client.lib.remote_auth import RemoteAuth
+from switcher_client.lib.globals import GlobalAuth
+from switcher_client.lib.remote import Remote
+from switcher_client.lib.resolver import Resolver
+from switcher_client.lib.types import ResultDetail
+from switcher_client.lib.utils.execution_logger import ExecutionLogger
+from switcher_client.switcher_data import SwitcherData
+
+class Switcher(SwitcherData):
+    """
+    Switcher handles criteria execution and validations.
+
+    The class provides methods to execute criteria with both boolean and detailed results,
+    and supports both synchronous and asynchronous execution modes.
+
+        Example usage:
+            switcher = Client.get_switcher('FEATURE_LOGIN_V2')
+            switcher.is_on()              # returns boolean result
+            switcher.is_on_with_details() # returns detailed result
+
+    """
+    def __init__(self, context: Context, key: Optional[str] = None):
+        super().__init__(context, key)
+        self._context = context
+        self._show_details: bool = False
+        self._next_refresh_time: int = 0
+        self._init_worker(context)
+        self._validate_args(key)
+
+    def _init_worker(self, context: Context):
+        self._background_executor = ThreadPoolExecutor(
+            max_workers=context.options.throttle_max_workers,
+            thread_name_prefix="SwitcherBackgroundRefresh"
+        )
+
+    def prepare(self, key: Optional[str] = None):
+        """ Checks API credentials and connectivity """
+        self._validate_args(key)
+
+        if not self._context.options.local or self._force_remote:
+            RemoteAuth.auth()
+
+    def is_on(self, key: Optional[str] = None) -> bool:
+        """ Execute criteria """
+        self._show_details = False
+        self._validate_args(key, details=False)
+
+        # try get cached result
+        cached_result = self._try_cached_result()
+        if cached_result is not None:
+            return cached_result.result
+
+        return self._submit().result
+
+    def is_on_with_details(self, key: Optional[str] = None) -> ResultDetail:
+        """ Execute criteria with details """
+        self._validate_args(key, details=True)
+
+        # try get cached result
+        cached_result = self._try_cached_result()
+        if cached_result is not None:
+            return cached_result
+
+        return self._submit()
+
+    def schedule_background_refresh(self):
+        """ Schedules background refresh of the last criteria request """
+        now = int(datetime.now().timestamp() * 1000)
+
+        if now > self._next_refresh_time:
+            self._next_refresh_time = now + self._throttle_period
+            self._background_executor.submit(self._submit)
+
+    def _submit(self) -> ResultDetail:
+        """ Submit criteria for execution (local or remote) """
+        # verify if query from snapshot
+        if (self._context.options.local and not self._force_remote):
+            return self._execute_local_criteria()
+
+        try:
+            self.validate()
+            if GlobalAuth.get_token() == 'SILENT':
+                return self._execute_local_criteria()
+
+            return self._execute_remote_criteria()
+        except Exception as e:
+            self._notify_error(e)
+
+            if self._context.options.silent_mode:
+                RemoteAuth.update_silent_token()
+                return self._execute_local_criteria()
+
+            raise e
+
+    def validate(self) -> 'Switcher':
+        """ Validates client settings for remote API calls """
+        errors = []
+
+        RemoteAuth.is_valid()
+
+        if not self._key:
+            errors.append('Missing key field')
+
+        self._execute_api_checks()
+        if not GlobalAuth.get_token():
+            errors.append('Missing token field')
+
+        if errors:
+            raise ValueError(f"Something went wrong: {', '.join(errors)}")
+
+        return self
+
+    def _validate_args(self, key: Optional[str] = None, details: Optional[bool] = None):
+        if key is not None:
+            self._key = key
+
+        if details is not None:
+            self._show_details = details
+
+    def _execute_api_checks(self):
+        """ Assure API is available and token is valid """
+        RemoteAuth.check_health()
+        if RemoteAuth.is_token_expired():
+            self.prepare(self._key)
+
+    def _try_cached_result(self) -> Optional[ResultDetail]:
+        """ Try get cached result if throttle is enabled and criteria was recently executed """
+        if self._has_throttle():
+            if not self._context.options.freeze:
+                self.schedule_background_refresh()
+
+            cached_result_logger = ExecutionLogger.get_execution(self._key, self._input)
+            if cached_result_logger.key is not None:
+                return cached_result_logger.response
+
+        return None
+
+    def _notify_error(self, error: Exception):
+        """ Notify asynchronous error to the subscribed callback """
+        callback = ExecutionLogger.callback_error()
+        if callback:
+            callback(error)
+
+    def _execute_remote_criteria(self):
+        """ Execute remote criteria """
+        try:
+            token = GlobalAuth.get_token()
+            response = Remote.check_criteria(token, self._context, self)
+
+            if self._can_log():
+                ExecutionLogger.add(response, self._key, self._input)
+
+            return response
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            return self._get_default_result_or_raise(e)
+
+    def _execute_local_criteria(self):
+        """ Execute local criteria """
+        try:
+            response = Resolver.check_criteria(GlobalSnapshot.snapshot(), self)
+            if self._can_log():
+                ExecutionLogger.add(response, self._key, self._input)
+
+            return response
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            return self._get_default_result_or_raise(e)
+
+    def _can_log(self) -> bool:
+        """ Check if logging is enabled """
+        return self._context.options.logger and self._key is not None
+
+    def _has_throttle(self) -> bool:
+        """ Check if throttle is enabled and criteria was recently executed """
+        return self._throttle_period != 0
+
+    def _get_default_result_or_raise(self, e) -> ResultDetail:
+        """ Get default result if set, otherwise raise the error """
+        if self._default_result is None:
+            raise e
+
+        self._notify_error(e)
+        return ResultDetail.create(result=self._default_result, reason="Default result")

switcher_client/switcher_data.py

@@ -0,0 +1,112 @@
+# pylint: disable=redefined-builtin
+import json
+
+from dataclasses import dataclass
+from datetime import datetime
+from abc import ABCMeta
+from typing import Optional, Union
+
+from switcher_client.lib.compat import Self
+from switcher_client.lib.utils import get
+from switcher_client.lib.globals.global_context import Context
+from switcher_client.lib.snapshot import StrategiesType
+
+@dataclass
+class SwitcherData(metaclass=ABCMeta):
+    """
+    SwitcherData holds the data for a switcher execution.
+    It is used by the Switcher class to execute criteria and return results.
+    """
+
+    # pylint: disable=too-many-instance-attributes
+    def __init__(self, context: Context,key: Optional[str] = None):
+        self._context = context
+        self._key = key
+        self._input = []
+        self._show_details = False
+        self._throttle_period = 0
+        self._next_refresh_time = 0 # timestamp
+        self._default_result = None
+        self._force_remote = False
+        self._restrict_relay = True
+
+    def check(self, strategy_type: str, input: str)-> Self:
+        """ Adds a strategy for validation """
+        self._input = [item for item in self._input if item[0] != strategy_type]
+        self._input.append([strategy_type, input])
+        return self
+
+    def check_value(self, input: str) -> Self:
+        """ Adds VALUE_VALIDATION input for strategy validation """
+        return self.check(StrategiesType.VALUE.value, input)
+
+    def check_network(self, input: str) -> Self:
+        """ Adds NETWORK_VALIDATION input for strategy validation """
+        return self.check(StrategiesType.NETWORK.value, input)
+
+    def check_regex(self, input: str) -> Self:
+        """ Adds REGEX_VALIDATION input for strategy validation """
+        return self.check(StrategiesType.REGEX.value, input)
+
+    def check_payload(self, input: Union[str, dict]) -> Self:
+        """ Adds PAYLOAD_VALIDATION input for strategy validation """
+        if isinstance(input, dict):
+            payload_str = json.dumps(input)
+        else:
+            payload_str = input
+
+        return self.check(StrategiesType.PAYLOAD.value, payload_str)
+
+    def throttle(self, period: int) -> Self:
+        """ Sets throttle period in milliseconds """
+        self._throttle_period = period
+
+        if self._next_refresh_time == 0:
+            self._next_refresh_time = int(datetime.now().timestamp() * 1000) + period
+
+        if self._throttle_period > 0:
+            self._context.options.logger = True
+
+        return self
+
+    def remote(self, force_remote: bool = True) -> Self:
+        """ Force the use of the remote API when local is enabled """
+        if not self._context.options.local:
+            raise ValueError("Local mode is not enabled")
+
+        self._force_remote = force_remote
+        return self
+
+    def default_result(self, result: bool) -> Self:
+        """ Sets the default result for the switcher """
+        self._default_result = result
+        return self
+
+    def restrict_relay(self, restrict: bool = True) -> Self:
+        """ Allow local snapshots to ignore or require Relay verification """
+        self._restrict_relay = restrict
+        return self
+
+    def reset_inputs(self) -> Self:
+        """ Resets all strategy inputs """
+        self._input = []
+        return self
+
+    @property
+    def inputs(self) -> list[list[str]]:
+        """ Gets all strategy inputs """
+        return self._input
+
+    @property
+    def key(self) -> str:
+        """ Gets the switcher key """
+        return get(self._key, '')
+
+    @property
+    def show_details(self) -> bool:
+        """ Gets the show_details setting """
+        return self._show_details
+
+    def is_restrict_relay(self) -> bool:
+        """ Gets the restrict_relay setting """
+        return self._restrict_relay

switcher_client/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.2"