kaqing 1.98.15__py3-none-any.whl → 2.0.145__py3-none-any.whl

adam/utils_k8s/pods.py

@@ -0,0 +1,342 @@
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime
+import sys
+import time
+from typing import TypeVar, cast
+from kubernetes import client
+from kubernetes.stream import stream
+from kubernetes.stream.ws_client import ERROR_CHANNEL, WSClient
+
+from adam.config import Config
+from adam.utils_k8s.volumes import ConfigMapMount
+from adam.pod_exec_result import PodExecResult
+from adam.utils import elapsed_time, log2
+from .kube_context import KubeContext
+
+from websocket._core import WebSocket
+
+T = TypeVar('T')
+_TEST_POD_EXEC_OUTS: PodExecResult = None
+
+# utility collection on pods; methods are all static
+class Pods:
+    _TEST_POD_CLOSE_SOCKET: bool = False
+
+    def set_test_pod_exec_outs(outs: PodExecResult):
+        global _TEST_POD_EXEC_OUTS
+        _TEST_POD_EXEC_OUTS = outs
+
+        return _TEST_POD_EXEC_OUTS
+
+    def delete(pod_name: str, namespace: str, grace_period_seconds: int = None):
+        try:
+            v1 = client.CoreV1Api()
+            v1.delete_namespaced_pod(pod_name, namespace, grace_period_seconds=grace_period_seconds)
+        except Exception as e:
+            log2("Exception when calling CoreV1Api->delete_namespaced_pod: %s\n" % e)
+
+    def delete_with_selector(namespace: str, label_selector: str, grace_period_seconds: int = None):
+        v1 = client.CoreV1Api()
+
+        ret = v1.list_namespaced_pod(namespace=namespace, label_selector=label_selector)
+        for i in ret.items:
+            v1.delete_namespaced_pod(name=i.metadata.name, namespace=namespace, grace_period_seconds=grace_period_seconds)
+
+    def on_pods(pods: list[str],
+                namespace: str,
+                body: Callable[[ThreadPoolExecutor, str, str, bool], T],
+                post: Callable[[T], T] = None,
+                action: str = 'action',
+                max_workers=0,
+                show_out=True,
+                on_any = False,
+                background = False) -> list[T]:
+        show_out = KubeContext.show_out(show_out)
+
+        if not max_workers:
+            max_workers = Config().action_workers(action, 0)
+        if not on_any and max_workers > 0:
+            # if parallel, node sampling is suppressed
+            if KubeContext.show_parallelism():
+                log2(f'Executing on all nodes from statefulset in parallel...')
+            start_time = time.time()
+            try:
+                with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                    # disable stdout from the pod_exec, then show the output in a for loop
+                    futures = [body(executor, pod, namespace, show_out) for pod in pods]
+                    if len(futures) == 0:
+                        return cast(list[T], [])
+
+                rs = [future.result() for future in as_completed(futures)]
+                if post:
+                    rs = [post(r, show_out=show_out) for r in rs]
+
+                return rs
+            finally:
+                if KubeContext.show_parallelism():
+                    log2(f"Parallel {action} elapsed time: {elapsed_time(start_time)} with {max_workers} workers")
+        else:
+            results: list[T] = []
+
+            samples = 1 if on_any else Config().action_node_samples(action, sys.maxsize)
+            l = min(len(pods), samples)
+            adj = 'all'
+            if l < len(pods):
+                adj = f'{l} sample'
+            if show_out:
+                log2(f'Executing on {adj} nodes from statefulset...')
+            for pod_name in pods:
+                try:
+                    # disable stdout from the pod_exec, then show the output in a for loop
+                    result = body(None, pod_name, namespace, False)
+                    if post:
+                        result = post(result, show_out=show_out)
+                    results.append(result)
+                    if result:
+                        l -= 1
+                        if not l:
+                            break
+                except Exception as e:
+                    log2(e)
+
+            return results
+
+    def exec(pod_name: str, container: str, namespace: str, command: str,
+             show_out = True, throw_err = False, shell = '/bin/sh',
+             background = False,
+             log_file = None,
+             interaction: Callable[[any, list[str]], any] = None,
+             env_prefix: str = None):
+        if _TEST_POD_EXEC_OUTS:
+            return _TEST_POD_EXEC_OUTS
+
+        show_out = KubeContext.show_out(show_out)
+
+        api = client.CoreV1Api()
+
+        tty = True
+        exec_command = [shell, '-c', command]
+        if env_prefix:
+            exec_command = [shell, '-c', f'{env_prefix} {command}']
+
+        if background or command.endswith(' &'):
+            # should be false for starting a background process
+            tty = False
+
+            if Config().get('repl.background-process.auto-nohup', True):
+                command = command.strip(' &')
+                cmd_name = ''
+                if command.startswith('nodetool '):
+                    cmd_name = f".{'_'.join(command.split(' ')[5:])}"
+
+                if not log_file:
+                    log_file = f'{log_prefix()}-{datetime.now().strftime("%d%H%M%S")}{cmd_name}.log'
+                command = f"nohup {command} > {log_file} 2>&1 &"
+                if env_prefix:
+                    command = f'{env_prefix} {command}'
+                exec_command = [shell, '-c', command]
+
+        k_command = f'kubectl exec {pod_name} -c {container} -n {namespace} -- {shell} -c "{command}"'
+        if show_out:
+            print(k_command)
+
+        resp: WSClient = stream(
+            api.connect_get_namespaced_pod_exec,
+            pod_name,
+            namespace,
+            command=exec_command,
+            container=container,
+            stderr=True,
+            stdin=True,
+            stdout=True,
+            tty=tty,
+            _preload_content=False,
+        )
+
+        s: WebSocket = resp.sock
+        stdout = []
+        stderr = []
+        error_output = None
+        try:
+            while resp.is_open():
+                resp.update(timeout=1)
+                if resp.peek_stdout():
+                    frag = resp.read_stdout()
+                    stdout.append(frag)
+                    if show_out: print(frag, end="")
+
+                    if interaction:
+                        interaction(resp, stdout)
+                if resp.peek_stderr():
+                    frag = resp.read_stderr()
+                    stderr.append(frag)
+                    if show_out: print(frag, end="")
+
+            try:
+                # get the exit code from server
+                error_output = resp.read_channel(ERROR_CHANNEL)
+            except Exception as e:
+                pass
+        except Exception as e:
+            if throw_err:
+                raise e
+            else:
+                log2(e)
+        finally:
+            resp.close()
+            if s and s.sock and Pods._TEST_POD_CLOSE_SOCKET:
+                try:
+                    s.sock.close()
+                except:
+                    pass
+
+        return PodExecResult("".join(stdout), "".join(stderr), k_command, error_output, pod=pod_name, log_file=log_file)
+
+    def read_file(pod_name: str, container: str, namespace: str, file_path: str):
+        v1 = client.CoreV1Api()
+
+        resp = stream(
+            v1.connect_get_namespaced_pod_exec,
+            name=pod_name,
+            namespace=namespace,
+            container=container,
+            command=["cat", file_path],
+            stderr=True, stdin=False,
+            stdout=True, tty=False,
+            _preload_content=False, # Important for streaming
+        )
+
+        s: WebSocket = resp.sock
+        try:
+            while resp.is_open():
+                resp.update(timeout=1)
+                if resp.peek_stdout():
+                    yield resp.read_stdout()
+
+            try:
+                # get the exit code from server
+                error_output = resp.read_channel(ERROR_CHANNEL)
+            except Exception as e:
+                pass
+        except Exception as e:
+            raise e
+        finally:
+            resp.close()
+            if s and s.sock and Pods._TEST_POD_CLOSE_SOCKET:
+                try:
+                    s.sock.close()
+                except:
+                    pass
+    def get_container(namespace: str, pod_name: str, container_name: str):
+        pod = Pods.get(namespace, pod_name)
+        if not pod:
+            return None
+
+        for container in pod.spec.containers:
+            if container_name == container.name:
+                return container
+
+        return None
+
+    def get(namespace: str, pod_name: str):
+        v1 = client.CoreV1Api()
+        return v1.read_namespaced_pod(name=pod_name, namespace=namespace)
+
+    def get_with_selector(namespace: str, label_selector: str):
+        v1 = client.CoreV1Api()
+
+        ret = v1.list_namespaced_pod(namespace=namespace, label_selector=label_selector)
+        for i in ret.items:
+            return v1.read_namespaced_pod(name=i.metadata.name, namespace=namespace)
+
+    def create_pod_spec(name: str, image: str, image_pull_secret: str,
+                        envs: list, container_security_context: client.V1SecurityContext,
+                        volume_name: str, pvc_name:str, mount_path:str,
+                        command: list[str]=None, sa_name : str = None, config_map_mount: ConfigMapMount = None,
+                        restart_policy="Never"):
+        volume_mounts = []
+        if volume_name and pvc_name and mount_path:
+            volume_mounts=[client.V1VolumeMount(mount_path=mount_path, name=volume_name)]
+
+        if config_map_mount:
+            volume_mounts.append(client.V1VolumeMount(mount_path=config_map_mount.mount_path, sub_path=config_map_mount.sub_path, name=config_map_mount.name()))
+
+        container = client.V1Container(name=name, image=image, env=envs, security_context=container_security_context, command=command,
+                                    volume_mounts=volume_mounts)
+
+        volumes = []
+        if volume_name and pvc_name and mount_path:
+            volumes=[client.V1Volume(name=volume_name, persistent_volume_claim=client.V1PersistentVolumeClaimVolumeSource(claim_name=pvc_name))]
+
+        security_context = None
+        if not sa_name:
+            security_context=client.V1PodSecurityContext(run_as_user=1001, run_as_group=1001, fs_group=1001)
+
+        if config_map_mount:
+            volumes.append(client.V1Volume(name=config_map_mount.name(), config_map=client.V1ConfigMapVolumeSource(name=config_map_mount.config_map_name)))
+
+        return client.V1PodSpec(
+            restart_policy=restart_policy,
+            containers=[container],
+            image_pull_secrets=[client.V1LocalObjectReference(name=image_pull_secret)],
+            security_context=security_context,
+            service_account_name=sa_name,
+            volumes=volumes
+        )
+
+    def create(namespace: str, pod_name: str, image: str,
+               command: list[str] = None,
+               secret: str = None,
+               env: dict[str, any] = {},
+               container_security_context: client.V1SecurityContext = None,
+               labels: dict[str, str] = {},
+               volume_name: str = None,
+               pvc_name: str = None,
+               mount_path: str = None,
+               sa_name: str = None,
+               config_map_mount: ConfigMapMount = None):
+        v1 = client.CoreV1Api()
+        envs = []
+        for k, v in env.items():
+            envs.append(client.V1EnvVar(name=str(k), value=str(v)))
+        pod = Pods.create_pod_spec(pod_name, image, secret, envs, container_security_context, volume_name, pvc_name, mount_path, command=command,
+                                   sa_name=sa_name, config_map_mount=config_map_mount)
+        return v1.create_namespaced_pod(
+            namespace=namespace,
+            body=client.V1Pod(spec=pod, metadata=client.V1ObjectMeta(
+                name=pod_name,
+                labels=labels
+            ))
+        )
+
+    def wait_for_running(namespace: str, pod_name: str, msg: str = None, label_selector: str = None):
+        cnt = 2
+        while (cnt < 302 and Pods.get_with_selector(namespace, label_selector) if label_selector else Pods.get(namespace, pod_name)).status.phase != 'Running':
+            if not msg:
+                msg = f'Waiting for the {pod_name} pod to start up.'
+
+            max_len = len(msg) + 3
+            mod = cnt % 3
+            padded = ''
+            if mod == 0:
+                padded = f'\r{msg}'.ljust(max_len)
+            elif mod == 1:
+                padded = f'\r{msg}.'.ljust(max_len)
+            else:
+                padded = f'\r{msg}..'.ljust(max_len)
+            log2(padded, nl=False)
+            cnt += 1
+            time.sleep(1)
+
+        log2(f'\r{msg}..'.ljust(max_len), nl=False)
+        if cnt < 302:
+            log2(' OK')
+        else:
+            log2(' Timed Out')
+
+    def completed(namespace: str, pod_name: str):
+        return Pods.get(namespace, pod_name).status.phase in ['Succeeded', 'Failed']
+
+def log_prefix():
+    return Config().get('log-prefix', '/tmp/qing')

