osmem-server 0.1.1__py3-none-win_amd64.whl

osmem_server/__init__.py

@@ -0,0 +1,182 @@
+"""In-memory OpenSearch-compatible server for tests.
+
+    from osmem_server import OsmemServer
+
+    with OsmemServer.start(seed=["testdata/seed"], freeze=True) as server:
+        with server.clone() as clone:
+            client = OpenSearch(hosts=[clone.url])
+            ...
+
+The pytest plugin (loaded automatically) provides the ``osmem_server``
+(session) and ``osmem_clone`` (function) fixtures; see ``osmem_server.pytest_plugin``.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import platform
+import subprocess
+import sys
+import threading
+import time
+import urllib.error
+import urllib.request
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Iterable, Optional, Sequence, Union
+
+__all__ = ["OsmemServer", "OsmemClone", "OsmemError", "resolve_binary"]
+
+__version__ = "0.1.1"
+
+
+class OsmemError(RuntimeError):
+    """Raised when the server cannot be started or a request fails."""
+
+
+def resolve_binary(binary: Optional[str] = None) -> str:
+    """Locate osmem-server: explicit path, OSMEM_SERVER_BIN, then the bundled binary."""
+    if binary:
+        return binary
+    env = os.environ.get("OSMEM_SERVER_BIN")
+    if env:
+        return env
+    name = "osmem-server.exe" if sys.platform == "win32" else "osmem-server"
+    bundled = Path(__file__).parent / "bin" / name
+    if bundled.exists():
+        return str(bundled)
+    raise OsmemError(
+        f"osmem: no server binary bundled for {sys.platform}/{platform.machine()}; "
+        "install a platform wheel or set OSMEM_SERVER_BIN"
+    )
+
+
+def _request(method: str, url: str, body: Any = None, timeout: float = 30.0) -> Any:
+    data = None if body is None else json.dumps(body).encode()
+    req = urllib.request.Request(url, data=data, method=method, headers={"Content-Type": "application/json"})
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            text = resp.read().decode()
+    except urllib.error.HTTPError as e:
+        text = e.read().decode()
+        try:
+            err = json.loads(text).get("error", text)
+            detail = f"{err.get('type')}: {err.get('reason')}" if isinstance(err, dict) else str(err)
+        except ValueError:
+            detail = text
+        raise OsmemError(f"osmem: {method} {url}: {e.code} {detail}") from None
+    return json.loads(text) if text else {}
+
+
+@dataclass
+class OsmemClone:
+    """A clone of the base cluster served on its own port."""
+
+    server: "OsmemServer"
+    id: str
+    url: str
+
+    def close(self) -> None:
+        try:
+            _request("DELETE", f"{self.server.url}/_osmem/clones/{self.id}")
+        except OsmemError:
+            pass
+
+    def __enter__(self) -> "OsmemClone":
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self.close()
+
+
+@dataclass
+class OsmemServer:
+    """A running osmem-server process hosting a base cluster."""
+
+    process: subprocess.Popen
+    url: str
+    pid: int
+    version: str
+    japanese: bool
+    indices: list = field(default_factory=list)
+
+    @classmethod
+    def start(
+        cls,
+        seed: Union[None, str, os.PathLike, Sequence[Union[str, os.PathLike]]] = None,
+        *,
+        freeze: bool = False,
+        japanese: bool = True,
+        addr: Optional[str] = None,
+        binary: Optional[str] = None,
+        startup_timeout: float = 30.0,
+    ) -> "OsmemServer":
+        """Start the server and wait until it is ready."""
+        args = [resolve_binary(binary), "--parent-pid", str(os.getpid())]
+        seeds: Iterable[Any] = [] if seed is None else ([seed] if isinstance(seed, (str, os.PathLike)) else seed)
+        for s in seeds:
+            args += ["--seed", os.fspath(s)]
+        if freeze:
+            args.append("--freeze")
+        if not japanese:
+            args.append("--no-ja")
+        if addr:
+            args += ["--addr", addr]
+        proc = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=None, text=True)
+        ready: dict = {}
+        error: list = []
+
+        def reader() -> None:
+            assert proc.stdout is not None
+            for line in proc.stdout:
+                try:
+                    msg = json.loads(line)
+                except ValueError:
+                    continue
+                if isinstance(msg, dict) and "url" in msg:
+                    ready.update(msg)
+                    return
+            error.append("server exited during startup")
+
+        t = threading.Thread(target=reader, daemon=True)
+        t.start()
+        t.join(startup_timeout)
+        if not ready:
+            proc.kill()
+            raise OsmemError("osmem: " + (error[0] if error else f"server did not start within {startup_timeout} s"))
+        return cls(proc, ready["url"], ready.get("pid", proc.pid), ready.get("version", ""), ready.get("japanese", False), list(ready.get("indices", [])))
+
+    def clone(self) -> OsmemClone:
+        """Create a clone served on its own port; freezes the base."""
+        res = _request("POST", f"{self.url}/_osmem/clones")
+        return OsmemClone(self, res["id"], res["url"])
+
+    def freeze(self) -> None:
+        _request("POST", f"{self.url}/_osmem/base/freeze")
+
+    def request(self, method: str, path: str, body: Any = None) -> Any:
+        """Any request against the base, decoded as JSON; raises OsmemError on error status."""
+        return _request(method, f"{self.url}{path}", body)
+
+    def close(self, grace: float = 5.0) -> None:
+        """Stop the process: close stdin, then kill after the grace period."""
+        if self.process.poll() is not None:
+            return
+        try:
+            if self.process.stdin:
+                self.process.stdin.close()
+        except OSError:
+            pass
+        deadline = time.monotonic() + grace
+        while self.process.poll() is None and time.monotonic() < deadline:
+            time.sleep(0.05)
+        if self.process.poll() is None:
+            self.process.kill()
+            self.process.wait()
+
+    def __enter__(self) -> "OsmemServer":
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self.close()

osmem_server/pytest_plugin.py

@@ -0,0 +1,51 @@
+"""pytest fixtures for osmem.
+
+Configure the seed in pytest.ini / pyproject.toml::
+
+    [tool.pytest.ini_options]
+    osmem_seed = ["testdata/seed"]
+    osmem_freeze = true
+
+or override the ``osmem_server`` fixture in conftest.py to call
+``OsmemServer.start`` yourself. Tests take ``osmem_clone`` (a fresh clone
+per test, closed afterwards) or ``osmem_server`` (shared, read-only use).
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from osmem_server import OsmemServer
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    parser.addini("osmem_seed", "osmem seed directories or .ndjson files", type="paths", default=[])
+    parser.addini("osmem_freeze", "freeze the osmem base after seeding", type="bool", default=True)
+    parser.addini("osmem_japanese", "enable Japanese analysis in osmem", type="bool", default=True)
+
+
+@pytest.fixture(scope="session")
+def osmem_server(request: pytest.FixtureRequest):
+    """A session-wide osmem-server seeded from the osmem_seed ini option."""
+    cfg = request.config
+    server = OsmemServer.start(
+        seed=[str(p) for p in cfg.getini("osmem_seed")],
+        freeze=cfg.getini("osmem_freeze"),
+        japanese=cfg.getini("osmem_japanese"),
+    )
+    yield server
+    server.close()
+
+
+@pytest.fixture
+def osmem_clone(osmem_server: OsmemServer):
+    """A clone of the base for one test; use ``osmem_clone.url`` with a client."""
+    clone = osmem_server.clone()
+    yield clone
+    clone.close()
+
+
+@pytest.fixture
+def osmem_url(osmem_clone) -> str:
+    """The clone URL, for tests that only need the address."""
+    return osmem_clone.url

