semvec/pypi-packages huggingface dataset:
py-import-scanner 0.1.1
CLI tool to list and classify Python imports in a project.
Requires Python: >=3.7

# 🧠 importscanner

> A lightweight CLI tool to list and classify Python imports: standard library, pip-installed (third-party), and local modules.

---

## 🎞️ Features

* 📚 **Categorizes Python imports**:

  * ✅ Standard Library modules
  * ✅ Third-party packages installed via `pip`
  * ✅ Your project's local modules
* ✍️ Optionally generates a `requirements.txt`
* 🦢 Works on any Python-based project or codebase
* 🧫 Graceful handling of broken files, bad syntax, and missing packages
* 📄 Optional logging to `importscanner.log`

---

## 🚀 Installation

### From PyPI (recommended):

```bash
pip install importscanner
```

### From source (GitHub):

```bash
git clone https://github.com/harshmeet-1029/importscanner.git
cd importscanner
pip install .
```

---

## 💻 Usage

Once installed, the CLI command is available as:

```bash
list-imports [directory] [--save] [--log]
```

### 🧪 Examples

#### ▶️ Basic usage (scan current directory):

```bash
list-imports
```

#### 📂 Scan a specific folder:

```bash
list-imports ./src
```

#### 📆 Save third-party packages to `requirements.txt`:

```bash
list-imports ./project --save
```

#### �� Enable log file output to `importscanner.log`:

```bash
list-imports --log
```

#### 📦 Combine all options:

```bash
list-imports ./backend --save --log
```

---

## 📂 Output Format

```
📦 Third-Party Packages (installed via pip):
  - requests
  - flask

📁 Local Modules (your own project's files/modules):
  - myutils
  - handlers

📚 Standard Library (built-in Python modules):
  - os
  - sys
  - json
```

---

## 📝 Notes

* Uses the `stdlib_list` package to detect standard library modules.
* Gracefully skips unreadable or invalid `.py` files.
* Supports Python 3.8+
pynvml-amd-windows 1.0.14
pynvml-compatible library for AMD GPUs on Windows
Requires Python: >=3.7
Keywords: amd, gpu, nvidia, pynvml, adlx, crystools, comfyui, windows

# pynvml-amd-windows

## Purpose

**pynvml-amd-windows** is a drop-in replacement for NVIDIA's `pynvml` Python library, designed to allow existing pynvml-based applications to monitor and manage AMD GPUs on Windows systems. It provides a compatible API that redirects NVML calls to the AMD ADLX backend, enabling tools that were written for NVIDIA GPUs to work seamlessly with AMD hardware.

