moat-db-thing 0.0.1__tar.gz

moat_db_thing-0.0.1/LICENSE.txt

@@ -0,0 +1,14 @@
+The code in this repository, and all MoaT submodules it refers to,
+is part of the MoaT project.
+
+Unless a submodule's LICENSE.txt states otherwise, all included files are
+licensed under the LGPL V3, as published by the FSF at
+https://www.gnu.org/licenses/lgpl-3.0.html .
+
+In addition to the LGPL's terms, the author(s) respectfully ask all users of
+this code to contribute any bug fixes or enhancements. Also, please link back to
+https://M-o-a-T.org.
+
+Thank you.
+
+Copyright © 2021 ff.: the MoaT contributor(s), as per the git changelog(s).

moat_db_thing-0.0.1/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: moat-db-thing
+Version: 0.0.1
+Summary: MoaT support for storing info about things
+Author-email: Matthias Urlichs <matthias@urlichs.de>
+Project-URL: homepage, https://m-o-a-t.org
+Project-URL: repository, https://github.com/M-o-a-T/moat
+Keywords: MoaT
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Trio
+Classifier: Framework :: AnyIO
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: anyio~=4.2
+Requires-Dist: asyncclick
+Requires-Dist: attrs
+Requires-Dist: msgpack
+Requires-Dist: moat-util~=0.60.9
+Requires-Dist: moat-db~=0.2.3
+Requires-Dist: moat-label~=0.2.2
+Requires-Dist: moat-box~=0.2.2
+Dynamic: license-file

moat_db_thing-0.0.1/README.md

@@ -0,0 +1,9 @@
+# MoaT-Thing
+
+% start synopsis
+
+This module manages things. As in, the stuff you own.
+
+This is woefully incomplete, more a concept than real code, and a work in progress.
+
+% end synopsis

moat_db_thing-0.0.1/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = [ "setuptools", "wheel",]
+
+[project]
+classifiers = [
+	"Intended Audience :: Developers",
+	"Programming Language :: Python :: 3",
+	"Framework :: AsyncIO",
+	"Framework :: Trio",
+	"Framework :: AnyIO",
+	"Development Status :: 4 - Beta",
+	]
+dependencies = [
+	"anyio ~= 4.2",
+	"asyncclick",
+	"attrs",
+	"msgpack",
+	"moat-util ~= 0.60.9",
+	"moat-db ~= 0.2.3",
+	"moat-label ~= 0.2.2",
+	"moat-box ~= 0.2.2",
+	]
+version = "0.0.1"
+keywords = [ "MoaT",]
+requires-python = ">=3.8"
+name = "moat-db-thing"
+description = "MoaT support for storing info about things"
+readme = "README.rst"
+
+[[project.authors]]
+name = "Matthias Urlichs"
+email = "matthias@urlichs.de"
+
+[project.urls]
+homepage = "https://m-o-a-t.org"
+repository = "https://github.com/M-o-a-T/moat"
+
+[tool.setuptools]
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"*" = ["*.yaml"]

moat_db_thing-0.0.1/setup.cfg

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

moat_db_thing-0.0.1/src/moat/db/thing/__init__.py

@@ -0,0 +1,3 @@
+"""
+This subpackage manages things (stored in a database).
+"""

moat_db_thing-0.0.1/src/moat/db/thing/_main.py