adam/{k8s_utils → utils_k8s}/secrets.py

@@ -1,4 +1,5 @@
 import base64
+import functools
 import re
 from typing import cast
 from kubernetes import client
@@ -9,7 +10,10 @@ from adam.utils import log2
 
 # utility collection on secrets; methods are all static
 class Secrets:
+    @functools.lru_cache()
     def list_secrets(namespace: str = None, name_pattern: str = None):
+        Config().wait_log('Inspecting Cassandra Instances...')
+
         secrets_names = []
 
         v1 = client.CoreV1Api()

adam/utils_k8s/service_accounts.py

@@ -0,0 +1,169 @@
+from kubernetes import client, config
+
+from adam.config import Config
+
+# utility collection on service accounts; methods are all static
+class ServiceAccounts:
+    def delete(namespace: str, label_selector: str):
+        ServiceAccounts.delete_cluster_role_bindings(label_selector)
+        ServiceAccounts.delete_role_bindings(namespace, label_selector)
+        ServiceAccounts.delete_service_account(namespace, label_selector)
+
+    def replicate(to_sa: str, namespace: str, from_sa: str, labels: dict[str, str] = {}, add_cluster_roles: list[str] = []):
+        ServiceAccounts.create_service_account(to_sa, namespace, labels=labels)
+        for b in ServiceAccounts.get_role_bindings(from_sa, namespace):
+            n = f'{to_sa}-{b.role_ref.name}'
+            ServiceAccounts.create_role_binding(n, namespace, to_sa, b.role_ref.name, labels=labels)
+
+        for b in ServiceAccounts.get_cluster_role_bindings(from_sa):
+            n = f'{to_sa}-{b.role_ref.name}'
+            ServiceAccounts.create_cluster_role_binding(n, namespace, to_sa, b.role_ref.name, labels=labels)
+
+        for cr in add_cluster_roles:
+            n = f'{to_sa}-{cr}'
+            ServiceAccounts.create_cluster_role_binding(n, namespace, to_sa, cr, labels=labels)
+
+    def create_service_account(name: str, namespace: str, labels: dict[str, str] = {}):
+        config.load_kube_config()
+
+        v1 = client.CoreV1Api()
+
+        service_account = client.V1ServiceAccount(
+            metadata=client.V1ObjectMeta(
+                name=name,
+                labels=labels)
+        )
+        api_response = v1.create_namespaced_service_account(
+            namespace=namespace,
+            body=service_account
+        )
+        Config().debug(f"Service Account '{api_response.metadata.name}' created in namespace '{namespace}'.")
+
+    def delete_service_account(namespace: str, label_selector: str) -> list:
+        refs = []
+
+        v1 = client.CoreV1Api()
+        sas = v1.list_namespaced_service_account(namespace=namespace, label_selector=label_selector).items
+        for sa in sas:
+            Config().debug(f'delete {sa.metadata.name}')
+            v1.delete_namespaced_service_account(name=sa.metadata.name, namespace=namespace)
+            refs.append(sa)
+
+        return refs
+
+    def create_role_binding(name: str, namespace: str, sa_name: str, role_name: str, labels: dict[str, str] = {}):
+        api = client.RbacAuthorizationV1Api()
+
+        metadata = client.V1ObjectMeta(
+            name=name,
+            namespace=namespace,
+            labels=labels
+        )
+        role_ref = client.V1RoleRef(
+            api_group="rbac.authorization.k8s.io",
+            kind="Role",
+            name=role_name
+        )
+
+        subjects = [
+            client.RbacV1Subject(
+                kind="ServiceAccount",
+                name=sa_name, # Name of the service account
+                namespace=namespace # Namespace of the service account
+            )
+        ]
+
+        role_binding = client.V1RoleBinding(
+            api_version="rbac.authorization.k8s.io/v1",
+            kind="RoleBinding",
+            metadata=metadata,
+            role_ref=role_ref,
+            subjects=subjects
+        )
+
+        api.create_namespaced_role_binding(namespace=namespace, body=role_binding)
+
+    def get_role_bindings(service_account_name: str, namespace: str) -> list:
+        refs = []
+
+        rbac_api = client.RbacAuthorizationV1Api()
+        role_bindings = rbac_api.list_namespaced_role_binding(namespace=namespace)
+        for binding in role_bindings.items:
+            if binding.subjects:
+                for subject in binding.subjects:
+                    if subject.kind == "ServiceAccount" and subject.name == service_account_name:
+                        refs.append(binding)
+
+        return refs
+
+    def delete_role_bindings(namespace: str, label_selector: str) -> list:
+        refs = []
+
+        v1_rbac = client.RbacAuthorizationV1Api()
+        cluster_role_bindings = v1_rbac.list_namespaced_role_binding(namespace=namespace, label_selector=label_selector).items
+        for binding in cluster_role_bindings:
+            Config().debug(f'delete {binding.metadata.name}')
+            v1_rbac.delete_namespaced_role_binding(name=binding.metadata.name, namespace=namespace)
+            refs.append(binding)
+
+        return refs
+
+    def create_cluster_role_binding(name: str, namespace: str, sa_name: str, role_name: str, labels: dict[str, str] = {}):
+        api = client.RbacAuthorizationV1Api()
+
+        metadata = client.V1ObjectMeta(
+            name=name,
+            namespace=namespace,
+            labels=labels
+        )
+        role_ref = client.V1RoleRef(
+            api_group="rbac.authorization.k8s.io",
+            kind="ClusterRole",
+            name=role_name
+        )
+
+        subjects = [
+            client.RbacV1Subject(
+                kind="ServiceAccount",
+                name=sa_name,
+                namespace=namespace
+            )
+        ]
+
+        role_binding = client.V1ClusterRoleBinding(
+            api_version="rbac.authorization.k8s.io/v1",
+            metadata=metadata,
+            role_ref=role_ref,
+            subjects=subjects
+        )
+
+        try:
+            api.create_cluster_role_binding(body=role_binding)
+        except client.ApiException as e:
+            print(f"Error creating ClusterRoleBinding: {e}")
+
+    def get_cluster_role_bindings(service_account_name: str) -> list:
+        refs = []
+
+        v1_rbac = client.RbacAuthorizationV1Api()
+        cluster_role_bindings = v1_rbac.list_cluster_role_binding().items
+        for binding in cluster_role_bindings:
+            if binding.subjects:
+                for subject in binding.subjects:
+                    if subject.kind == "ServiceAccount" and subject.name == service_account_name:
+                        refs.append(binding)
+
+        return refs
+
+
+    def delete_cluster_role_bindings(label_selector: str) -> list:
+        refs = []
+
+        v1_rbac = client.RbacAuthorizationV1Api()
+        cluster_role_bindings = v1_rbac.list_cluster_role_binding(label_selector=label_selector).items
+        for binding in cluster_role_bindings:
+            Config().debug(f'delete {binding.metadata.name}')
+            v1_rbac.delete_cluster_role_binding(binding.metadata.name)
+            refs.append(binding)
+
+        return refs

