brewdoc-linux-x64-glibc 0.0.0-stage → 0.3.2

package/binary/_internal/quickjs_ng-0.17.0.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+uv

package/binary/_internal/quickjs_ng-0.17.0.1.dist-info/METADATA

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: quickjs-ng
+Version: 0.17.0.1
+Summary: Thin Python wrapper of quickjs-ng
+Author-email: Ganesh Viswanathan <dev@genotrance.com>
+Project-URL: Homepage, https://github.com/genotrance/quickjs-ng
+Project-URL: Repository, https://github.com/genotrance/quickjs-ng
+Keywords: quickjs,javascript,embedding
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: <4.0,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# quickjs-ng
+
+[![Build status](https://img.shields.io/github/actions/workflow/status/genotrance/quickjs-ng/main.yml?branch=main)](https://github.com/genotrance/quickjs-ng/actions/workflows/main.yml?query=branch%3Amain)
+[![License](https://img.shields.io/github/license/genotrance/quickjs-ng)](https://img.shields.io/github/license/genotrance/quickjs-ng)
+
+Python wrapper around [quickjs-ng](https://github.com/quickjs-ng/quickjs), the actively maintained fork of the [QuickJS](https://bellard.org/quickjs/) JavaScript engine.
+
+Drop-in replacement for the archived [quickjs](https://github.com/PetterS/quickjs) package — `import quickjs` works unchanged.
+
+## Installation
+
+```bash
+pip install quickjs-ng
+```
+
+Requires Python ≥ 3.10. Pre-built wheels are available for Linux (x86_64, i686, aarch64), Windows (AMD64, x86), and macOS (arm64), for CPython 3.10+ and PyPy 3.10/3.11.
+
+## Usage
+
+```python
+import quickjs
+
+# Evaluate expressions
+ctx = quickjs.Context()
+ctx.eval("1 + 2")  # => 3
+
+# Call JS functions from Python
+ctx.eval("function add(a, b) { return a + b; }")
+add = ctx.get("add")
+add(3, 4)  # => 7
+
+# Call Python functions from JS
+ctx.add_callable("py_add", lambda a, b: a + b)
+ctx.eval("py_add(3, 4)")  # => 7
+
+# Use the Function helper for thread-safe execution
+f = quickjs.Function("f", "function f(x) { return x * 2; }")
+f(21)  # => 42
+
+# Resource limits
+ctx.set_memory_limit(1024 * 1024)  # 1 MB
+ctx.set_time_limit(5)              # 5 seconds of CPU time
+ctx.set_max_stack_size(512 * 1024) # 512 KB stack
+```
+
+## Threading
+
+Each `Context` owns an isolated QuickJS runtime — there is no shared state between contexts. A single `Context` is **not thread-safe** and must not be used from multiple threads.
+
+**Recommended patterns:**
+
+- **Context per thread** — create a separate `Context` in each thread. No locking, no overhead, full parallelism:
+
+  ```python
+  import threading, quickjs
+
+  def worker():
+      ctx = quickjs.Context()
+      print(ctx.eval("1 + 1"))
+
+  threads = [threading.Thread(target=worker) for _ in range(4)]
+  for t in threads: t.start()
+  ```
+
+- **`Function` helper** — wraps a `Context` with a dedicated worker thread and lock, safe to call from any thread:
+
+  ```python
+  f = quickjs.Function("f", "function f(x) { return x * 2; }")
+  # safe to call f(21) from any thread
+  ```
+
+| Pattern | Thread-safe | Overhead |
+|---------|:-----------:|----------|
+| Context per thread | ✅ | None |
+| `Function` helper | ✅ | Small (executor dispatch) |
+| Shared `Context` | ❌ | — |
+
+**Free-threaded Python (3.13t / 3.14t):** Both patterns remain safe. The GIL was never relied upon for thread-safety.
+
+**musl / Alpine:** Worker threads are automatically created with an 8 MB stack (matching glibc defaults) so `set_max_stack_size` and deep recursion work correctly on musl-based systems.
+
+## Versioning
+
+Version format is `X.Y.Z.P` where `X.Y.Z` matches the upstream quickjs-ng tag and `P` is the wrapper patch (starts at 1 per upstream release). Wheels are built automatically when a new upstream tag is detected.
+
+## Development
+
+Requires a C compiler and [uv](https://docs.astral.sh/uv/).
+
+```bash
+git clone --recurse-submodules https://github.com/genotrance/quickjs-ng.git
+cd quickjs-ng
+make install
+make test
+```
+
+| Target         | Description                                        |
+|----------------|----------------------------------------------------|
+| `make install` | Create venv, build C extension, install pre-commit |
+| `make test`    | Run tests with coverage                            |
+| `make check`   | Run linters and type checking                      |
+| `make build`   | Build sdist and wheel                              |
+| `make clean`   | Remove build artifacts                             |
+| `make publish` | Publish to PyPI                                    |
+
+## Contributing
+
+Bug reports and pull requests are welcome at <https://github.com/genotrance/quickjs-ng/issues>.
+
+1. Fork and clone with `--recurse-submodules`.
+2. Run `make install` to set up the venv, build the C extension, and install pre-commit hooks.
+3. Create a feature branch, make changes, add tests in `tests/`.
+4. Run `make check && make test` — all checks must pass.
+5. Open a pull request. CI runs on Ubuntu, Windows, and macOS across Python 3.10–3.14 (including free-threaded 3.13t/3.14t) and PyPy 3.10/3.11.
+
+## Documentation
+
+Full technical documentation is in the [`docs/`](docs/) folder:
+
+| File | Contents |
+|------|----------|
+| [docs/porting.md](docs/porting.md) | Porting history from PetterS/quickjs |
+| [docs/c-extension.md](docs/c-extension.md) | C extension design and stable ABI migration |
+| [docs/build.md](docs/build.md) | Build system: setup.py, pyproject.toml, wheels |
+| [docs/ci.md](docs/ci.md) | GitHub Actions workflows |
+| [docs/threading.md](docs/threading.md) | Threading model and musl stack fix |
+| [docs/testing.md](docs/testing.md) | Test suite layout and memory leak tests |
+| [docs/versioning.md](docs/versioning.md) | Version scheme and automated stamping |
+| [docs/typing.md](docs/typing.md) | Type annotations and mypy configuration |
+
+## Acknowledgments
+
+This project is a fork of [quickjs](https://github.com/PetterS/quickjs) by [Petter Strandmark](https://github.com/PetterS). The original design of the C bindings, the `Function` thread-safety wrapper, and the overall API shape are all his work.
+
+The porting to quickjs-ng, the stable ABI migration, the expanded test suite, CICD and all documentation were developed with the assistance of LLMs.
+
+## License
+
+MIT

package/binary/_internal/quickjs_ng-0.17.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+_quickjs.abi3.so,sha256=r69JxerB7gdTt8VqaD2WJNM-4eyf9V8J-phtgA6SELI,8035944
+quickjs/__init__.py,sha256=BtvPUJD4rt_zUj2riib5xGzWr0tdiP7aIO965Fzd7zg,5664
+quickjs_ng-0.17.0.1.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+quickjs_ng-0.17.0.1.dist-info/METADATA,sha256=qE5JmkqBZB3CrEKzo6yAoOxNVbV47UBzMO4txx9UIxA,6459
+quickjs_ng-0.17.0.1.dist-info/RECORD,,
+quickjs_ng-0.17.0.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+quickjs_ng-0.17.0.1.dist-info/WHEEL,sha256=yGw0S4yb8rUjuiE5T7Lb-hD_2wSDLme4T4CyaKHO-jY,187
+quickjs_ng-0.17.0.1.dist-info/licenses/LICENSE,sha256=HZi7-GDDwPBCgZQeQeVTSk5cNYjapzVrBlwqGC3ifCo,1075
+quickjs_ng-0.17.0.1.dist-info/top_level.txt,sha256=KrXFdJGch2baRcvdgEGjrk8zdolgKFRZ0xx4UhDg7h8,17

package/binary/_internal/quickjs_ng-0.17.0.1.dist-info/WHEEL

@@ -0,0 +1,7 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: false
+Tag: cp310-abi3-manylinux_2_17_x86_64
+Tag: cp310-abi3-manylinux2014_x86_64
+Tag: cp310-abi3-manylinux_2_28_x86_64
+

package/binary/_internal/quickjs_ng-0.17.0.1.dist-info/licenses/LICENSE

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

package/binary/_internal/quickjs_ng-0.17.0.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+_quickjs
+quickjs

package/binary/_internal/selectolax/base.pxi

@@ -0,0 +1,4 @@
+
+class SelectolaxError(Exception):
+    """An exception that indicates error."""
+    pass

package/binary/_internal/selectolax/lexbor/attrs.pxi

@@ -0,0 +1,123 @@
+cimport cython
+
+
+@cython.final
+cdef class LexborAttributes:
+    """A dict-like object that represents attributes."""
+    cdef lxb_dom_node_t *node
+    cdef unicode decode_errors
+
+    @staticmethod
+    cdef LexborAttributes create(lxb_dom_node_t *node):
+        obj = <LexborAttributes> LexborAttributes.__new__(LexborAttributes)
+        obj.node = node
+        return obj
+
+    def __iter__(self):
+        cdef lxb_dom_attr_t *attr = lxb_dom_element_first_attribute_noi(<lxb_dom_element_t *> self.node)
+        cdef size_t str_len = 0
+
+        while attr != NULL:
+            key = lxb_dom_attr_local_name_noi(attr, &str_len)
+            if key is not NULL:
+                yield key.decode(_ENCODING)
+            attr = attr.next
+
+    def __setitem__(self, str key, object value):
+        value = value
+        bytes_key = key.encode(_ENCODING)
+        bytes_value = value.encode(_ENCODING) if value else b""
+        cdef lxb_dom_attr_t *attr
+        cdef lxb_dom_document_t *doc
+
+        if value is None:
+            # N.B. This is suboptimal, but there is not API to set empty attributes
+            attr = lxb_dom_element_set_attribute(
+                <lxb_dom_element_t *> self.node,
+                <lxb_char_t *> bytes_key, len(bytes_key),
+                NULL, 0
+            )
+            if attr == NULL:
+                raise MemoryError("Failed to set attribute")
+            doc = (<lxb_dom_node_t*>attr).owner_document
+            lexbor_str_destroy(attr.value, doc.text, 0)
+            attr.value = NULL
+
+        elif isinstance(value, str) or isinstance(value, unicode) :
+            attr = lxb_dom_element_set_attribute(
+                <lxb_dom_element_t *> self.node,
+                <lxb_char_t *> bytes_key, len(bytes_key),
+                <lxb_char_t *> bytes_value, len(bytes_value),
+            )
+            if attr == NULL:
+                raise MemoryError("Failed to set attribute")
+        else:
+            raise TypeError("Expected str or unicode, got %s" % type(value))
+
+    def __delitem__(self, key):
+        try:
+            self.__getitem__(key)
+        except KeyError:
+            raise KeyError(key)
+        bytes_key = key.encode(_ENCODING)
+        lxb_dom_element_remove_attribute(
+            <lxb_dom_element_t *> self.node,
+            <lxb_char_t *> bytes_key, len(bytes_key),
+        )
+
+    def __getitem__(self, str key):
+        bytes_key = key.encode(_ENCODING)
+        cdef lxb_dom_attr_t * attr = lxb_dom_element_attr_by_name(
+            <lxb_dom_element_t *> self.node,
+            <lxb_char_t *> bytes_key, len(bytes_key)
+        )
+        cdef size_t str_len = 0
+        if attr != NULL:
+            value = lxb_dom_attr_value_noi(attr, &str_len)
+            return value.decode(_ENCODING) if value else None
+        raise KeyError(key)
+
+    def __len__(self):
+        return len(list(self.__iter__()))
+
+    def keys(self):
+        return self.__iter__()
+
+    def items(self):
+        for key in self.__iter__():
+            yield key, self[key]
+
+    def values(self):
+        for key in self.__iter__():
+            yield self[key]
+
+    def get(self, key, default=None):
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def sget(self, key, default=""):
+        """Same as get, but returns empty strings instead of None values for empty attributes."""
+        try:
+            val = self[key]
+            if val is None:
+                val = ""
+            return val
+        except KeyError:
+            return default
+
+    def __contains__(self, key):
+        try:
+            self[key]
+        except KeyError:
+            return False
+        else:
+            return True
+
+    def __repr__(self):
+        cdef lxb_char_t *c_text
+        cdef size_t str_len = 0
+        c_text = lxb_dom_element_qualified_name(<lxb_dom_element_t *> self.node, &str_len)
+        tag_name = c_text.decode(_ENCODING, 'ignore') if c_text != NULL else 'unknown'
+        return "<%s attributes, %s items>" % (tag_name, len(self))

package/binary/_internal/selectolax/lexbor/fragment_lookup.pxi

@@ -0,0 +1,52 @@
+cdef inline lxb_tag_id_t _fragment_tag_id_from_string(
+    lxb_html_document_t *document,
+    str fragment_tag,
+) except? 0:
+    cdef bytes fragment_tag_bytes
+    cdef lxb_tag_id_t tag_id
+
+    if not fragment_tag:
+        raise ValueError("fragment_tag cannot be empty")
+
+    fragment_tag_bytes = fragment_tag.encode("UTF-8")
+    tag_id = lxb_tag_id_by_name_noi(
+        document.dom_document.tags,
+        <const lxb_char_t *> fragment_tag_bytes,
+        len(fragment_tag_bytes),
+    )
+    if tag_id == LXB_TAG__UNDEF:
+        raise ValueError(f"Unknown fragment tag: {fragment_tag!r}")
+
+    return tag_id
+
+
+cdef inline lxb_ns_id_t _fragment_namespace_id_from_string(
+    lxb_html_document_t *document,
+    str fragment_namespace,
+) except? 0:
+    cdef bytes fragment_namespace_bytes
+    cdef const lxb_ns_prefix_data_t *prefix_data
+    cdef const lxb_ns_data_t *ns_data
+
+    if not fragment_namespace:
+        raise ValueError("fragment_namespace cannot be empty")
+
+    fragment_namespace_bytes = fragment_namespace.encode("UTF-8")
+
+    prefix_data = lxb_ns_prefix_data_by_name(
+        document.dom_document.ns,
+        <const lxb_char_t *> fragment_namespace_bytes,
+        len(fragment_namespace_bytes),
+    )
+    if prefix_data != NULL:
+        return <lxb_ns_id_t> prefix_data.prefix_id
+
+    ns_data = lxb_ns_data_by_link(
+        document.dom_document.ns,
+        <const lxb_char_t *> fragment_namespace_bytes,
+        len(fragment_namespace_bytes),
+    )
+    if ns_data != NULL:
+        return ns_data.ns_id
+
+    raise ValueError(f"Unknown fragment namespace: {fragment_namespace!r}")