@@ -0,0 +1,232 @@
+"""
+Support for things.
+"""
+
+# The main code must not load any sqlalchemy code.
+# sqlalchemy might not be present.
+
+from __future__ import annotations
+
+import sys
+
+import asyncclick as click
+from sqlalchemy import select
+
+from moat.util import load_subgroup, option_ng, yprint
+from moat.db import database
+
+from .model import Thing, ThingTyp
+
+
+@load_subgroup(prefix="moat.thing", invoke_without_command=False)
+@click.pass_context
+@click.option("--name", "-n", type=str, help="Name of the thing type")
+def cli(ctx, name):
+    """Things."""
+    obj = ctx.obj
+
+    sess = ctx.with_resource(database(obj.cfg.db))
+    ctx.with_resource(sess.begin())
+
+    obj.session = sess
+    obj.name = name
+
+
+@cli.group
+@click.option("--name", "-n", type=str, help="Text on the label")
+@click.pass_obj
+def one(obj, name):
+    """
+    Manage actual things.
+    """
+    obj.name = name
+    pass
+
+
+@one.command(name="show")
+@click.option("--type", "-t", "type_", type=str, help="Type of thing to list")
+@click.pass_obj
+def show_(obj, type_):
+    """
+    Show thing details / list all things of a type.
+
+    If a name is set, show details for this thing.
+    Otherwise list all things without storage.
+    """
+    sess = obj.session
+
+    if obj.name is not None:
+        thing = sess.one(Thing, name=obj.name)
+        yprint(thing.dump())
+        return
+
+    sel = select(Thing)
+    if type_ is None:
+        sel = sel.where(Thing.container == None)  # noqa:E711
+    else:
+        ttyp = obj.session.one(ThingTyp, name=type_)
+        sel = sel.where(Thing.thingtyp == ttyp)
+    with sess.execute(select(Thing).where(Thing.container == None)) as things:  # noqa:E711
+        for (thing,) in things:
+            print(thing.name, thing.descr)
+
+
+def opts(c):
+    c = option_ng("--name", "-n", type=str, help="Rename this thing")(c)
+    c = option_ng("--x", "-x", "pos_x", type=int, help="X position in parent")(c)
+    c = option_ng("--y", "-y", "pos_y", type=int, help="Y position in parent")(c)
+    c = option_ng("--z", "-z", "pos_z", type=int, help="Z position in parent")(c)
+    c = option_ng("--in", "-i", "container", type=str, help="Where is it?")(c)
+    c = option_ng("--typ", "-t", "thingtyp", type=str, help="Type of the thing")(c)
+    c = option_ng("--descr", "-d", "descr", type=str, help="Description of the thing")(c)
+    c = option_ng("--comment", "-c", type=str, help="Additional comments")(c)
+    c = option_ng("--label", "-l", type=str, help="Label for this thing")(c)
+    return c
+
+
+@one.command()
+@opts
+@click.pass_obj
+def add(obj, **kw):
+    """
+    Add a thing.
+    """
+    if obj.name is None:
+        raise click.UsageError("The thing needs a name!")
+
+    try:
+        thing = obj.session.one(Thing, name=obj.name)
+    except KeyError:
+        pass
+    else:
+        print("This thing already exists", file=sys.stderr)
+        sys.exit(1)
+    thing = Thing(name=obj.name)
+    obj.session.add(thing)
+    thing.apply(**kw)
+
+
+@one.command(epilog="Use '-x/-y/-z 0' to clear a position, '--in -' to remove the location.")
+@opts
+@click.pass_obj
+def set(obj, **kw):  # noqa: A001
+    """
+    Modify a thing.
+    """
+    if obj.name is None:
+        raise click.UsageError("Which thing? Use a name")
+
+    try:
+        thing = obj.session.one(Thing, name=obj.name)
+    except KeyError:
+        print("This thing doesn't exist", file=sys.stderr)
+        sys.exit(1)
+    thing.apply(**kw)
+
+
+@one.command()
+@click.pass_obj
+def delete(obj):
+    """
+    Permanently remove a thing.
+    """
+    if obj.name is None:
+        raise click.UsageError("Which thing? Use a name")
+    try:
+        thing = obj.session.one(Thing, name=obj.name)
+    except KeyError:
+        print("This thing doesn't exist", file=sys.stderr)
+        sys.exit(1)
+    obj.session.delete(thing)
+
+
+@cli.group(name="typ")
+@click.option("--name", "-n", type=str, help="Name of the type")
+@click.pass_context
+def typ_(ctx, name):
+    """\
+    Manage a hierarchy of types of things.
+    """
+    obj = ctx.obj
+    if obj.name is not None:
+        raise click.UsageError("Please use 'thing typ -n NAME'")
+    obj.name = name
+
+
+@typ_.command(name="show")
+@click.pass_obj
+def typ_show(obj):
+    """
+    Show thing details / list all thing types.
+
+    If a name is set, show details for this type.
+    Otherwise list all known thing types.
+    """
+    sess = obj.session
+
+    if obj.name is None:
+        seen = False
+        with sess.execute(select(ThingTyp)) as things:
+            for (thing,) in things:
+                seen = True
+                print(thing.name)
+        if not seen:
+            print("No thing types defined yet. Use '--help'?", file=sys.stderr)
+    else:
+        thing = sess.one(ThingTyp, name=obj.name)
+        yprint(thing.dump())
+
+
+def typopts(c):
+    c = option_ng("--name", "-n", type=str, help="Rename this type")(c)
+    c = option_ng("--parent", "-p", type=str, help="Parent of this type")(c)
+    c = click.option(
+        "--abstract",
+        "-a",
+        is_flag=True,
+        help="This type can't contain a real thing",
+    )(c)
+    c = click.option("--real", "-A", is_flag=True, help="This type can have a real thing")(c)
+    c = option_ng("--comment", "-c", "comment", type=str, help="Description of this type")(c)
+    return c
+
+
+@typ_.command(name="add")
+@typopts
+@click.pass_obj
+def typ_add(obj, **kw):
+    """
+    Add a thing type.
+    """
+    if obj.name is None:
+        raise click.UsageError("The thing type needs a name!")
+
+    bt = ThingTyp(name=obj.name)
+    obj.session.add(bt)
+    bt.apply(**kw)
+
+
+@typ_.command(name="set", epilog="Use '-i -NAME' to remove a containing thing type.")
+@typopts
+@click.pass_obj
+def typ_set(obj, **kw):
+    """
+    Modify a thing type.
+    """
+    if obj.name is None:
+        raise click.UsageError("Which thing type? Use a name")
+
+    bt = obj.session.one(ThingTyp, name=obj.name)
+    bt.apply(**kw)
+
+
+@typ_.command(name="delete")
+@click.pass_obj
+def typ_delete(obj):
+    """
+    Remove a thing type.
+    """
+    if obj.name is None:
+        raise click.UsageError("Which thing type? Use a name")
+    bt = obj.session.one(ThingTyp, name=obj.name)
+    obj.session.delete(bt)

