brik64 0.1.0b5__tar.gz

brik64-0.1.0b5/LICENSE

@@ -0,0 +1,3 @@
+Apache License, Version 2.0
+Copyright 2026 BRIK-64 Inc.
+http://www.apache.org/licenses/LICENSE-2.0

brik64-0.1.0b5/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: brik64
+Version: 0.1.0b5
+Summary: BRIK64 Python SDK beta for monomer helpers and EVA composition patterns aligned with CLI 0.1.0-beta.5.
+Author-email: BRIK64 INC <info@brik64.com>
+License: Apache License, Version 2.0
+        Copyright 2026 BRIK-64 Inc.
+        http://www.apache.org/licenses/LICENSE-2.0
+        
+Project-URL: Homepage, https://brik64.com
+Project-URL: Repository, https://github.com/brik64/brik64-lib-python
+Keywords: brik64,digital-circuitality,monomers,pcd,sdk
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# brik64
+
+Python SDK beta for BRIK64 monomer helpers and EVA composition patterns.
+
+Current SDK beta: `0.1.0b5`
+Aligned CLI beta: `0.1.0-beta.5`
+
+## Install
+
+```bash
+pip install brik64==0.1.0b5
+```
+
+The BRIK64 CLI is distributed separately in beta5:
+
+```bash
+curl -fsSL https://brik64.com/cli/install.sh | bash
+```
+
+## Usage
+
+```python
+from brik64.mc.arithmetic import add8, mul8
+from brik64.eva import seq
+
+double_then_triple = seq(lambda x: x + x, lambda x: x * 3)
+print(double_then_triple(5))  # 30
+print(add8(200, 100))         # 44 (wrapping)
+```
+
+## Beta Boundary
+
+This package is a beta SDK surface for Python projects. It is useful for
+examples, local integration, and working with BRIK64-style monomer and EVA
+concepts in application code.
+
+It does not by itself establish formal certification, N5/L5+N5 status,
+self-hosting, fixpoint, production approval, or CLI installation.
+
+## Public References
+
+- Website: https://brik64.com
+- Docs: https://docs.brik64.com
+- CLI release: https://github.com/brik64/brik64-cli/releases/tag/v0.1.0-beta.5
+
+## Beta5 Release Boundary
+
+This repository is aligned to the beta5 CLI contract, but marketplace
+publication is blocked until the beta5 release surface gate authorizes SDK
+publication.
+
+## License
+
+See [LICENSE](LICENSE).

brik64-0.1.0b5/README.md

@@ -0,0 +1,54 @@
+# brik64
+
+Python SDK beta for BRIK64 monomer helpers and EVA composition patterns.
+
+Current SDK beta: `0.1.0b5`
+Aligned CLI beta: `0.1.0-beta.5`
+
+## Install
+
+```bash
+pip install brik64==0.1.0b5
+```
+
+The BRIK64 CLI is distributed separately in beta5:
+
+```bash
+curl -fsSL https://brik64.com/cli/install.sh | bash
+```
+
+## Usage
+
+```python
+from brik64.mc.arithmetic import add8, mul8
+from brik64.eva import seq
+
+double_then_triple = seq(lambda x: x + x, lambda x: x * 3)
+print(double_then_triple(5))  # 30
+print(add8(200, 100))         # 44 (wrapping)
+```
+
+## Beta Boundary
+
+This package is a beta SDK surface for Python projects. It is useful for
+examples, local integration, and working with BRIK64-style monomer and EVA
+concepts in application code.
+
+It does not by itself establish formal certification, N5/L5+N5 status,
+self-hosting, fixpoint, production approval, or CLI installation.
+
+## Public References
+
+- Website: https://brik64.com
+- Docs: https://docs.brik64.com
+- CLI release: https://github.com/brik64/brik64-cli/releases/tag/v0.1.0-beta.5
+
+## Beta5 Release Boundary
+
+This repository is aligned to the beta5 CLI contract, but marketplace
+publication is blocked until the beta5 release surface gate authorizes SDK
+publication.
+
+## License
+
+See [LICENSE](LICENSE).

brik64-0.1.0b5/brik64/__init__.py

