[WIP] envoy.code.check: experimental

aio.api.aspell/BUILD

@@ -0,0 +1,2 @@
+
+pytooling_package("aio.api.aspell")

aio.api.aspell/README.rst

@@ -0,0 +1,5 @@
+
+aio.api.aspell
+==============
+
+Wrapper around aspell

aio.api.aspell/VERSION

@@ -0,0 +1 @@
+0.0.5-dev

aio.api.aspell/aio/api/aspell/BUILD

@@ -0,0 +1,16 @@
+
+pytooling_library(
+    "aio.api.aspell",
+    dependencies=[
+        "//deps:abstracts",
+        "//deps:aio.core",
+    ],
+    sources=[
+        "abstract/__init__.py",
+        "abstract/api.py",
+        "__init__.py",
+        "api.py",
+        "exceptions.py",
+        "utils.py",
+    ],
+)

aio.api.aspell/aio/api/aspell/__init__.py

@@ -0,0 +1,16 @@
+"""aio.api.aspell."""
+
+from . import abstract
+from . import exceptions
+from . import utils
+from .api import (
+    AspellAPI, )
+from .abstract import (
+    AAspellAPI, )
+
+
+__all__ = (
+    "abstract",
+    "AAspellAPI",
+    "AspellAPI",
+    "exceptions", )

aio.api.aspell/aio/api/aspell/abstract/__init__.py

@@ -0,0 +1,6 @@
+
+from .api import AAspellAPI
+
+
+__all__ = (
+    "AAspellAPI", )

aio.api.aspell/aio/api/aspell/abstract/api.py

@@ -0,0 +1,139 @@
+
+import asyncio
+import abc
+import shutil
+from functools import cached_property
+from typing import Any, Type
+
+import abstracts
+
+from aio.core.functional import async_property
+from aio.core.tasks import concurrent
+from aio.core.interactive import Interactive
+
+
+class AspellPipe:
+    handlers = []
+
+    def __init__(self, in_q, out_q):
+        self.in_q = in_q
+        self.out_q = out_q
+
+    @async_property(cache=True)
+    async def proc(self):
+        return await asyncio.create_subprocess_exec(
+            "/home/phlax/.virtualenvs/envoydev/pytooling/echo.py",
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE)
+
+    async def listen(self):
+        print ("STARTING LISTENER")
+        while True:
+            msg = await self.in_q.get()
+            print(f"IN Q MESSAGE RECVD: {msg}")
+            self.in_q.task_done()
+            print(f"Sending message to process: {msg}")
+            result = await self.write(msg)
+            await self.out_q.put(result)
+
+    async def start(self):
+        print ("STARTING ASPELL")
+        self.task = asyncio.create_task(self.listen())
+        return (await self.write(b""))[0]
+
+    async def stop(self):
+        print ("STOPPING ASPELL")
+
+    async def write(self, message):
+        print(f"WRITE: {message}")
+        proc = await self.proc
+        stdout, stderr = await proc.communicate(message)
+        other = await proc.stdout.read()
+        more = await proc.communicate(message)
+        return stdout, stderr
+
+
+class MultiPipe:
+
+    def __init__(self, pipe_type):
+        self.pipe_type = pipe_type
+
+    @cached_property
+    def in_q(self):
+        return asyncio.Queue()
+
+    @cached_property
+    def out_q(self):
+        return asyncio.Queue()
+
+    @async_property(cache=True)
+    async def pipes(self):
+        aspell_pipe = self.pipe_type(self.in_q, self.out_q)
+        print(f"Started aspell pipe: {await aspell_pipe.start()}")
+        return aspell_pipe
+
+    async def write(self, message):
+        print(f"PUTTING MESSAGE: {message}")
+        print(f"IN Q: {self.in_q}")
+        await self.in_q.put(message)
+        print(f"DONE")
+        while True:
+            stdout, stderr = await self.out_q.get()
+            self.out_q.task_done()
+            if stdout or stderr:
+                return stdout, stderr
+
+
+class AAspellAPI(metaclass=abstracts.Abstraction):
+    """Aspell API wrapper.
+    """
+
+    def __init__(self, *args, **kwargs) -> None:
+        self.args = args
+        self.kwargs = kwargs
+
+    @cached_property
+    def aspell_command(self):
+        command = shutil.which("aspell")
+        return f"{command} -a"
+
+    @async_property(cache=True)
+    async def session(self):
+        session = Interactive(self.aspell_command, 1)
+        await session.start()
+        return session
+
+    async def compile_dictionary(self, path):
+        # breakpoint()
+        pass
+
+    @async_property(cache=True)
+    async def pipe(self):
+        aspell_pipe = MultiPipe(AspellPipe)
+        await aspell_pipe.pipes
+        # await aspell_pipe.start()
+        return aspell_pipe
+
+    async def listener(self):
+        print(f"MESSAGE RCVD: {stdout} {stderr}")
+
+    async def spellcheck(self, message):
+        pipe = await self.pipe
+        return await pipe.write(message)
+
+    async def start(self):
+        await self.session
+
+    async def compile_dictionary(self, dictionary):
+        words = ["asdfasfdafds", "cabbage"]
+        session = await self.session
+        for word in words:
+            response = await session(f"{word}\n".encode("utf-8"))
+            if str(response[0]).strip() == "*":
+                print(f"{word} is a good word")
+            else:
+                print(f"{word} is a bad word")
+
+    async def stop(self):
+        pass