adam/{k8s_utils → utils_k8s}/statefulsets.py

@@ -24,11 +24,12 @@ class StatefulSets:
 
         return statefulsets.items
 
+    @functools.lru_cache()
     def list_sts_name_and_ns():
         return [(statefulset.metadata.name, statefulset.metadata.namespace) for statefulset in StatefulSets.list_sts()]
 
-    def list_sts_names(show_namespace = True):
-        if show_namespace:
+    def list_sts_names():
+        if not KubeContext.in_cluster_namespace():
             return [f"{sts}@{ns}" for sts, ns in StatefulSets.list_sts_name_and_ns()]
         else:
             return [f"{sts}" for sts, _ in StatefulSets.list_sts_name_and_ns()]
@@ -61,10 +62,10 @@ class StatefulSets:
                 namespace: str,
                 body: Callable[[ThreadPoolExecutor, str, str, bool], T],
                 post: Callable[[T], T] = None,
-                action: str = 'action', max_workers=0, show_out=True) -> list[T]:
+                action: str = 'action', max_workers=0, show_out=True, on_any = False, background = False) -> list[T]:
         pods = StatefulSets.pod_names(statefulset, namespace)
 
-        return Pods.on_pods(pods, namespace, body, post=post, action=action, max_workers=max_workers, show_out=show_out)
+        return Pods.on_pods(pods, namespace, body, post=post, action=action, max_workers=max_workers, show_out=show_out, on_any=on_any, background=background)
 
     @functools.lru_cache()
     def pod_names(ss: str, ns: str):