@@ -0,0 +1,7 @@
+"""BRIK64 Python SDK beta for monomer helpers and EVA composition."""
+
+__version__ = "0.1.0b5"
+
+from brik64 import mc, eva
+
+__all__ = ["mc", "eva", "__version__"]

brik64-0.1.0b5/brik64/eva/__init__.py

@@ -0,0 +1,59 @@
+"""EVA Algebra — composition operators for monomers."""
+
+from typing import Any, Callable
+
+F = Callable[..., Any]
+
+
+def seq(f: F, g: F) -> F:
+    """Sequential composition: g(f(x))."""
+    def _seq(*args: Any, **kwargs: Any) -> Any:
+        return g(f(*args, **kwargs))
+    return _seq
+
+
+def par(f: F, g: F) -> Callable[[Any, Any], tuple[Any, Any]]:
+    """Parallel composition: (f(a), g(b))."""
+    def _apply(fn: F, value: Any) -> Any:
+        if isinstance(value, (tuple, list)):
+            return fn(*value)
+        return fn(value)
+
+    def _par(a: Any, b: Any) -> tuple[Any, Any]:
+        return (_apply(f, a), _apply(g, b))
+    return _par
+
+
+def cond(predicate: Callable[[Any], bool], then_fn: F, else_fn: F) -> F:
+    """Conditional composition: then_fn(x) if predicate(x) else else_fn(x)."""
+    def _cond(*args: Any, **kwargs: Any) -> Any:
+        if predicate(*args, **kwargs):
+            return then_fn(*args, **kwargs)
+        return else_fn(*args, **kwargs)
+    return _cond
+
+
+def pipeline(*args: Any) -> Any:
+    """Chain functions sequentially.
+
+    Supports both `pipeline(f1, f2)(value)` and `pipeline(value, [f1, f2])`.
+    """
+    if len(args) == 2 and isinstance(args[1], list):
+        result = args[0]
+        for fn in args[1]:
+            result = fn(result)
+        return result
+
+    fns = args
+
+    def _pipeline(*args: Any, **kwargs: Any) -> Any:
+        result = fns[0](*args, **kwargs)
+        for fn in fns[1:]:
+            result = fn(result)
+        return result
+    return _pipeline
+
+
+def compose(*fns: F) -> F:
+    """Reverse pipeline: f1(f2(...fN(x)))."""
+    return pipeline(*reversed(fns))

brik64-0.1.0b5/brik64/mc/__init__.py

@@ -0,0 +1,31 @@
+"""Monomer Catalog — all 8 core + 8 extended families."""
+
+from brik64.mc import (
+    arithmetic,
+    logic,
+    memory,
+    control,
+    io,
+    string,
+    crypto,
+    system,
+    float64,
+    math_ops,
+    network,
+    graphics,
+    audio,
+    filesystem,
+    concurrency,
+    interop,
+)
+from brik64.mc.arithmetic import abs8, add8, clamp, dec, div8, inc, mod8, mul8, sub8
+from brik64.mc.logic import and8, not8, or8, rol, ror, shl, shr, xor8
+
+__all__ = [
+    "arithmetic", "logic", "memory", "control",
+    "io", "string", "crypto", "system",
+    "float64", "math_ops", "network", "graphics",
+    "audio", "filesystem", "concurrency", "interop",
+    "abs8", "add8", "clamp", "dec", "div8", "inc", "mod8", "mul8", "sub8",
+    "and8", "not8", "or8", "rol", "ror", "shl", "shr", "xor8",
+]

brik64-0.1.0b5/brik64/mc/arithmetic.py

