semvec/pypi-packages huggingface dataset:
go4py 0.1.74
Add your description here
Requires Python: <3.13,>=3.10

<div style="text-align: center;">
<img src="docs/img/go4py.png" width="290" style=""/>
<h2> go4py: ⚡ Supercharge your Python with Go ⚡ </h2>
</div>

Do you ever wish Python were faster? `go4py` is here to help!
Enjoy the speed and simplicity of Go within Python! You can write bottlenecks of your Python code as CGo functions. The `go4py` will automatically generate a Python module from it for you!

Check the performance boost in our [benchmarks](docs/benchmark.md) and get a sense of how much faster it can be compared to basic Python! 🚀


## Installation
#### Linux
 1. Install Go
 2. `pip install go4py`
#### Windows
 1. Install Go
 2. Install [MSYS2](https://www.msys2.org/) and then install [mingw-toolchain](https://packages.msys2.org/groups/mingw-w64-x86_64-toolchain) inside it.
 3. Install `go4py` in a python vitrual exnvironment.
 4. Open a mingw shell and activate the venv inside it (e.g. `source venv/Scripts/activate`)
 5. Add Go to your PATH in the mingw shell (e.g., `export PATH=$PATH:"/c/Program Files/Go/bin/"`)


## Usage
 To create a Go package inside your Python project:
```shell
 go4py init <module_name>
```
 This will create a directory with the name `<module_name>` and add `go.mod` to your project.
 You can go to `<module_name>/src` directory and add your Go functions there.

 To build the Go package and generate bindings code for the Python module:
```shell
 go4py build <module_name>
```

You can now import the functions as methods of a python module:
```python
from <module_name> import <function_name>
```
Please note that we convert the function names' first character to lower case.

## How it works
There is a Makefile in the created directory with four major steps:
1. Parsing the Go code and extracting the signatures of the functions (the `functions.json` file).
2. Building an object file from Go code (`.a` and `.h` files).
3. Making a C wrapper for the Go functions as a Python native C extension.
4. Building a shared library from the generated C code (`__init__.so` file or `__init__.pyd` file).

The Makefile is actually quite readable, and you can modify it to your needs `go4py` will just run it 

## Documentation
[This documentation](docs/documentation.md) will explain how to use go4py. there is also a [examples](examples) directory for some examples. But if you need to dive into inner-workings of `go4py` take a look at the [tests](tests) directory and checkout the codes that `go4py` generates automaticly from a go function signature.
dom-inspector-ai 0.1.1
Extract class/id and DOM paths with screenshot for AI agents
Requires Python: >=3.8

# DOM Inspector AI

This package extracts all `id` and `class` attributes from a web page, along with their DOM paths and a base64 screenshot.

## Installation

```bash
pip install git+https://github.com/yut0takagi/dom-inspector-ai.git
```

## CLI Usage

```bash
python cli.py https://example.com > output.json
```

## Python Usage

```python
from dom_inspector_ai.analyzer import analyze_url

result = analyze_url("https://example.com")
print(result["ids"])
```

## Output

- `ids`: Dictionary of id attributes with tag, hierarchy, and CSS selector path
- `classes`: Dictionary of class attributes with count and example paths
- `screenshot_base64`: PNG screenshot of the page in base64
mtsl 0.1.0.6
An easy to use, minimal trust security layer.
Requires Python: >=3.6

# MTSL

MTSL is an easy-to-use, relatively simple, low blast radius security layer.

It works similar to the TLS socket wrapper from `ssl`.

Example:

```python
from mtsl import MTSLContext
import socket

ctx = MTSLContext()
ctx.authority_file("authority.pub.elle")
ctx.subject_files('subject.pub.elle', 'subject.sec.elle')

sock = socket.socket()

sock.connect('12.34.56.78')

secure_sock = ctx.wrap_socket(sock)

# send/recv works from here
# conn from `socket.accept()` works this way as well

sock.listen()
while 1:
    c, addr = sock.accept()
    with ctx.wrap_socket(c) as secure_conn:
        pass  # send/recv works from here
```

Read source code for full technical details if you're a nerd like me.  
Or just float off into the ether and accept that I had to know what I was doing so you don't.