adam/{k8s_utils → utils_k8s}/volumes.py

@@ -1,6 +1,15 @@
 from kubernetes import client
 from adam.utils import log2
 
+class ConfigMapMount:
+    def __init__(self, config_map_name: str, sub_path: str, mount_path: str):
+        self.config_map_name = config_map_name
+        self.sub_path = sub_path
+        self.mount_path = mount_path
+
+    def name(self) -> str:
+        return f"{self.config_map_name}-volume"
+
 # utility collection on volumes; methods are all static
 class Volumes:
     def create_pvc(name: str, storage: int, namespace: str):

adam/utils_net.py

@@ -0,0 +1,24 @@
+import socket
+
+MY_HOST = None
+
+def get_my_host():
+    global MY_HOST
+
+    if MY_HOST:
+       return MY_HOST
+
+    MY_HOST = get_ip_from_hostname('host.docker.internal')
+    if not MY_HOST:
+       MY_HOST = socket.gethostname()
+
+    if not MY_HOST:
+       MY_HOST = 'NA'
+
+    return MY_HOST
+
+def get_ip_from_hostname(hostname):
+    try:
+        return socket.gethostbyname(hostname)
+    except socket.gaierror:
+        return None

adam/utils_repl/automata_completer.py

@@ -0,0 +1,48 @@
+from typing import Generic, Iterable, TypeVar
+from prompt_toolkit.completion import CompleteEvent, Completer, Completion, WordCompleter
+from prompt_toolkit.document import Document
+
+from adam.utils_repl.state_machine import StateMachine, State
+
+__all__ = [
+    "AutomataCompleter",
+]
+
+T = TypeVar('T')
+
+class AutomataCompleter(Completer, Generic[T]):
+    def __init__(self,
+                 state_machine: StateMachine,
+                 first_term: str = '',
+                 debug = False):
+        super().__init__()
+        self.machine = state_machine
+        self.first_term = first_term
+        self.debug = debug
+
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        text = document.text_before_cursor.lstrip()
+        state = ''
+        if self.first_term:
+            text = f'{self.first_term} {text}'
+
+        completer: Completer = None
+        state: State = self.machine.traverse_tokens(self.tokens(text), State(state))
+        if self.debug:
+            print('\n  =>', state.state if isinstance(state, State) else '')
+
+        if state.state in self.machine.suggestions:
+            if completer := self.suggestions_completer(state, self.machine.suggestions[state.state].strip(' ')):
+                for c in completer.get_completions(document, complete_event):
+                    yield c
+
+    def tokens(self, text: str) -> list[T]:
+        return text.split(' ')
+
+    def suggestions_completer(self, _: State, suggestions: str) -> list[str]:
+        if not suggestions:
+            return None
+
+        return WordCompleter(suggestions.split(','))

