semvec/pypi-packages huggingface dataset:
WinRAM 1.5
Exposes Windows bindings to the memory interface.
Requires Python: >=3.14
Keywords: WINDOWS, WIN32, WINNT, MEMORY, VIRTUALALLOC

# WinRAM
## The honest Python-to-Windows interface
## Introduction
**WinRAM** is a Python library dedicated to exposing raw access to the user-mode memory on Windows. Before you ask, no, i will **not** support backwards compatibility. It will be in line with bleeding edge standards. Follow or be left behind.

## Features
- Virtual Memory: No more of that kiddy Unix-inspired stuff from `mmap`, instead you call `vm = VirtualMemory(addr, size, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE)` and watch as virtual memory gets handed down on a silver platter, wrapped in a buffer-supported `memoryview`. 
- Constants: Yes. Constants are supported, so you can do `MEM_COMMIT` instead of fiddling with bitflags.
- Executable Memory: Yes, the widely recognisable **RWX** is supported. **JIT** developers would be happy, even though Python is slower than eight `C++` hot loops.
- Security: For security-obessesed people, **W^X** is supported (even though you have to flip flags like a maniac).

## Comparison with `mmap`:
**Scale is 0.4**, because i said so.
- Can allocate and free memory: Both support it. Boring, but useful.
- Mark down specific regions of memory with flags: WinRAM supports it. `mmap` does not.
- Query full regions: Another point to **WinRAM**.
- Commit and decommit?: WinRAM again. `mmap` dropping the ball here.


Result:

WinRAM: 1.6

`mmap`: 0.4

## Call for Action
CPython devs... Show love for **NT**. POSIX is too overrepresented.

## Conclusion
Get this library if you are sick and tired of constant-less ctypes binding, sick of baby abstractions, and sick of `mmap` and `POSIX` culture as a whole.
directory-analyzer 0.1.1
Recursive directory analyzer with stats, top files and duplicate detection
Requires Python: >=3.8

# Directory Analyzer

Directory Analyzer is a simple Python tool that scans a directory recursively and generates a structured report.

## Features

- Count total number of files and folders.
- Group files by extension and calculate total size per extension.
- Find top 10 largest files in the directory tree.
- Detect duplicate files by comparing file content (hash).
- Handle file access errors safely (permission denied, missing files).
- Print report to console or save it to a file.

## Command line arguments

- `path` (required): path to the target directory.

## Requirements

- Python 3.8 or newer.
- Standard library only (os, hashlib, collections, argparse, etc.).

## How it works

1. The program receives a directory path from the command line.
2. It uses `os.walk()` to recursively traverse all subdirectories and files.
3. For each file it:
   - Counts total files and folders.
   - Determines the file extension and adds the file size to extension statistics.
   - Stores the file path and size for later sorting (top 10 largest files).
   - Reads the file in small chunks and calculates an MD5 hash to detect duplicates.
4. After scanning, the program:
   - Builds a list of the top 10 largest files.
   - Groups files by hash and keeps only hashes that have more than one file (duplicates).
   - Generates a text report with all collected statistics.

## Main functions / methods

- `analyze_directory(path)` or class method `DirectoryAnalyzer.analyze_directory()`  
  Scans the directory recursively and fills all statistics.

- `get_top_files(n=10)`  
  Returns a list of the largest files (path and size).

- `find_duplicates()`  
  Returns groups of files that have identical content.

- `generate_report()`  

## Example report (simplified)

Analysis of: /home/user/documents
Files: 1247, Folders: 156

Extensions (total size in bytes):
.jpg: 2456789
.py: 124567
.txt: 45678

Top-10 largest files:
1234567 bytes: images/photo.jpg
987654 bytes: videos/movie.mp4

Duplicates:
Group (2 files):
/home/user/documents/file1.txt
/home/user/documents/copy/file1_copy.txt

## Download

pip install directory-analyzer==0.1.0

## Example of usage

from directory_analyzer import DirectoryAnalyzer:

path = r'C:\directory'

analyzer = DirectoryAnalyzer(path)

analyzer.analyze_directory()

print(analyzer.generate_report())
pep610 0.5.1
PEP 610 Direct URL data parser
Requires Python: >=3.8
Keywords: packaging, pep, pep610

# pep610