moat_db_thing-0.0.1/src/moat/db/thing/model.py

@@ -0,0 +1,111 @@
+"""
+Database schema for collecting things
+"""
+
+from __future__ import annotations
+
+from sqlalchemy import ForeignKey, String, event
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from moat.db.schema import Base
+
+
+class ThingTyp(Base):
+    "One kind of thing."
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    name: Mapped[str] = mapped_column(unique=True, type_=String(40))
+    comment: Mapped[str] = mapped_column(type_=String(200), nullable=True)
+
+    parent_id: Mapped[int] = mapped_column(
+        ForeignKey("thingtyp.id", name="fk_thingtyp_typ"),
+        nullable=True,
+    )
+    parent: Mapped[ThingTyp] = relationship(
+        "ThingTyp",
+        back_populates="children",
+        remote_side=[id],
+    )
+
+    abstract: Mapped[bool] = mapped_column(
+        nullable=False,
+        default=False,
+        server_default="0",
+        comment="Must be False for instantiating things with this type",
+    )
+    children: Mapped[set[ThingTyp]] = relationship("ThingTyp", back_populates="parent")
+    things: Mapped[set[Thing]] = relationship(back_populates="thingtyp")
+
+    def dump(self):  # noqa: D102
+        res = super().dump()
+        if self.parent:
+            res["parent"] = self.parent.name
+        if self.children:
+            res["child"] = [p.name for p in self.children]
+        if self.things:
+            res["things"] = len(self.things)
+        return res
+
+
+class Thing(Base):
+    "One particular thing"
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+
+    typ_id: Mapped[int] = mapped_column(ForeignKey("thingtyp.id", name="fk_thing_typ"))
+    name: Mapped[str] = mapped_column(unique=True, type_=String(40))
+    descr: Mapped[str] = mapped_column(type_=String(200), nullable=True)
+    comment: Mapped[str] = mapped_column(type_=String(200), nullable=True)
+
+    box_id: Mapped[int] = mapped_column(ForeignKey("box.id", name="fk_thing_box"), nullable=True)
+
+    thingtyp: Mapped[ThingTyp] = relationship(back_populates="things")
+
+    # possibly the location within its parent
+    pos_x: Mapped[int] = mapped_column(nullable=True, comment="X position in parent")
+    pos_y: Mapped[int] = mapped_column(nullable=True, comment="Y position in parent")
+    pos_z: Mapped[int] = mapped_column(nullable=True, comment="Z position in parent")
+
+    def dump(self):  # noqa: D102
+        res = super().dump()
+        res.pop("pos_x", None)
+        res.pop("pos_y", None)
+        res.pop("pos_z", None)
+        if self.pos_x or self.pos_y or self.pos_z:
+            res["pos"] = [self.pos_x, self.pos_y, self.pos_z]
+        if self.container is not None:
+            res["in"] = self.container.name
+        if self.labels:
+            res["labels"] = [f"{lab.id}:{lab.text}" for lab in self.labels]
+        if self.thingtyp:
+            res["typ"] = self.thingtyp.name
+        return res
+
+
+@event.listens_for(Thing, "before_insert")
+@event.listens_for(Thing, "before_update")
+def validate_thing_coords(mapper, connection, model):  # noqa: D103
+    mapper, connection  # noqa:B018
+    par = model.container
+    if par is not None:
+        par = par.boxtyp
+
+    def chk(p):
+        pp = f"pos_{p}"
+        ppos = getattr(par, pp, None)
+
+        if (pos := getattr(model, pp)) is None:
+            if ppos is not None and ppos > 1:
+                raise ValueError(f"Thing {model.name} needs a value for {p}")
+        elif pos <= 0:
+            raise ValueError(f"Thing {model.name} can't set {p} <= 0")
+        elif par is None:
+            raise ValueError(f"Thing {model.name} is not in a sized container")
+        elif ppos is None:
+            raise ValueError(f"Thing {model.name} can't have a value for {p}")
+        elif ppos < pos:
+            raise ValueError(f"Thing {model.name}: {p} is {pos}, max is {ppos}")
+
+    chk("x")
+    chk("y")
+    chk("z")

