ddss 0.0.6__tar.gz

ddss-0.0.6/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: ddss
+Version: 0.0.6
+Summary: Distributed Deductive System Sorts
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: aiomysql>=0.3.2
+Requires-Dist: aiosqlite>=0.22.0
+Requires-Dist: apyds>=0.0.7
+Requires-Dist: apyds-bnf>=0.0.7
+Requires-Dist: cloudpickle>=3.1.2
+Requires-Dist: egglog>=12.0.0
+Requires-Dist: sqlalchemy>=2.0.45
+
+# Distributed Deductive System Sorts

ddss-0.0.6/README.md

@@ -0,0 +1 @@
+# Distributed Deductive System Sorts

ddss-0.0.6/ddss/ds.py

@@ -0,0 +1,49 @@
+import sys
+import asyncio
+from sqlalchemy import select
+from apyds import Search
+from .orm import initialize_database, insert_or_ignore, Facts, Ideas
+from .poly import Poly
+
+
+async def main(addr, engine=None, session=None):
+    if engine is None or session is None:
+        engine, session = await initialize_database(addr)
+
+    search = Search()
+    max_fact = -1
+
+    while True:
+        begin = asyncio.get_running_loop().time()
+
+        async with session() as sess:
+            for i in await sess.scalars(select(Facts).where(Facts.id > max_fact)):
+                max_fact = max(max_fact, i.id)
+                search.add(Poly(dsp=i.data).ds)
+            tasks = []
+
+            def handler(rule):
+                poly = Poly(rule=rule)
+                tasks.append(asyncio.create_task(insert_or_ignore(sess, Facts, poly.dsp)))
+                if idea := poly.idea:
+                    tasks.append(asyncio.create_task(insert_or_ignore(sess, Ideas, idea.dsp)))
+                return False
+
+            count = search.execute(handler)
+            await asyncio.gather(*tasks)
+            await sess.commit()
+
+        end = asyncio.get_running_loop().time()
+        duration = end - begin
+        if count == 0:
+            delay = max(0, 0.1 - duration)
+            await asyncio.sleep(delay)
+
+    await engine.dispose()
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print(f"Usage: {sys.argv[0]} <database-addr>")
+        sys.exit(1)
+    asyncio.run(main(sys.argv[1]))

ddss-0.0.6/ddss/egg.py

@@ -0,0 +1,47 @@
+import sys
+import asyncio
+from sqlalchemy import select
+from .orm import initialize_database, insert_or_ignore, Facts, Ideas
+from .egraph import Search
+from .poly import Poly
+
+
+async def main(addr, engine=None, session=None):
+    if engine is None or session is None:
+        engine, session = await initialize_database(addr)
+
+    search = Search()
+    pool = []
+    max_fact = -1
+    max_idea = -1
+
+    while True:
+        count = 0
+        begin = asyncio.get_running_loop().time()
+
+        async with session() as sess:
+            for i in await sess.scalars(select(Facts).where(Facts.id > max_fact)):
+                max_fact = max(max_fact, i.id)
+                search.add(Poly(dsp=i.data))
+            for i in await sess.scalars(select(Ideas).where(Ideas.id > max_idea)):
+                max_idea = max(max_idea, i.id)
+                pool.append(Poly(dsp=i.data))
+            tasks = []
+            for i in pool:
+                for o in search.execute(i):
+                    tasks.append(asyncio.create_task(insert_or_ignore(sess, Facts, o.dsp)))
+            await asyncio.gather(*tasks)
+            await sess.commit()
+
+        end = asyncio.get_running_loop().time()
+        duration = end - begin
+        if count == 0:
+            delay = max(0, 0.1 - duration)
+            await asyncio.sleep(delay)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print(f"Usage: {sys.argv[0]} <database-addr>")
+        sys.exit(1)
+    asyncio.run(main(sys.argv[1]))