aio.api.aspell/aio/api/aspell/api.py

@@ -0,0 +1,13 @@
+
+from typing import Type
+
+import abstracts
+
+from .abstract import AAspellAPI
+
+
+@abstracts.implementer(AAspellAPI)
+class AspellAPI:
+
+    def __init__(self, *args, **kwargs) -> None:
+        AAspellAPI.__init__(self, *args, **kwargs)

aio.api.aspell/aio/api/aspell/utils.py

@@ -0,0 +1,14 @@
+
+from datetime import datetime
+
+
+# these only deal with utc but are good enough for working with the
+# github api
+
+
+def dt_from_js_isoformat(iso: str) -> datetime:
+    return datetime.fromisoformat(iso.replace("Z", "+00:00"))
+
+
+def dt_to_js_isoformat(dt: datetime) -> str:
+    return dt.isoformat().replace("+00:00", "Z")

aio.api.aspell/setup.cfg

@@ -0,0 +1,48 @@
+[metadata]
+name = aio.api.aspell
+version = file: VERSION
+author = Ryan Northey
+author_email = [email protected]
+maintainer = Ryan Northey
+maintainer_email = [email protected]
+license = Apache Software License 2.0
+url = https://github.com/envoyproxy/pytooling/tree/main/aio.api.aspell
+description = Wrapper around aspell
+long_description = file: README.rst
+classifiers =
+    Development Status :: 4 - Beta
+    Framework :: Pytest
+    Intended Audience :: Developers
+    Topic :: Software Development :: Testing
+    Programming Language :: Python
+    Programming Language :: Python :: 3
+    Programming Language :: Python :: 3.8
+    Programming Language :: Python :: 3.9
+    Programming Language :: Python :: 3 :: Only
+    Programming Language :: Python :: Implementation :: CPython
+    Operating System :: OS Independent
+    License :: OSI Approved :: Apache Software License
+
+[options]
+python_requires = >=3.5
+py_modules = aio.api.aspell
+packages = find_namespace:
+install_requires =
+    abstracts>=0.0.12
+    aio.core>=0.3.0
+    gidgethub
+    packaging
+
+[options.extras_require]
+test =
+    pytest
+    pytest-asyncio
+    pytest-coverage
+    pytest-patches
+lint = flake8
+types =
+    mypy
+publish = wheel
+
+[options.package_data]
+* = py.typed

aio.api.aspell/setup.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+
+from setuptools import setup  # type:ignore
+
+setup()

aio.api.aspell/tests/BUILD

@@ -0,0 +1,12 @@
+
+pytooling_tests(
+    "aio.api.github",
+    dependencies=[
+        "//deps:abstracts",
+        "//deps:aio.core",
+        "//deps:aiohttp",
+        "//deps:gidgethub",
+        "//deps:packaging",
+        "//deps:pytest-asyncio",
+    ],
+)

aio.core/aio/core/BUILD

@@ -34,6 +34,10 @@ pytooling_library(
         "functional/utils.py",
         "log/__init__.py",
         "log/logging.py",
+        "interactive/abstract/__init__.py",
+        "interactive/abstract/interactive.py",
+        "interactive/exceptions.py",
+        "interactive/interactive.py",
         "output/abstract/__init__.py",
         "output/abstract/output.py",
         "output/exceptions.py",

aio.core/aio/core/__init__.py

@@ -4,6 +4,7 @@
     directory,
     event,
     functional,
+    interactive,
     output,
     stream,
     subprocess,
@@ -15,6 +16,7 @@
     "directory",
     "event",
     "functional",
+    "interactive",
     "output",
     "stream",
     "subprocess",

aio.core/aio/core/interactive/__init__.py

@@ -0,0 +1,14 @@
+
+
+from .abstract import AInteractive, APrompt
+from .interactive import Interactive, interactive, Prompt
+from . import exceptions
+
+
+__all__ = (
+    "AInteractive",
+    "APrompt",
+    "exceptions",
+    "interactive",
+    "Interactive",
+    "Prompt")

aio.core/aio/core/interactive/abstract/__init__.py

@@ -0,0 +1,7 @@
+
+from .interactive import AInteractive, APrompt
+
+
+__all__ = (
+    "AInteractive",
+    "APrompt")