moat_db_thing-0.0.1/src/moat/db/thing/model_.py

@@ -0,0 +1,94 @@
+"""
+Database schema for collecting things
+"""
+
+from __future__ import annotations
+
+from sqlalchemy import func, select
+from sqlalchemy.orm import relationship
+
+from moat.util import NotGiven
+from moat.box.model import Box
+from moat.db.schema import Base
+from moat.db.util import session
+from moat.label.model import Label
+
+from .model import Thing, ThingTyp
+
+Thing.labels = relationship(Label, back_populates="thing", collection_class=set)
+Thing.container = relationship(Box, back_populates="things")
+
+
+def thing_apply(self, label=NotGiven, container=NotGiven, thingtyp=NotGiven, **kw):  # noqa: D103
+    sess = session.get()
+    with sess.no_autoflush:
+        Base.apply(self, **kw)
+
+        if container is NotGiven:
+            pass
+        elif container is None or container == "-":
+            self.container = None
+        else:
+            box = sess.one(Box, name=container)
+            if not box.boxtype.usable:
+                raise ValueError("You can't put anything into a {box.boxtype.name !r}.")
+            self.container = box
+
+        if label is NotGiven:
+            pass
+        elif label is None or label == "-":
+            self.label = None
+        else:
+            self.label = sess.one(Label, name=label)
+
+        if thingtyp is NotGiven:
+            if self.thingtyp is None:
+                raise ValueError("New things need a type")
+        elif thingtyp is None:
+            raise ValueError("Things need a type")
+        else:
+            if self.thingtyp is None:
+                ttyp = sess.one(ThingTyp, name=thingtyp)
+                if ttyp.abstract:
+                    raise ValueError("Things need a non-abstract type")
+                self.thingtyp = ttyp
+            elif self.thingtyp.name != thingtyp:
+                raise ValueError("Thing types cannot be changed")
+
+
+Thing.apply = thing_apply
+
+
+def thingtyp_apply(self, parent=NotGiven, abstract=False, real=False, **kw):  # noqa: D103
+    if abstract:
+        if real:
+            raise ValueError("A type can't be both 'abstract' and 'real'.")
+        kw["abstract"] = True
+    elif real:
+        kw["abstract"] = False
+
+    Base.apply(self, **kw)
+
+    sess = session.get()
+
+    if parent is NotGiven:
+        parent = self.parent.name if self.parent is not None else None
+    if parent is None:
+        (n,) = sess.execute(
+            select(func.count(ThingTyp.id))
+            .where(ThingTyp.parent == None)  # noqa:E711
+            .where(ThingTyp.name != self.name),
+        ).first()
+        if n:
+            raise ValueError("Only one top entry allowed")
+    else:
+        par = sess.one(ThingTyp, name=parent)
+        p = par
+        while p is not None:
+            if p == self:
+                raise ValueError("No cycles allowed.")
+            p = p.parent
+        self.parent = par
+
+
+ThingTyp.apply = thingtyp_apply