ddss-0.0.6/ddss/egraph.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+import typing
+import egglog
+from apyds import Term, List
+from .poly import Poly
+
+
+class EGraphTerm(egglog.Expr):
+    def __init__(self, name: egglog.StringLike) -> None: ...
+
+    @classmethod
+    def begin(cls) -> EGraphTerm: ...
+
+    @classmethod
+    def pair(cls, lhs: EGraphTerm, rhs: EGraphTerm) -> EGraphTerm: ...
+
+
+def _ds_to_egraph(data: Term) -> EGraphTerm:
+    term = data.term
+    if isinstance(term, List):
+        result = EGraphTerm.begin()
+        for i in range(len(term)):
+            child = _ds_to_egraph(term[i])
+            result = EGraphTerm.pair(result, child)
+        return result
+    else:
+        return EGraphTerm(str(term))
+
+
+class Search:
+    def __init__(self) -> None:
+        self.egraph = egglog.EGraph()
+        self.terms = set()
+
+    def _is_equality(self, data: Poly) -> bool:
+        return data.ds.startswith("----\n(binary == ")
+
+    def _extract_lhs_rhs(self, data: Poly) -> tuple[str, str]:
+        term = data.rule.conclusion
+        lhs = str(term.term[2])
+        rhs = str(term.term[3])
+        return lhs, rhs
+
+    def _ast(self, data: str) -> EGraphTerm:
+        result = _ds_to_egraph(Term(data))
+        self.egraph.register(result)
+        return result
+
+    def _set_equality(self, lhs: str, rhs: str) -> None:
+        self.egraph.register(egglog.union(self._ast(lhs)).with_(self._ast(rhs)))
+
+    def _get_equality(self, lhs: str, rhs: str) -> None:
+        return self.egraph.check_bool(self._ast(lhs) == self._ast(rhs))
+
+    def _search_equality(self, data: str) -> typing.Iterator[str]:
+        for result in self.terms:
+            if self._get_equality(data, result):
+                yield result
+
+    def _build_equality(self, lhs: str, rhs: str) -> Poly:
+        return Poly(ds=f"----\n(binary == {lhs} {rhs})")
+
+    def add(self, data: Poly) -> None:
+        if not self._is_equality(data):
+            return
+        lhs, rhs = self._extract_lhs_rhs(data)
+        self.terms.add(lhs)
+        self.terms.add(rhs)
+        self._set_equality(lhs, rhs)
+
+    def execute(self, data: Poly) -> typing.Iterator[Poly]:
+        if not self._is_equality(data):
+            return
+        lhs, rhs = self._extract_lhs_rhs(data)
+        if self._get_equality(lhs, rhs):
+            yield self._build_equality(lhs, rhs)
+            return
+        if lhs.startswith("`"):
+            for result in self._search_equality(rhs):
+                yield self._build_equality(result, rhs)
+        if rhs.startswith("`"):
+            for result in self._search_equality(lhs):
+                yield self._build_equality(lhs, result)

ddss-0.0.6/ddss/input.py

@@ -0,0 +1,32 @@
+import sys
+import asyncio
+from .orm import initialize_database, insert_or_ignore, Facts, Ideas
+from .poly import Poly
+
+
+async def main(addr, engine=None, session=None):
+    if engine is None or session is None:
+        engine, session = await initialize_database(addr)
+
+    while True:
+        try:
+            data = await asyncio.get_running_loop().run_in_executor(None, input)
+            if data.strip() == "":
+                continue
+        except EOFError:
+            break
+        async with session() as sess:
+            poly = Poly(dsp=data)
+            await insert_or_ignore(sess, Facts, poly.dsp)
+            if idea := poly.idea:
+                await insert_or_ignore(sess, Ideas, idea.dsp)
+            await sess.commit()
+
+    await engine.dispose()
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print(f"Usage: {sys.argv[0]} <database-addr>")
+        sys.exit(1)
+    asyncio.run(main(sys.argv[1]))

ddss-0.0.6/ddss/main.py

@@ -0,0 +1,34 @@
+import sys
+import asyncio
+from .orm import initialize_database
+from .ds import main as ds
+from .egg import main as egg
+from .input import main as input
+from .output import main as output
+
+
+async def main(addr, recreate=False):
+    engine, session = await initialize_database(addr, recreate)
+    await asyncio.gather(
+        ds(addr, engine, session),
+        egg(addr, engine, session),
+        input(addr, engine, session),
+        output(addr, engine, session),
+    )
+
+
+def cli():
+    if len(sys.argv) == 1:
+        addr = "sqlite+aiosqlite:////tmp/ddss.db"
+        recreate = True
+    elif len(sys.argv) == 2:
+        addr = sys.argv[1]
+        recreate = False
+    else:
+        print(f"Usage: {sys.argv[0]} [<database-addr>]")
+        sys.exit(1)
+    asyncio.run(main(addr, recreate))
+
+
+if __name__ == "__main__":
+    cli()

ddss-0.0.6/ddss/orm.py

@@ -0,0 +1,45 @@
+import asyncio
+from collections import defaultdict
+from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy import Integer, Text
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class Facts(Base):
+    __tablename__ = "facts"
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    data: Mapped[str] = mapped_column(Text, unique=True, nullable=False)
+
+
+class Ideas(Base):
+    __tablename__ = "ideas"
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    data: Mapped[str] = mapped_column(Text, unique=True, nullable=False)
+
+
+async def initialize_database(
+    addr: str, recreate: bool = False
+) -> tuple[AsyncEngine, async_sessionmaker[AsyncSession]]:
+    engine = create_async_engine(addr)
+    session = async_sessionmaker(engine)
+    async with engine.begin() as conn:
+        if recreate:
+            await conn.run_sync(Base.metadata.drop_all)
+        await conn.run_sync(Base.metadata.create_all)
+    return engine, session
+
+
+async def insert_or_ignore(sess: AsyncSession, model, data, locks=defaultdict(lambda: asyncio.Lock())) -> None:
+    async with locks[id(sess.bind)]:
+        try:
+            async with sess.begin_nested():
+                sess.add(model(data=data))
+                await sess.flush()
+        except IntegrityError:
+            pass

