semvec/pypi-packages huggingface dataset:
pyhangouts2 1.1.2
A Selenium-based Python 3 library for Google Chat.
Requires Python: >=3.13

# Google Chat Utils
Misc. tools for Google Chat.

*No longer maintained*
PyHangouts2 is inefficient in a way that it uses Selenium.
[maugclib](https://github.com/mautrix/googlechat/tree/master/maugclib) is much better.

## Disclaimer
Google is a registered trademark.
This project is not affiliated or endorsed by Google.

<!--
SPDX-FileCopyrightText: 2026 NexusSfan <nexussfan@duck.com>
SPDX-License-Identifier: CC0-1.0
-->
st-zig 0.1.1
A setuptools extension for compiling native extensions with Zig.
Requires Python: >=3.7

# st_zig

A setuptools extension for compiling native extensions with Zig.

`st_zig` is a lightweight standalone package that enables `setuptools` to use
Zig as a C/C++ compiler. By leveraging the standalone
[ziglang](https://pypi.org/project/ziglang/) package, which is available for all
PyPI-supported target platforms, this tool allows native extensions to be
compiled directly on user devices.

This approach eliminates the need for users to install additional build tools,
simplifying the setup process. Additionally, it removes the complexity of
managing platform-specific compiler flags, particularly on Windows.

## Usage

To use this package, simply add it as build requirement to your project.

### Direct

The easier option to use is directly using `st_zig.build_meta` as build backend,
which is a proxy to `setuptools.build_meta` and simply uses
`st_zig.enforce_via_build_ext` during the import.

`pyproject.toml`

```toml
[build-system]
requires = ["st_zig"]
build-backend = "st_zig.build_meta"
```

### Indirect

Alternatively `enforce_via_build_ext` or `enforce_via_env` can be used.
`st_zig.enforce_via_build_ext` patches `build_ext` so that it picks
`st_zig.ZigCompiler`. `st_zig.enforce_via_env` modifies the sysconfig read by
python to make the `UnixCompiler` use zig, this doesn't seem to work on Windows
anymore though. The `UnixCompiler` class, while primarily designed for Unix-like
systems, works seamlessly on Windows as well. This is because Zig includes a
bundled version of Clang, which ensures compatibility with Unix-style compiler
flags across all platforms, including Windows.

Mind that the `UnixCompiler` class just describes unix focussed compilers like
gcc and clang, it also works just fine on Windows. As Zig basically ships clang,
you can use the same clang unix flags on all systems.

## Example

`setup.py`

```py
from setuptools import Extension, setup
# Add the following to your setup.py to enable Zig as the compiler
from st_zig import enforce_via_build_ext
enforce_via_build_ext()


setup(
    name="testc",
    ext_modules=[
        Extension(
            "testc",
            ["test.cpp"],
            language="c++",
            # Adjust the compile arguments based on your project's requirements
            extra_compile_args=["-std=c++23"],
        ),  # Note: The above example uses C++23. Modify the flag as needed for your project.
    ],
)
```

`pyproject.toml`

```toml
[build-system]
requires = ["setuptools", "st_zig"]
build-backend = "setuptools.build_meta"

# Add any additional configuration options below as needed
...
```
torch-delaunay 1.3.0
The Delaunay triangulation for PyTorch
Requires Python: >=3.9

# Torch Delaunay - The Delaunay triangulation library for PyTorch

This is a fast library for computing [Delaunay triangulation](https://en.wikipedia.org/wiki/Delaunay_triangulation)
of 2-dimensional points.

The implementation is based on a sweep-algorithm, introduced by David Sinclair[^1] and later
improved by Volodymyr Agafonkin[^2].

Here is an example of triangulation output produced by Torch Delaunay library for a random set of
points:
![example](docs/index.jpg)

## Installation

The library is distributed as PyPI package, to install the package, execute the following
command:
```sh
pip install torch_delaunay
```

You can use the `torch_delaunay` library for a fast computation of Delaunay triangulation for
points defined as [PyTorch](https://pytorch.org) tensors.

## Usage

```py
import torch
from torch_delaunay.functional import shull2d
import matplotlib.pyplot as plt

# Compute Delaunay triangulation for randomly-generated 2-dimensional points.
points = torch.rand((100, 2))
simplices = shull2d(points)

# Plot the result
plt.triplot(points[:, 0], points[:, 1], triangles=simplices)
plt.title("Delaunay Triangulation")
```

## Benchmarks

Benchmarks are collected on _Apple M1 Pro_ chip with 32 GiB of memory.

| Prob. Distribution | Data Type | Samples | Time     | CPU      | Iterations |
| ------------------ | --------- | ------- | -------- | -------- | ---------- |
| Uniform            | Float64   | 10000   |  4.18 ms |  4.11 ms |        171 |
| Uniform            | Float64   | 100000  |  49.6 ms |  48.3 ms |         15 |
| Uniform            | Float64   | 1000000 |   600 ms |   592 ms |          1 |
| Uniform            | Float32   | 10000   |  4.37 ms |  4.29 ms |        161 |
| Uniform            | Float32   | 100000  |  47.4 ms |  46.4 ms |         15 |
| Uniform            | Float32   | 1000000 |   573 ms |   568 ms |          1 |
| Normal             | Float64   | 10000   |  4.60 ms |  4.49 ms |        156 |
| Normal             | Float64   | 100000  |  48.5 ms |  47.4 ms |         15 |
| Normal             | Float64   | 1000000 |   568 ms |   563 ms |          1 |
| Normal             | Float32   | 10000   |  4.42 ms |  4.33 ms |        165 |
| Normal             | Float32   | 100000  |  46.5 ms |  45.4 ms |         15 |
| Normal             | Float32   | 1000000 |   550 ms |   547 ms |          1 |

## License

The Torch Delaunay is distributed under GPLv3 license. See the [LICENSE](LICENSE) file for full
license text.


[^1]: David Sinclair - [S-hull: a fast radial sweep-hull routine for Delaunay triangulation](https://arxiv.org/abs/1604.01428).

[^2]: Volodymyr Agafonkin - [Delaunator: An incredibly fast and robust JavaScript library for Delaunay triangulation of 2D points](https://github.com/mapbox/delaunator).
Topsis-Manya-102303254 0.1
TOPSIS Multi-Criteria Decision Making Tool
Requires Python: >=3.6

# Topsis-Manya-102303254

This package implements TOPSIS (Technique for Order of Preference by Similarity to Ideal Solution) 
for multi-criteria decision-making.

## Installation

Run the following command to install the package:

    pip install Topsis-Manya-102303254

## Usage

Run TOPSIS from the command line:

    topsis <InputDataFile> <Weights> <Impacts> <OutputResultFile>

Example:

    topsis data.xlsx "1,1,1,1,2" "+,+,+,-,+" output.csv

## Author

Manya Garg