ambry 0.1.2__tar.gz

ambry-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CocosPYPI
+
+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.

ambry-0.1.2/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: ambry
+Version: 0.1.2
+Summary: A memory-efficient, iterable storage container with a limit.
+Author-email: Your Name <you@example.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yourusername/ambry
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ambry
+
+A memory-efficient iterable storage container with a limit.
+
+## Installation
+
+pip install ambry
+
+## Usage
+
+from ambry import ambry
+
+c = ambry(5, ["a", "b", "c"])
+print(c.contains)  # ['a', 'b', 'c']
+
+## Security warning!
+
+`use_pickle=True` enables pickle serialization. Never unpickle data from untrusted sources — it can execute arbitrary code [citation:15].

ambry-0.1.2/README.md

@@ -0,0 +1,18 @@
+# ambry
+
+A memory-efficient iterable storage container with a limit.
+
+## Installation
+
+pip install ambry
+
+## Usage
+
+from ambry import ambry
+
+c = ambry(5, ["a", "b", "c"])
+print(c.contains)  # ['a', 'b', 'c']
+
+## Security warning!
+
+`use_pickle=True` enables pickle serialization. Never unpickle data from untrusted sources — it can execute arbitrary code [citation:15].

ambry-0.1.2/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ambry"
+version = "0.1.2"
+description = "A memory-efficient, iterable storage container with a limit."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [
+    {name = "Your Name", email = "you@example.com"}
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/yourusername/ambry"
+
+[tool.setuptools]
+package-dir = {"" = "src"}

ambry-0.1.2/setup.cfg

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

ambry-0.1.2/src/ambry/__init__.py

@@ -0,0 +1,240 @@
+"""ambry — a memory-efficient, iterable storage container with a limit."""
+
+import struct
+import pickle
+from collections.abc import Iterable
+
+__version__ = "0.1.2"
+__all__ = ["ambry", "DoorException"]
+
+
+class DoorException(Exception):
+    """Raised when the ambry is closed or destroyed."""
+    pass
+
+
+class ambry:
+    """
+    A memory-efficient iterable storage container with a limit.
+
+    Stores elements serialized in a single bytearray.
+    Supports str, bytes, bool, int, float, tuple, set, frozenset,
+    list, and any other Iterable (converted to list).
+
+    dict is NOT supported (even with use_pickle=True).
+
+    Args:
+        limit: Maximum number of elements (default 32).
+        items: Optional iterable of initial elements.
+        use_pickle: If True, serialize any object via pickle (default False).
+                    WARNING: pickle is insecure with untrusted data.
+    """
+
+    __slots__ = ("_limit", "_data", "_published", "_alive", "_count", "_use_pickle")
+
+    def __init__(self, limit: int = 32, items=None, use_pickle: bool = False):
+        if not isinstance(limit, int) or isinstance(limit, bool):
+            raise TypeError("limit must be an integer")
+        if limit < 0:
+            raise ValueError("limit must be non-negative")
+
+        self._limit = limit
+        self._data = bytearray()
+        self._published = True
+        self._alive = True
+        self._count = 0
+        self._use_pickle = use_pickle
+
+        if items is not None:
+            try:
+                iterator = iter(items)
+            except TypeError:
+                raise TypeError("items must be an iterable")
+            for element in iterator:
+                self.att(element)
+
+    # --- Internal ---
+    def _check(self):
+        if not self._alive:
+            raise DoorException("Ambry has been destroyed")
+        if not self._published:
+            raise DoorException("Ambry is closed")
+
+    def _serialize(self, element) -> bytes:
+        if isinstance(element, dict):
+            raise TypeError("dict is not supported by ambry")
+
+        if self._use_pickle:
+            raw = pickle.dumps(element)
+            return b"P" + struct.pack(">I", len(raw)) + raw
+
+        if isinstance(element, str):
+            raw = element.encode("utf-8")
+            return b"S" + struct.pack(">I", len(raw)) + raw
+        if isinstance(element, bytes):
+            return b"Y" + struct.pack(">I", len(element)) + element
+        if isinstance(element, bool):
+            return b"B" + bytes([element])
+        if isinstance(element, int):
+            return b"I" + struct.pack(">q", element)
+        if isinstance(element, float):
+            return b"F" + struct.pack(">d", element)
+        if isinstance(element, tuple):
+            items = list(element)
+            raw = b"".join(self._serialize(x) for x in items)
+            return b"T" + struct.pack(">I", len(items)) + raw
+        if isinstance(element, frozenset):
+            items = list(element)
+            raw = b"".join(self._serialize(x) for x in items)
+            return b"O" + struct.pack(">I", len(items)) + raw
+        if isinstance(element, set):
+            items = list(element)
+            raw = b"".join(self._serialize(x) for x in items)
+            return b"E" + struct.pack(">I", len(items)) + raw
+        if isinstance(element, list):
+            items = list(element)
+            raw = b"".join(self._serialize(x) for x in items)
+            return b"L" + struct.pack(">I", len(items)) + raw
+        if isinstance(element, Iterable):
+            items = list(element)
+            raw = b"".join(self._serialize(x) for x in items)
+            return b"G" + struct.pack(">I", len(items)) + raw
+        raise TypeError(f"Unsupported type: {type(element).__name__}. Use use_pickle=True for arbitrary objects.")
+
+    def _deserialize(self, buf: memoryview, offset: int):
+        if offset >= len(buf):
+            raise ValueError(f"Buffer underflow at offset {offset}")
+        tag = buf[offset:offset + 1]
+        offset += 1
+
+        if tag == b"P":
+            length = struct.unpack_from(">I", buf, offset)[0]
+            offset += 4
+            raw = bytes(buf[offset:offset + length])
+            return pickle.loads(raw), offset + length
+        if tag == b"S":
+            length = struct.unpack_from(">I", buf, offset)[0]
+            offset += 4
+            value = bytes(buf[offset:offset + length]).decode("utf-8")
+            return value, offset + length
+        if tag == b"Y":
+            length = struct.unpack_from(">I", buf, offset)[0]
+            offset += 4
+            value = bytes(buf[offset:offset + length])
+            return value, offset + length
+        if tag == b"B":
+            return bool(buf[offset]), offset + 1
+        if tag == b"I":
+            value = struct.unpack_from(">q", buf, offset)[0]
+            return value, offset + 8
+        if tag == b"F":
+            value = struct.unpack_from(">d", buf, offset)[0]
+            return value, offset + 8
+
+        if tag in (b"O", b"T", b"E", b"L", b"G"):
+            count = struct.unpack_from(">I", buf, offset)[0]
+            offset += 4
+            items = []
+            for _ in range(count):
+                item, offset = self._deserialize(buf, offset)
+                items.append(item)
+            if tag == b"O":
+                return frozenset(items), offset
+            if tag == b"T":
+                return tuple(items), offset
+            if tag == b"E":
+                return set(items), offset
+            if tag == b"L":
+                return items, offset
+            return items, offset
+
+        raise ValueError(f"Unknown tag: {tag!r}")
+
+    def _all_items(self):
+        offset = 0
+        buf = memoryview(self._data)
+        for _ in range(self._count):
+            item, offset = self._deserialize(buf, offset)
+            yield item
+
+    # --- Public API ---
+    def publish(self):
+        self._published = True
+
+    def private(self):
+        self._published = False
+
+    @property
+    def cangrab(self) -> bool:
+        return self._published
+
+    @property
+    def contains(self):
+        self._check()
+        return list(self._all_items())
+
+    def att(self, element):
+        self._check()
+        if self._count + 1 > self._limit:
+            return
+        self._data += self._serialize(element)
+        self._count += 1
+
+    def disatt(self, index: int):
+        self._check()
+        if not (0 <= index < self._count):
+            raise ValueError(f"Index {index} out of range")
+        items = self.contains
+        del items[index]
+        self._data = bytearray()
+        self._count = 0
+        for item in items:
+            self._data += self._serialize(item)
+            self._count += 1
+
+    def disact(self, arg: list = None):
+        if not self._alive:
+            raise DoorException("Ambry already destroyed")
+        if arg is not None:
+            if not isinstance(arg, list):
+                raise TypeError("arg must be a list or None")
+            arg.extend(self._all_items())
+        self._alive = False
+        self._data = bytearray()
+        self._count = 0
+
+    # --- Class methods ---
+    @classmethod
+    def filter(cls, iterable, predicate, limit=32):
+        return cls(limit, (x for x in iterable if predicate(x)))
+
+    @classmethod
+    def merge(cls, *iterables, limit=32):
+        def chain():
+            for it in iterables:
+                yield from it
+        return cls(limit, chain())
+
+    @classmethod
+    def from_file(cls, path, fmt, limit=32):
+        s = struct.Struct(fmt)
+        with open(path, "rb") as f:
+            raw = f.read()
+        if len(raw) % s.size != 0:
+            raise ValueError("File size is not a multiple of struct size")
+        elements = (s.unpack_from(raw, i)[0] for i in range(0, len(raw), s.size))
+        return cls(limit, elements)
+
+    # --- Dunder ---
+    def __len__(self):
+        return self._count
+
+    def __iter__(self):
+        self._check()
+        return self._all_items()
+
+    def __repr__(self):
+        state = "open" if self._published else "closed"
+        if not self._alive:
+            state = "dead"
+        return f"<ambry {state}, {self._count}/{self._limit}>"

ambry-0.1.2/src/ambry.egg-info/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: ambry
+Version: 0.1.2
+Summary: A memory-efficient, iterable storage container with a limit.
+Author-email: Your Name <you@example.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/yourusername/ambry
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ambry
+
+A memory-efficient iterable storage container with a limit.
+
+## Installation
+
+pip install ambry
+
+## Usage
+
+from ambry import ambry
+
+c = ambry(5, ["a", "b", "c"])
+print(c.contains)  # ['a', 'b', 'c']
+
+## Security warning!
+
+`use_pickle=True` enables pickle serialization. Never unpickle data from untrusted sources — it can execute arbitrary code [citation:15].

ambry-0.1.2/src/ambry.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+LICENSE
+README.md
+pyproject.toml
+src/ambry/__init__.py
+src/ambry.egg-info/PKG-INFO
+src/ambry.egg-info/SOURCES.txt
+src/ambry.egg-info/dependency_links.txt
+src/ambry.egg-info/top_level.txt

ambry-0.1.2/src/ambry.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ambry-0.1.2/src/ambry.egg-info/top_level.txt

@@ -0,0 +1 @@
+ambry