semvec/pypi-packages huggingface dataset:
px6-proxy-fetcher 0.1.1
Fetch and export proxy listings from PROXY6.net.
Requires Python: >=3.9
Keywords: proxy, px6, proxy6, crawler

# px6-proxy-fetcher

Small helper that grabs your active proxies from [PROXY6.net](https://px6.me/) and drops them into a text file you can hand to whatever is doing the crawling. I've leaned on PX6 as my low-cost proxy pool for months; it's been steady and easy to manage, so this script wraps the one task I end up repeating the most.

## installation

Install from PyPI:

```bash
pip install px6-proxy-fetcher
# want .env support? pip install px6-proxy-fetcher[dotenv]
```

## getting started

First, grab your API key from the [PROXY6.net dashboard](https://px6.me/). Then run it:

```bash
export PX6_API_KEY="your_api_key_here"
px6-proxy-fetcher --print-env
```

That writes `proxies.txt` in the current directory containing your active proxies in `scheme://user:pass@host:port` format. With `--print-env`, it also emits shell exports for `PROXY_LIST` (comma-separated proxy URLs) and `PROXY_STRATEGY` (defaults to `round_robin`).

Options:
- `-o path/to/file.txt` - write to a different location
- `-q` - quiet mode (errors only)
- `-v` - verbose mode (debug output)
- `--print-env` - output shell export statements
- `--timeout SECONDS` - HTTP timeout for API requests (default: 30)

If `python-dotenv` is installed, a local `.env` file will be loaded automatically.

## cron idea

```
0 */6 * * * cd /path/to/px6-proxy-fetcher && px6-proxy-fetcher -o /var/run/proxies.txt
```

Keep `proxies.txt` out of Git; it holds authenticated endpoints. The script writes it with 600 permissions so only your user can read it, and the included `.gitignore` already skips it.

## requirements

- Python 3.9 or later
- A [PROXY6.net](https://px6.me/) account with an API key

## license

MIT - see the included `LICENSE` file.
l0n0lnat 3.1.8
Add your description here
Requires Python: >=3.8

# 功能: 内网穿透服务器与客户端

# 1. 安装
```bash
pip install l0n0lnat
```
# 2. 服务器命令
```bash
l0n0lnatserver -h
usage: l0n0lnatserver [-h] 监听地址 监听端口 密码

启动nat客户端

positional arguments:
  监听地址        服务器监听地址
  监听端口        服务器监听端口
  密码          通信密码

options:
  -h, --help  show this help message and exit
```

# 3. 客户端命令
```bash
l0n0lnatclient -h
usage: l0n0lnatclient [-h] [-6] 服务器地址 服务器端口 远端监听端口 被穿透的服务地址 被穿透的服务端口 密码

启动nat客户端

positional arguments:
  服务器地址           远程服务器地址
  服务器端口           远程服务器端口
  远端监听端口          远端监听端口
  被穿透的服务地址        被穿透的服务地址
  被穿透的服务端口        被穿透的服务端口
  密码              通信密码

options:
  -h, --help      show this help message and exit
  -6, --use-ipv6  启用 IPv6

```
# 4. 实例
* 被穿透服务: `A(192.168.1.2:80)`
* 服务器: `B(192.168.1.3)`

## 4.1 在`B`上执行
```bash
l0n0lnatserver 0.0.0.0 11223 123
```

## 4.2 在`A`上执行
```bash
l0n0lnatclient 192.168.1.3 11223 8888 127.0.0.1 80 123
```

## 4.3 访问`B:8888`
```bash
curl http://192.168.1.3:8888
```
xtlib 0.0.342
A set of tools for organizing and scaling ML experiments

# XTlib: Experiment Tools Library

XTlib is an API and command line tool for scaling and managing ML experiments.  

The goal of XTLib is to enable you to effortlessly organize and scale your ML experiments.
Our tools offer an incremental approach to adoption, so you can begin realizing benifits immediatly.

XT Key Features
  - Scale ML experiments across multiple COMPUTE services:
      - local machine, VM's, Azure Batch, Singularity, and Azure ML
  - Provide a consistent STORAGE model:
      - workspaces, experiments, jobs, runs
      - blob shares 
  - Provide related tooling:
      - live tensorboard, hyperparameter searching, reporting, plotting, utilities

XTLib provides an experiment STORE that enables you to easily track, compare, rerun, and share your ML experiments.  
The STORE consists of user-defined workspaces, each of which can contain a set of user-run experiments.  
XT currently supports 2 STORE services: local (folder-based) and azure (Azure Storage-based).

In addition, XTLb also provides easy access to scalable COMPUTE resources so you can 
easily run multiple experiments in parallel and on larger computers, as needed.  With this feature, 
you can scale from running  experiments on your local machine, to multiple VM's under your control, to compute 
services like Azure Batch and Azure ML.

Finally, XTLib offers a few other experiment-related features to help maximize your ML agility:
    - hyperparameter searching
    - run and job reports
    - ad-hoc plotting

For more information, run: xt --help

# Installation

For installation steps, see:

   - Windows:   INSTALL_ON_WINDOWS.md  (recommended)
   - Linux:     INSTALL_ON_LINUX.md
   - MAC OS:    INSTALL_ON_MAC.md

# Getting Started

After you have installed XT, you can read the following to geth started using XT:

    GETTING_STARTED.md

# Contributing

Check [CONTRIBUTING](CONTRIBUTING.md) page.

# Microsoft Open Source Code of Conduct

This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/)
or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.

# License

This project is licensed under the terms of the MIT license. See [LICENSE.txt](LICENSE.txt) for additional details.
ast-roller 0.0.1
Expressive AST-based dice roller
Requires Python: >=3.12

# ast_roller

<!-- TODO: Add shields/badges >
<!-- TODO: Add test coverage badge (TBD) -->
<!-- TODO: Add GitHub Actions status badge (pass/fail) once build actions are set up -->

An expressive, abstract syntax tree-based dice roller.

### Installation
TBD

### Usage

As a library:

```shel
>>> from ast_roller.grammar import parser, transformer
>>> roll_string = '2 2d20 kh1 + 8'
>>> eval_root = transformer.transform(parser.parse(roll_string))
>>> result_root = eval_root.evaluate()
>>> print(result_root.pretty_print())
List Expansion: 2 (2d20 kh1 + 8)
  Count: 2 => 2
  Expression: (2d20 kh1 + 8)
  Results: [21, 26]
  0: 
    (2d20 kh1 + 8) => ([13, 8] + 8) => 13 + 8 = 21
  1: 
    (2d20 kh1 + 8) => ([6, 18] + 8) => 18 + 8 = 26
```

As a command-line tool:

```
TBD
```

### Design

This package processes dice rolls in tree main steps:
- 1. Parse dice roll strings into syntax trees using Lark and a defined roll string grammar.
- 2. Transforming the parse tree into an evaluation tree
- 3. Recursively call `evaluate()` from the root of the evaluation tree.

This logic is spread across three files:
- `grammar.py`: Contains the dice roll grammar and logic for transforming parse trees into eval trees.
- `evaluators.py`: Handles evaluation logic.
- `results.py`: Handles 

### Contributing

Contributions are welcome and should be pretty manageable. New roll features can be included by adding a definition for the new rule to the grammar and adding or modifying corresponding `EvaluatorNode` and `ResultNode` definitions to implement the actual logic.

Code changes must be accompanied by new or reconciled spec code in `src/tests`. 

I feel lukewarm at best about the current output formats so if anyone has better ideas, I'd love an issue suggesting the changes.