It was written for the specific purpose of enabling [Crystools](https://github.com/crystian/ComfyUI-Crystools) GPU performance monitoring for AMD platforms under Windows.

This package is especially useful if you have tools or scripts that expect `pynvml` to be present, and you want them to function without modification on systems with supported AMD GPUs.

## Features

- Implements the `pynvml` interface using AMD's ADLX library for Windows.
- Compatible with most scripts and programs expecting `import pynvml`.
- No need to modify existing code: the package transparently handles imports using a `.pth` file.

## Installation

### Using pip
```
pip install pynvml-amd-windows
```

### From source

Clone or download this repository, then run:
```
pip install .
```
from within the project directory.

## Usage

After installation, any Python program that imports `pynvml` (or uses a package depending on it) will transparently use the AMD implementation on Windows—no code changes required.

Example:
```
python
import pynvml

pynvml.nvmlInit()
count = pynvml.nvmlDeviceGetCount()
print("Number of AMD GPUs detected:", count)
```
## Limitations

- Only supports AMD GPUs on Windows using the ADLX backend.
- Some advanced `pynvml` features may not be supported or may have slightly different behavior due to backend differences.

## License

This project is distributed under the MIT License.

## Authors

- Christopher Anderson (<sfinktah@github.spamtrak.org>)
```
topology-hm 3.11.1
Connect to real devices supported by hm
Keywords: topology_hm

=================================
Topology Platform for the SDK lab
=================================

Connect to real devices in the sdk lab


Documentation
=============

    https://pvsdk.rose.rdlabs.hpecorp.net/provision/topology_hm


License
=======

::

   Copyright (C) 2017 Hewlett Packard Enterprise Development LP

   All Rights Reserved.

   The contents of this software are proprietary and confidential to the
   Hewlett Packard Enterprise Development LP. No part of this program may be
   photocopied, reproduced, or translated into another programming language
   without prior written consent of the Hewlett Packard Enterprise
   Development LP.
pythonic-fp.iterables 4.0.0
Library of functions for iterating iterables.
Requires Python: >=3.12
Keywords: iterables, iterators

# Pythonic FP - Tools for iterables

PyPI project
[pythonic-fp.iterators](https://pypi.org/project/pythonic-fp.iterables/)
implementing a Python library of functions for iterables and iterators.

- Concatenating and merging iterables
- Dropping and taking values from iterables
- Reducing and accumulating iterables

#### Info:

This library assumes that at all times iterator protocol
is followed. This means that all iterators are iterable and
that ``iter(some_iterator) is some_iterator``.

#### Note:

Iterables are not necessarily iterators.

This PyPI project is part of of the grscheller
[pythonic-fp namespace projects](https://github.com/grscheller/pythonic-fp/blob/main/README.md).

## Documentation

Documentation for this PyPI projects is hosted on
[GitHub Pages](https://grscheller.github.io/pythonic-fp/iterators/API/development/build/html/releases.html).

## Copyright and License

Copyright (c) 2023-2025 Geoffrey R. Scheller. Licensed under the Apache
License, Version 2.0. See the LICENSE file for details.
hpsspy 0.8.0
Package for interacting with HPSS.
Requires Python: >=3.10
Keywords: HPSS, tape, backup

======
HPSSPy
======

|License| |PyPI| |Downloads| |Actions Status| |Coveralls Status| |Documentation Status|

.. |License| image:: https://img.shields.io/pypi/l/hpsspy.svg
    :target: https://pypi.python.org/pypi/hpsspy
    :alt: License

.. |PyPI| image:: https://img.shields.io/pypi/v/hpsspy.svg
    :target: https://pypi.python.org/pypi/hpsspy
    :alt: PyPI Badge

.. |Downloads| image:: https://img.shields.io/pypi/dm/hpsspy.svg
    :target: https://pypi.python.org/pypi/hpsspy
    :alt: PyPI Downloads

.. |Actions Status| image:: https://github.com/weaverba137/hpsspy/workflows/CI/badge.svg
    :target: https://github.com/weaverba137/hpsspy/actions
    :alt: GitHub Actions CI Status

.. |Coveralls Status| image:: https://coveralls.io/repos/github/weaverba137/hpsspy/badge.svg
    :target: https://coveralls.io/github/weaverba137/hpsspy
    :alt: Test Coverage Status

.. |Documentation Status| image:: https://readthedocs.org/projects/hpsspy/badge/
    :target: https://hpsspy.readthedocs.io/en/latest/
    :alt: Documentation Status

Overview
--------

HPSSPy is a Python_ package for interacting with the HPSS_ tape storage
system at NERSC_.  It is currently being developed on GitHub_.

.. _Python: https://www.python.org
.. _HPSS: https://www.nersc.gov/what-we-do/computing-for-science/data-resources/storage
.. _NERSC: https://www.nersc.gov
.. _GitHub: https://github.com/weaverba137/hpsspy

Requirements
------------

HPSSPy assumes that the HPSS utilities `hsi and htar`_ are installed.  As of
2023, these utilities are only available within the NERSC_ environment.

.. _`hsi and htar`: https://docs.nersc.gov/filesystems/archive/#common-commands

License
-------

HPSSPy is free software licensed under a 3-clause BSD-style license. For details see
the ``LICENSE.rst`` file.
vec-noise-numpy2 1.1.5
Vectorized Perlin noise for Python

This is a fork of Casey Duncan's noise library that vectorizes all of the noise
functions using NumPy. It is much faster than the original for computing noise
values at many coordinates.

Perlin noise is ubiquitous in modern CGI. Used for procedural texturing,
animation, and enhancing realism, Perlin noise has been called the "salt" of
procedural content. Perlin noise is a type of gradient noise, smoothly
interpolating across a pseudo-random matrix of values.

The vec_noise library includes native-code implementations of Perlin "improved"
noise and Perlin simplex noise. It also includes a fast implementation of
Perlin noise in GLSL, for use in OpenGL shaders. The shader code and many of
the included examples require Pyglet (http://www.pyglet.org), the native-code
noise functions themselves do not, however.

The Perlin improved noise functions can also generate fBm (fractal Brownian
motion) noise by combining multiple octaves of Perlin noise. Shader functions
for convenient generation of turbulent noise are also included.