[![PyPI - Version](https://img.shields.io/pypi/v/pep610.svg)](https://pypi.org/project/pep610)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pep610.svg)](https://pypi.org/project/pep610)
![PyPI - Downloads](https://img.shields.io/pypi/dw/pep610)
[![codecov](https://codecov.io/gh/edgarrmondragon/pep610/graph/badge.svg?token=6W1M6P9LYI)](https://codecov.io/gh/edgarrmondragon/pep610)
[![Documentation Status](https://readthedocs.org/projects/pep610/badge/?version=latest)](https://pep610.readthedocs.io/en/stable)

A Python library for parsing the [Direct URL Origin structure][pep610-structure] from installed packages.

[PEP 610][pep610] initially specified how the Direct URL Origin of installed distributions should be recorded, but the up-to-date, [canonical specification][pep610-pypa] is maintained on the [PyPA specs page][pypa-specs].

-----

**Table of Contents**

- [Installation](#installation)
- [Usage](#usage)
- [License](#license)

## Installation

```console
pip install pep610
```

## Usage

You can use `pep610.read_from_distribution` to parse the [Direct URL Origin structure][pep610-structure] from a `Distribution` object:

```python
from importlib import metadata

import pep610

dist = metadata.distribution("pep610")

if (
    (data := pep610.read_from_distribution(dist))
    and isinstance(data, pep610.DirData)
    and data.dir_info.is_editable()
):
    print("Editable installation, a.k.a. in development mode")
else:
    print("Not an editable installation")
```

Or, in Python 3.10+ using pattern matching:

```python
from importlib import metadata

import pep610

dist = metadata.distribution("pep610")

match data := pep610.read_from_distribution(dist):
    case pep610.DirData(url, pep610.DirInfo(editable=True)):
        print("Editable installation, a.k.a. in development mode")
    case _:
        print("Not an editable installation")
```

## Development

This project uses [Tox][tox].

Run all checks with:

```shell
tox run-parallel
```

## License

`pep610` is distributed under the terms of the [Apache License 2.0](LICENSE).

[pep610]: https://www.python.org/dev/peps/pep-0610/
[pep610-pypa]: https://packaging.python.org/en/latest/specifications/direct-url/#direct-url
[pep610-structure]: https://packaging.python.org/en/latest/specifications/direct-url-data-structure/
[pypa-specs]: https://packaging.python.org/en/latest/specifications/
[tox]: https://tox.wiki/
order-journey-viz 0.2.0
Interactive visualization of order status journeys
Requires Python: >=3.8

## Examples

Below are **self-contained example scripts** you can copy and run to try the
Order Journey Visualizer. Each example generates an interactive HTML file
that you can open in your browser.

---

### Minimal Example

The simplest possible usage. Good starting point.

```python
import pandas as pd
from order_journey import OrderJourneyVisualizer

df = pd.DataFrame({
    "order_id": ["A", "A"],
    "status": ["Start", "End"],
    "timestamp": ["2024-01-01", "2024-01-02"]
})

viz = OrderJourneyVisualizer(df)
viz.build_graph()
viz.generate_html("minimal_example.html")

print("Done! Open minimal_example.html in your browser")
```

### Retry / Failure Pattern Example

```python
import pandas as pd
from order_journey import OrderJourneyVisualizer

df = pd.DataFrame({
    "order_id": ["A", "A", "A", "A"],
    "status": ["New", "Processing", "Failed", "Processing"],
    "timestamp": [
        "2024-01-01 10:00",
        "2024-01-01 11:00",
        "2024-01-01 12:00",
        "2024-01-01 13:00",
    ],
})

viz = OrderJourneyVisualizer(df)
viz.build_graph()
viz.generate_html("retry_example.html")

print("Done! Open retry_example.html in your browser")

```
trio-binance 0.4.6
trio based asynchronous binance SDK
Requires Python: >=3.11

=================================
Welcome to trio-binance
=================================

This is an unofficial Python wrapper for the `Binance exchange REST API v3 <https://binance-docs.github.io/apidocs/spot/en>`_. I am in no way affiliated with Binance, use at your own risk.

And this repository is forked from `python-binance <https://github.com/sammchardy/python-binance>`_, but has only async client, and works **only** with `trio <https://trio.readthedocs.io/en/stable/index.html>`_ or `trio-compatible <https://trio.readthedocs.io/en/stable/awesome-trio-libraries.html#trio-asyncio-interoperability>`_ asynchronous frameworks.

Source code
  https://github.com/halfelf/trio-binance

Quick Start
-----------

`Register an account with Binance <https://accounts.binance.com/en/register?ref=10099792>`_.

`Generate an API Key <https://www.binance.com/en/my/settings/api-management>`_ and assign relevant permissions.

.. code:: bash

    pip install trio-binance


Example
-------------

Check pytest file under ``tests``.

Donate
------

If this library helps, feel free to donate.

- ETH: 0xf560e5F7F234307A20670ed8A5778F350a8366d1