osmem_server-0.1.1.dist-info/METADATA

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: osmem-server
+Version: 0.1.1
+Summary: In-memory OpenSearch-compatible server for tests (osmem-server launcher, pytest fixtures)
+License-Expression: MIT
+Project-URL: Repository, https://github.com/shibukawa/osmem
+Keywords: opensearch,elasticsearch,testing,pytest,in-memory
+Classifier: Framework :: Pytest
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# osmem-server
+
+In-memory OpenSearch-compatible server for tests (`pip install osmem-server`).
+The wheel bundles the `osmem-server` binary for your platform; no Docker,
+no JVM. The import name is `osmem_server`.
+
+```python
+# pytest.ini / pyproject.toml
+[tool.pytest.ini_options]
+osmem_seed = ["testdata/seed"]
+```
+
+```python
+from opensearchpy import OpenSearch
+
+def test_search(osmem_clone):
+    client = OpenSearch(hosts=[osmem_clone.url])
+    client.index(index="products", id="x", body={"name": "new"}, refresh=True)
+    assert client.count(index="products")["count"] == 6
+```
+
+Each test gets its own clone of the seeded base cluster (milliseconds,
+copy-on-write); the server itself starts once per session and exits with
+the test process. Without pytest:
+
+```python
+from osmem_server import OsmemServer
+
+with OsmemServer.start(seed=["testdata/seed"]) as server, server.clone() as clone:
+    ...
+```
+
+Set `OSMEM_SERVER_BIN` to use a locally built binary. Seed layout and the
+management API are documented in the
+[osmem repository](https://github.com/shibukawa/osmem).
+
+Full guide: [English](https://shibukawa.github.io/osmem/python/) · [日本語](https://shibukawa.github.io/osmem/ja/python/)

osmem_server-0.1.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+osmem_server/__init__.py,sha256=F9WK5e1NJ4dbBtXF6uGizJg80XgYHjiMDgM0eCOtd7Q,6101
+osmem_server/pytest_plugin.py,sha256=_g0Rx7nIUr6VFyKsaQagT2IZfbaHW7EMTpRiRMSkWuY,1598
+osmem_server/bin/osmem-server.exe,sha256=qkrL7_FWFoxMoNdtu94tCciq9jy84IZRMTFENqcgXpA,27565056
+osmem_server-0.1.1.dist-info/licenses/LICENSE,sha256=-EG0igTVeHkIYfDKGDH47dLaukAH-bCdolHP1EePNDg,1074
+osmem_server-0.1.1.dist-info/METADATA,sha256=j_fMIc-yeiWHpW6IPnqLw87heoTPFlAc_-eyZMjxq3s,1738
+osmem_server-0.1.1.dist-info/WHEEL,sha256=Zx98gwb_dQKckJK3HEOVKnxxD52EfU_PXDG_usMJ2ng,98
+osmem_server-0.1.1.dist-info/entry_points.txt,sha256=wxcpLmhcQ5vEXAgljqllV7UBE7kiEtwc658ZrJknJuc,46
+osmem_server-0.1.1.dist-info/top_level.txt,sha256=w3zz1pOxTpWKZcrNdZqg8yBCmuW6w01Wy0CE1ccOVH0,13
+osmem_server-0.1.1.dist-info/RECORD,,

osmem_server-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: false
+Tag: py3-none-win_amd64
+

osmem_server-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+osmem = osmem_server.pytest_plugin

osmem_server-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yoshiki Shibukawa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

osmem_server-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+osmem_server