ddss-0.0.6/ddss/output.py

@@ -0,0 +1,39 @@
+import sys
+import asyncio
+from sqlalchemy import select
+from .orm import initialize_database, Facts, Ideas
+from .poly import Poly
+
+
+async def main(addr, engine=None, session=None):
+    if engine is None or session is None:
+        engine, session = await initialize_database(addr)
+
+    max_fact = -1
+    max_idea = -1
+
+    while True:
+        count = 0
+        begin = asyncio.get_running_loop().time()
+
+        async with session() as sess:
+            for i in await sess.scalars(select(Facts).where(Facts.id > max_fact)):
+                max_fact = max(max_fact, i.id)
+                print("fact:", Poly(dsp=i.data).dsp)
+            for i in await sess.scalars(select(Ideas).where(Ideas.id > max_idea)):
+                max_idea = max(max_idea, i.id)
+                print("idea:", Poly(dsp=i.data).dsp)
+            await sess.commit()
+
+        end = asyncio.get_running_loop().time()
+        duration = end - begin
+        if count == 0:
+            delay = max(0, 0.1 - duration)
+            await asyncio.sleep(delay)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print(f"Usage: {sys.argv[0]} <database-addr>")
+        sys.exit(1)
+    asyncio.run(main(sys.argv[1]))

ddss-0.0.6/ddss/poly.py

@@ -0,0 +1,28 @@
+from apyds import Rule
+from apyds_bnf import parse, unparse
+
+
+class Poly:
+    def __init__(self, **kwargs):
+        ((key, value),) = kwargs.items()
+        match key:
+            case "dsp":
+                self.ds = parse(value)
+                self.dsp = unparse(self.ds)
+                self.rule = Rule(self.ds)
+            case "ds":
+                self.dsp = unparse(value)
+                self.ds = parse(self.dsp)
+                self.rule = Rule(self.ds)
+            case "rule":
+                self.rule = value
+                self.ds = str(self.rule)
+                self.dsp = unparse(self.ds)
+            case _:
+                raise ValueError("Invalid argument for Poly")
+
+    @property
+    def idea(self):
+        if len(self.rule) != 0:
+            return Poly(ds=f"--\n{self.rule[0]}")
+        return None

ddss-0.0.6/ddss.egg-info/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.4
+Name: ddss
+Version: 0.0.6
+Summary: Distributed Deductive System Sorts
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: aiomysql>=0.3.2
+Requires-Dist: aiosqlite>=0.22.0
+Requires-Dist: apyds>=0.0.7
+Requires-Dist: apyds-bnf>=0.0.7
+Requires-Dist: cloudpickle>=3.1.2
+Requires-Dist: egglog>=12.0.0
+Requires-Dist: sqlalchemy>=2.0.45
+
+# Distributed Deductive System Sorts

ddss-0.0.6/ddss.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+ddss/ds.py
+ddss/egg.py
+ddss/egraph.py
+ddss/input.py
+ddss/main.py
+ddss/orm.py
+ddss/output.py
+ddss/poly.py
+ddss.egg-info/PKG-INFO
+ddss.egg-info/SOURCES.txt
+ddss.egg-info/dependency_links.txt
+ddss.egg-info/entry_points.txt
+ddss.egg-info/requires.txt
+ddss.egg-info/top_level.txt

ddss-0.0.6/ddss.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ddss-0.0.6/ddss.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ddss = ddss.main:cli

ddss-0.0.6/ddss.egg-info/requires.txt

@@ -0,0 +1,7 @@
+aiomysql>=0.3.2
+aiosqlite>=0.22.0
+apyds>=0.0.7
+apyds-bnf>=0.0.7
+cloudpickle>=3.1.2
+egglog>=12.0.0
+sqlalchemy>=2.0.45

ddss-0.0.6/ddss.egg-info/top_level.txt

@@ -0,0 +1 @@
+ddss

ddss-0.0.6/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "ddss"
+version = "0.0.6"
+description = "Distributed Deductive System Sorts"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "aiomysql>=0.3.2",
+    "aiosqlite>=0.22.0",
+    "apyds>=0.0.7",
+    "apyds-bnf>=0.0.7",
+    "cloudpickle>=3.1.2",
+    "egglog>=12.0.0",
+    "sqlalchemy>=2.0.45",
+]
+
+[project.scripts]
+ddss = "ddss.main:cli"
+
+[tool.ruff]
+line-length = 120

ddss-0.0.6/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+