moat_db_thing-0.0.1/src/moat_db_thing.egg-info/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: moat-db-thing
+Version: 0.0.1
+Summary: MoaT support for storing info about things
+Author-email: Matthias Urlichs <matthias@urlichs.de>
+Project-URL: homepage, https://m-o-a-t.org
+Project-URL: repository, https://github.com/M-o-a-T/moat
+Keywords: MoaT
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Trio
+Classifier: Framework :: AnyIO
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: anyio~=4.2
+Requires-Dist: asyncclick
+Requires-Dist: attrs
+Requires-Dist: msgpack
+Requires-Dist: moat-util~=0.60.9
+Requires-Dist: moat-db~=0.2.3
+Requires-Dist: moat-label~=0.2.2
+Requires-Dist: moat-box~=0.2.2
+Dynamic: license-file

moat_db_thing-0.0.1/src/moat_db_thing.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE.txt
+README.md
+pyproject.toml
+src/moat/db/thing/__init__.py
+src/moat/db/thing/_main.py
+src/moat/db/thing/model.py
+src/moat/db/thing/model_.py
+src/moat_db_thing.egg-info/PKG-INFO
+src/moat_db_thing.egg-info/SOURCES.txt
+src/moat_db_thing.egg-info/dependency_links.txt
+src/moat_db_thing.egg-info/requires.txt
+src/moat_db_thing.egg-info/top_level.txt

moat_db_thing-0.0.1/src/moat_db_thing.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

moat_db_thing-0.0.1/src/moat_db_thing.egg-info/requires.txt

@@ -0,0 +1,8 @@
+anyio~=4.2
+asyncclick
+attrs
+moat-box~=0.2.2
+moat-db~=0.2.3
+moat-label~=0.2.2
+moat-util~=0.60.9
+msgpack

moat_db_thing-0.0.1/src/moat_db_thing.egg-info/top_level.txt

@@ -0,0 +1 @@
+moat