@@ -0,0 +1,41 @@
+"""Arithmetic monomers — wrapping 8-bit unsigned."""
+
+
+def add8(a: int, b: int) -> int:
+    return (a + b) & 0xFF
+
+
+def sub8(a: int, b: int) -> int:
+    return (a - b) & 0xFF
+
+
+def mul8(a: int, b: int) -> int:
+    return (a * b) & 0xFF
+
+
+def div8(a: int, b: int) -> tuple[int, int]:
+    if b == 0:
+        raise ZeroDivisionError("div8: division by zero")
+    return (a // b, a % b)
+
+
+def mod8(a: int, b: int) -> int:
+    if b == 0:
+        raise ZeroDivisionError("mod8: division by zero")
+    return (a % b) & 0xFF
+
+
+def inc(a: int) -> int:
+    return (a + 1) & 0xFF
+
+
+def dec(a: int) -> int:
+    return (a - 1) & 0xFF
+
+
+def abs8(a: int) -> int:
+    return a & 0xFF
+
+
+def clamp(value: int, minimum: int, maximum: int) -> int:
+    return max(minimum, min(maximum, value))

brik64-0.1.0b5/brik64/mc/audio.py

@@ -0,0 +1,35 @@
+"""Audio monomers — stubs."""
+
+_STUB = "Extended monomer stub"
+
+
+def aud_create(sample_rate: int, channels: int) -> int:
+    raise NotImplementedError(_STUB)
+
+
+def aud_play(buf: int) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def aud_stop(buf: int) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def aud_write(buf: int, data: bytes) -> int:
+    raise NotImplementedError(_STUB)
+
+
+def aud_read(buf: int, size: int) -> bytes:
+    raise NotImplementedError(_STUB)
+
+
+def aud_volume(buf: int, level: float) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def aud_rate(buf: int) -> int:
+    raise NotImplementedError(_STUB)
+
+
+def aud_chans(buf: int) -> int:
+    raise NotImplementedError(_STUB)

brik64-0.1.0b5/brik64/mc/concurrency.py

@@ -0,0 +1,37 @@
+"""Concurrency monomers — stubs."""
+
+from typing import Any
+
+_STUB = "Extended monomer stub"
+
+
+def spawn(fn: Any) -> int:
+    raise NotImplementedError(_STUB)
+
+
+def join(tid: int) -> Any:
+    raise NotImplementedError(_STUB)
+
+
+def chan_new() -> int:
+    raise NotImplementedError(_STUB)
+
+
+def chan_send(ch: int, val: Any) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def chan_recv(ch: int) -> Any:
+    raise NotImplementedError(_STUB)
+
+
+def mutex_new() -> int:
+    raise NotImplementedError(_STUB)
+
+
+def mutex_lock(m: int) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def mutex_unlock(m: int) -> None:
+    raise NotImplementedError(_STUB)

brik64-0.1.0b5/brik64/mc/control.py

@@ -0,0 +1,37 @@
+"""Control monomers — stubs."""
+
+from typing import Any, Callable
+
+_STUB = "Extended monomer stub"
+
+
+def if_then(cond: bool, then_fn: Callable[[], Any]) -> Any | None:
+    raise NotImplementedError(_STUB)
+
+
+def loop_n(n: int, body: Callable[[int], Any]) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def call(fn: Callable[..., Any], *args: Any) -> Any:
+    raise NotImplementedError(_STUB)
+
+
+def ret(val: Any) -> Any:
+    raise NotImplementedError(_STUB)
+
+
+def break_op() -> None:
+    raise NotImplementedError(_STUB)
+
+
+def continue_op() -> None:
+    raise NotImplementedError(_STUB)
+
+
+def nop() -> None:
+    raise NotImplementedError(_STUB)
+
+
+def exit_op(code: int = 0) -> None:
+    raise NotImplementedError(_STUB)

brik64-0.1.0b5/brik64/mc/crypto.py

@@ -0,0 +1,39 @@
+"""Crypto monomers — hash_sha256 real, rest stubs."""
+
+import hashlib
+
+_STUB = "Extended monomer stub"
+
+
+def hash_sha256(data: bytes | str) -> str:
+    if isinstance(data, str):
+        data = data.encode("utf-8")
+    return hashlib.sha256(data).hexdigest()
+
+
+def encrypt(data: bytes, key: bytes) -> bytes:
+    raise NotImplementedError(_STUB)
+
+
+def decrypt(data: bytes, key: bytes) -> bytes:
+    raise NotImplementedError(_STUB)
+
+
+def sign(data: bytes, key: bytes) -> bytes:
+    raise NotImplementedError(_STUB)
+
+
+def verify(data: bytes, signature: bytes, key: bytes) -> bool:
+    raise NotImplementedError(_STUB)
+
+
+def rng(n: int) -> bytes:
+    raise NotImplementedError(_STUB)
+
+
+def derive(key: bytes, salt: bytes) -> bytes:
+    raise NotImplementedError(_STUB)
+
+
+def seal(data: bytes, key: bytes) -> bytes:
+    raise NotImplementedError(_STUB)

brik64-0.1.0b5/brik64/mc/filesystem.py

@@ -0,0 +1,35 @@
+"""Filesystem monomers — stubs."""
+
+_STUB = "Extended monomer stub"
+
+
+def fs_stat(path: str) -> dict[str, int]:
+    raise NotImplementedError(_STUB)
+
+
+def fs_mkdir(path: str) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def fs_rmdir(path: str) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def fs_list(path: str) -> list[str]:
+    raise NotImplementedError(_STUB)
+
+
+def fs_rename(src: str, dst: str) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def fs_remove(path: str) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def fs_exists(path: str) -> bool:
+    raise NotImplementedError(_STUB)
+
+
+def fs_copy(src: str, dst: str) -> None:
+    raise NotImplementedError(_STUB)

brik64-0.1.0b5/brik64/mc/float64.py

@@ -0,0 +1,37 @@
+"""Float64 monomers — real f64 math."""
+
+import math
+
+
+def fadd(a: float, b: float) -> float:
+    return a + b
+
+
+def fsub(a: float, b: float) -> float:
+    return a - b
+
+
+def fmul(a: float, b: float) -> float:
+    return a * b
+
+
+def fdiv(a: float, b: float) -> float:
+    if b == 0.0:
+        raise ZeroDivisionError("fdiv: division by zero")
+    return a / b
+
+
+def fabs(a: float) -> float:
+    return abs(a)
+
+
+def fneg(a: float) -> float:
+    return -a
+
+
+def fsqrt(a: float) -> float:
+    return math.sqrt(a)
+
+
+def fmod_op(a: float, b: float) -> float:
+    return math.fmod(a, b)

brik64-0.1.0b5/brik64/mc/graphics.py

@@ -0,0 +1,35 @@
+"""Graphics monomers — stubs."""
+
+_STUB = "Extended monomer stub"
+
+
+def fb_create(width: int, height: int) -> int:
+    raise NotImplementedError(_STUB)
+
+
+def fb_pixel(fb: int, x: int, y: int, color: int) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def fb_line(fb: int, x0: int, y0: int, x1: int, y1: int, color: int) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def fb_rect(fb: int, x: int, y: int, w: int, h: int, color: int) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def fb_clear(fb: int, color: int) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def fb_blit(fb: int) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def fb_read(fb: int, x: int, y: int) -> int:
+    raise NotImplementedError(_STUB)
+
+
+def fb_dims(fb: int) -> tuple[int, int]:
+    raise NotImplementedError(_STUB)

brik64-0.1.0b5/brik64/mc/interop.py

@@ -0,0 +1,38 @@
+"""Interop monomers — json real, rest stubs."""
+
+import json as _json
+from typing import Any
+
+_STUB = "Extended monomer stub"
+
+
+def json_encode(obj: Any) -> str:
+    return _json.dumps(obj)
+
+
+def json_decode(s: str) -> Any:
+    return _json.loads(s)
+
+
+def ffi_call(lib: str, fn: str, *args: Any) -> Any:
+    raise NotImplementedError(_STUB)
+
+
+def ffi_load(lib: str) -> int:
+    raise NotImplementedError(_STUB)
+
+
+def ffi_free(handle: int) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def wasm_load(path: str) -> int:
+    raise NotImplementedError(_STUB)
+
+
+def wasm_call(module: int, fn: str, *args: Any) -> Any:
+    raise NotImplementedError(_STUB)
+
+
+def wasm_free(module: int) -> None:
+    raise NotImplementedError(_STUB)

brik64-0.1.0b5/brik64/mc/io.py

@@ -0,0 +1,35 @@
+"""I/O monomers — stubs."""
+
+_STUB = "Extended monomer stub"
+
+
+def read(fd: int, size: int) -> bytes:
+    raise NotImplementedError(_STUB)
+
+
+def write(fd: int, data: bytes) -> int:
+    raise NotImplementedError(_STUB)
+
+
+def open_file(path: str, mode: str = "r") -> int:
+    raise NotImplementedError(_STUB)
+
+
+def close_file(fd: int) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def seek(fd: int, offset: int) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def flush(fd: int) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def eof(fd: int) -> bool:
+    raise NotImplementedError(_STUB)
+
+
+def err(fd: int) -> bool:
+    raise NotImplementedError(_STUB)

brik64-0.1.0b5/brik64/mc/logic.py

@@ -0,0 +1,35 @@
+"""Logic monomers — 8-bit bitwise operations."""
+
+
+def and8(a: int, b: int) -> int:
+    return (a & b) & 0xFF
+
+
+def or8(a: int, b: int) -> int:
+    return (a | b) & 0xFF
+
+
+def xor8(a: int, b: int) -> int:
+    return (a ^ b) & 0xFF
+
+
+def not8(a: int) -> int:
+    return (~a) & 0xFF
+
+
+def shl(a: int, n: int) -> int:
+    return (a << n) & 0xFF
+
+
+def shr(a: int, n: int) -> int:
+    return (a >> n) & 0xFF
+
+
+def rol(a: int, n: int) -> int:
+    n = n % 8
+    return ((a << n) | (a >> (8 - n))) & 0xFF
+
+
+def ror(a: int, n: int) -> int:
+    n = n % 8
+    return ((a >> n) | (a << (8 - n))) & 0xFF

brik64-0.1.0b5/brik64/mc/math_ops.py

@@ -0,0 +1,35 @@
+"""Math monomers — real math.* wrappers."""
+
+import math
+
+
+def sin(x: float) -> float:
+    return math.sin(x)
+
+
+def cos(x: float) -> float:
+    return math.cos(x)
+
+
+def tan(x: float) -> float:
+    return math.tan(x)
+
+
+def exp(x: float) -> float:
+    return math.exp(x)
+
+
+def ln(x: float) -> float:
+    return math.log(x)
+
+
+def log2(x: float) -> float:
+    return math.log2(x)
+
+
+def pow_op(base: float, exponent: float) -> float:
+    return math.pow(base, exponent)
+
+
+def ceil(x: float) -> int:
+    return math.ceil(x)

brik64-0.1.0b5/brik64/mc/memory.py

@@ -0,0 +1,35 @@
+"""Memory monomers — stubs."""
+
+_STUB = "Extended monomer stub"
+
+
+def load(addr: int) -> int:
+    raise NotImplementedError(_STUB)
+
+
+def store(addr: int, val: int) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def push(val: int) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def pop() -> int:
+    raise NotImplementedError(_STUB)
+
+
+def peek() -> int:
+    raise NotImplementedError(_STUB)
+
+
+def dup() -> None:
+    raise NotImplementedError(_STUB)
+
+
+def drop() -> None:
+    raise NotImplementedError(_STUB)
+
+
+def swap() -> None:
+    raise NotImplementedError(_STUB)

brik64-0.1.0b5/brik64/mc/network.py

@@ -0,0 +1,35 @@
+"""Network monomers — stubs."""
+
+_STUB = "Extended monomer stub"
+
+
+def tcp_conn(host: str, port: int) -> int:
+    raise NotImplementedError(_STUB)
+
+
+def tcp_send(fd: int, data: bytes) -> int:
+    raise NotImplementedError(_STUB)
+
+
+def tcp_recv(fd: int, size: int) -> bytes:
+    raise NotImplementedError(_STUB)
+
+
+def tcp_close(fd: int) -> None:
+    raise NotImplementedError(_STUB)
+
+
+def udp_send(host: str, port: int, data: bytes) -> int:
+    raise NotImplementedError(_STUB)
+
+
+def udp_recv(fd: int, size: int) -> bytes:
+    raise NotImplementedError(_STUB)
+
+
+def dns_resolve(hostname: str) -> str:
+    raise NotImplementedError(_STUB)
+
+
+def http_req(url: str, method: str = "GET") -> str:
+    raise NotImplementedError(_STUB)

brik64-0.1.0b5/brik64/mc/string.py

@@ -0,0 +1,35 @@
+"""String monomers — real implementations."""
+
+import re
+
+
+def concat(a: str, b: str) -> str:
+    return a + b
+
+
+def split(s: str, sep: str) -> list[str]:
+    return s.split(sep)
+
+
+def substr(s: str, start: int, length: int) -> str:
+    return s[start:start + length]
+
+
+def len_str(s: str) -> int:
+    return len(s)
+
+
+def upper(s: str) -> str:
+    return s.upper()
+
+
+def lower(s: str) -> str:
+    return s.lower()
+
+
+def trim(s: str) -> str:
+    return s.strip()
+
+
+def match_str(s: str, pattern: str) -> bool:
+    return bool(re.search(pattern, s))

brik64-0.1.0b5/brik64/mc/system.py

@@ -0,0 +1,38 @@
+"""System monomers — time_unix, pid, env_get real, rest stubs."""
+
+import os
+import time
+
+_STUB = "Extended monomer stub"
+
+
+def time_unix() -> int:
+    return int(time.time())
+
+
+def cpu() -> float:
+    raise NotImplementedError(_STUB)
+
+
+def disk() -> dict[str, int]:
+    raise NotImplementedError(_STUB)
+
+
+def net() -> dict[str, int]:
+    raise NotImplementedError(_STUB)
+
+
+def env_get(key: str, default: str | None = None) -> str | None:
+    return os.environ.get(key, default)
+
+
+def pid() -> int:
+    return os.getpid()
+
+
+def thread() -> int:
+    raise NotImplementedError(_STUB)
+
+
+def exec_cmd(cmd: str) -> str:
+    raise NotImplementedError(_STUB)

brik64-0.1.0b5/brik64.egg-info/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: brik64
+Version: 0.1.0b5
+Summary: BRIK64 Python SDK beta for monomer helpers and EVA composition patterns aligned with CLI 0.1.0-beta.5.
+Author-email: BRIK64 INC <info@brik64.com>
+License: Apache License, Version 2.0
+        Copyright 2026 BRIK-64 Inc.
+        http://www.apache.org/licenses/LICENSE-2.0
+        
+Project-URL: Homepage, https://brik64.com
+Project-URL: Repository, https://github.com/brik64/brik64-lib-python
+Keywords: brik64,digital-circuitality,monomers,pcd,sdk
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# brik64
+
+Python SDK beta for BRIK64 monomer helpers and EVA composition patterns.
+
+Current SDK beta: `0.1.0b5`
+Aligned CLI beta: `0.1.0-beta.5`
+
+## Install
+
+```bash
+pip install brik64==0.1.0b5
+```
+
+The BRIK64 CLI is distributed separately in beta5:
+
+```bash
+curl -fsSL https://brik64.com/cli/install.sh | bash
+```
+
+## Usage
+
+```python
+from brik64.mc.arithmetic import add8, mul8
+from brik64.eva import seq
+
+double_then_triple = seq(lambda x: x + x, lambda x: x * 3)
+print(double_then_triple(5))  # 30
+print(add8(200, 100))         # 44 (wrapping)
+```
+
+## Beta Boundary
+
+This package is a beta SDK surface for Python projects. It is useful for
+examples, local integration, and working with BRIK64-style monomer and EVA
+concepts in application code.
+
+It does not by itself establish formal certification, N5/L5+N5 status,
+self-hosting, fixpoint, production approval, or CLI installation.
+
+## Public References
+
+- Website: https://brik64.com
+- Docs: https://docs.brik64.com
+- CLI release: https://github.com/brik64/brik64-cli/releases/tag/v0.1.0-beta.5
+
+## Beta5 Release Boundary
+
+This repository is aligned to the beta5 CLI contract, but marketplace
+publication is blocked until the beta5 release surface gate authorizes SDK
+publication.
+
+## License
+
+See [LICENSE](LICENSE).

brik64-0.1.0b5/brik64.egg-info/SOURCES.txt

@@ -0,0 +1,28 @@
+LICENSE
+README.md
+pyproject.toml
+brik64/__init__.py
+brik64.egg-info/PKG-INFO
+brik64.egg-info/SOURCES.txt
+brik64.egg-info/dependency_links.txt
+brik64.egg-info/top_level.txt
+brik64/eva/__init__.py
+brik64/mc/__init__.py
+brik64/mc/arithmetic.py
+brik64/mc/audio.py
+brik64/mc/concurrency.py
+brik64/mc/control.py
+brik64/mc/crypto.py
+brik64/mc/filesystem.py
+brik64/mc/float64.py
+brik64/mc/graphics.py
+brik64/mc/interop.py
+brik64/mc/io.py
+brik64/mc/logic.py
+brik64/mc/math_ops.py
+brik64/mc/memory.py
+brik64/mc/network.py
+brik64/mc/string.py
+brik64/mc/system.py
+tests/test_arithmetic.py
+tests/test_eva.py

brik64-0.1.0b5/brik64.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

brik64-0.1.0b5/brik64.egg-info/top_level.txt

@@ -0,0 +1 @@
+brik64

brik64-0.1.0b5/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "brik64"
+version = "0.1.0b5"
+description = "BRIK64 Python SDK beta for monomer helpers and EVA composition patterns aligned with CLI 0.1.0-beta.5."
+readme = "README.md"
+license = {file = "LICENSE"}
+requires-python = ">=3.10"
+authors = [{ name = "BRIK64 INC", email = "info@brik64.com" }]
+keywords = ["brik64", "digital-circuitality", "monomers", "pcd", "sdk"]
+
+[tool.setuptools.packages.find]
+include = ["brik64*"]
+
+[project.urls]
+Homepage = "https://brik64.com"
+Repository = "https://github.com/brik64/brik64-lib-python"

brik64-0.1.0b5/setup.cfg

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

brik64-0.1.0b5/tests/test_arithmetic.py

@@ -0,0 +1,41 @@
+from brik64 import mc
+
+
+def test_add8_wraps():
+    assert mc.add8(200, 100) == 44
+    assert mc.add8(10, 20) == 30
+
+
+def test_sub8_wraps():
+    assert mc.sub8(5, 10) == 251
+    assert mc.sub8(20, 5) == 15
+
+
+def test_div8_returns_quotient_remainder():
+    assert mc.div8(17, 5) == (3, 2)
+
+
+def test_div8_fails_closed_on_zero():
+    try:
+        mc.div8(10, 0)
+    except ZeroDivisionError:
+        return
+    raise AssertionError("div8 must fail closed on division by zero")
+
+
+def test_clamp():
+    assert mc.clamp(300, 0, 255) == 255
+    assert mc.clamp(-5, 0, 100) == 0
+    assert mc.clamp(50, 0, 100) == 50
+
+
+def test_mod8_returns_remainder():
+    assert mc.mod8(17, 5) == 2
+
+
+def test_mod8_fails_closed_on_zero():
+    try:
+        mc.mod8(10, 0)
+    except ZeroDivisionError:
+        return
+    raise AssertionError("mod8 must fail closed on division by zero")

brik64-0.1.0b5/tests/test_eva.py

@@ -0,0 +1,30 @@
+from brik64 import mc, eva
+
+
+def test_seq_pipeline():
+    p = eva.seq(
+        lambda pair: mc.add8(pair[0], pair[1]),
+        lambda s: mc.mod8(s, 10),
+    )
+    assert p((7, 8)) == 5  # add8(7,8)=15 -> mod8(15,10)=5
+
+
+def test_par_composition():
+    dual = eva.par(mc.add8, mc.xor8)
+    result = dual((10, 5), (0b1100, 0b1010))
+    assert result == (15, 0b0110)
+
+
+def test_cond_branching():
+    transform = eva.cond(
+        lambda x: x % 2 == 0,
+        lambda x: x * 2,
+        lambda x: x // 2,
+    )
+    assert transform(4) == 8
+    assert transform(5) == 2
+
+
+def test_pipeline_chain():
+    result = eva.pipeline(5, [lambda x: x + 1, lambda x: x * 2, lambda x: x - 3])
+    assert result == 9