adam/utils_repl/repl_completer.py

@@ -0,0 +1,46 @@
+import re
+from typing import Iterable, TypeVar
+from prompt_toolkit.completion import CompleteEvent, Completion, NestedCompleter, WordCompleter
+from prompt_toolkit.document import Document
+
+__all__ = [
+    "ReplCompleter",
+]
+
+T = TypeVar('T')
+
+class ReplCompleter(NestedCompleter):
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        # Split document.
+        text = document.text_before_cursor.lstrip()
+        stripped_len = len(document.text_before_cursor) - len(text)
+
+        # If there is a space, check for the first term, and use a
+        # subcompleter.
+        if " " in text:
+            first_term = text.split()[0]
+            completer = self.options.get(first_term)
+
+            # If we have a sub completer, use this for the completions.
+            if completer is not None:
+                remaining_text = text[len(first_term) :].lstrip()
+                move_cursor = len(text) - len(remaining_text) + stripped_len
+
+                new_document = Document(
+                    remaining_text,
+                    cursor_position=document.cursor_position - move_cursor,
+                )
+
+                for c in completer.get_completions(new_document, complete_event):
+                    yield c
+
+        # No space in the input: behave exactly like `WordCompleter`.
+        else:
+            completer = WordCompleter(
+                # Allow dot in the middle or a word
+                list(self.options.keys()), ignore_case=self.ignore_case, pattern=re.compile(r"([a-zA-Z0-9_\.\@\&]+|[^a-zA-Z0-9_\.\@\&\s]+)")
+            )
+            for c in completer.get_completions(document, complete_event):
+                yield c