semvec/pypi-packages huggingface dataset:
fasttask-manager 0.4.1
fasttask's manager 

manager for [fasttask](https://github.com/iridesc/fasttask) 

### create project 

```bash
python -m fasttask_manager.create_project
```


### create a Manager

```python
m = Manager("127.0.0.1", task_name="get_hypotenuse", port=8080)
```


### run a task

```python
result = m.run(params)
```


### create a task and check result later

```python
result_id = m.create_task(params)
# do something...
# do something...
# do something...
result = m.check(result_id)
```

### create a task and wait for result

```python
result = m.create_and_wait_result(params)    
```
LscCalculator 0.0.7
计算库（整合decimal）
Requires Python: >=3.7

# 强大的计算工具（整合decimal）

### 解决de问题
* 使用decimal库，防止0.1+0.2=0.30...4的局面
* 每个方法皆可输入多个数字，拒绝addition(1, addition(2, 3))

### 多功能
* 额外添加StringsCalculator

### 调用方法
```
from LscCalculator import *

"""
nc / NC / NumbersCalculator : 计算数字运算的类
addition : 加法
subtraction : 减法
multiplication : 乘法
division : 除法
power : 乘方
factorial : 阶乘
sqrt : 开根号
"""

print(nc().addition(1, 2, 3, 4)) 
```
alphared 0.1.0
A lightweight SDK for logging ML experiments to AlphaRed.
Requires Python: >=3.7

# AlphaRed SDK

A lightweight, professional SDK for logging machine learning experiments to the AlphaRed platform. 

## Features
- 🚀 **Real-time Metrics**: Log loss, accuracy, and custom metrics in the background.
- 📊 **Auto-Telemetry**: Automatically track CPU, RAM, and Disk metrics.
- ⚡ **Non-blocking**: Multi-threaded logging ensures your training script speed isn't affected.

## Installation
```bash
pip install alphared
```

## Quick Start
```python
import alphared

# Initialize the project
alphared.init(project="my-mnist-project")

# Your training loop
for epoch in range(10):
    # ... training logic ...
    alphared.log({"epoch": epoch, "loss": 0.5, "accuracy": 0.85})

# Finalize the run
alphared.finish()
```
py-api-dumper 4.1
Python API dumping and comparison tool
Requires Python: >=3.10

# Python API dumping and comparison tool

Dumps the public API of a Python module and its members to a file, which can
then be used to show differences in the public API between two dumps, e.g. of
different versions of the same module.

## Command-line interface

```
$ py-api-dumper --help
```

* To dump the public API of a module `mymod`:

  ```
  $ py-api-dumper dump -o mymod1.dump mymod
  ```

  `mymod1.dump` will record the public API of `mymod` in a reloadable format.

* To print the API of `mymod` in text format:
  ```
  $ py-api-dumper dump mymod
  MODULE : mymod
      CLASS : myclass
          FUNCTION : __init__ : no-return-type
              REQUIRED : 0 : x : int
  ...
  ```

  The text format is a tree of entries of each nested class, class method,
  function, member variable, etc. in the public API.

* To compare the API of `mymod` between different versions:
  ```
  $ py-api-dumper diff mymod-old.dump mymod-new.dump
  --- mymod-old.dump mymod=1.0
  +++ mymod-new.dump mymod=2.0
  +MODULE : mymod
  +    CLASS : myclass
  +        FUNCTION : __init__ : no-return-type
  +            REQUIRED : 1 : b : no-type
  ```

  The above output shows the expected output if, between `mymod` versions 1.0
  and 2.0, an additional positional argument `b` had been added to the
  `__init__` method of the class `mymod.myclass`.

  ```
  $ py-api-dumper diff -o mymod.diff ...
  ```

  This will write out the API differences to `mymod.diff` in JSON format:

  * the paths to the dumps of the old and new APIs, e.g. `mymod-old.dump`
    vs. `mymod-new.dump`;
  * the version of `mymod` at the old and new API dumps, e.g. mymod `1.0`
    vs. `2.0`;
  * API entries which have been *removed*, i.e. present in the old API but not
    in the new API (e.g. none in the above example);
  * API entries which have been *added*, i.e. present in the new API but not in
    the old API (e.g. the `b` argument in the above example).

## Python interface

```python
from py_api_dumper import APIDump, APIDiff
```

* To dump the public API of a module `mymod`:
  ```python
  import mymod
  dump = APIDump.from_modules(mymod)   # OR: APIDump.from_modules("mymod")
  dump.save_to_file("mymod.dump")
  ```

* To print the API of `mymod` in text format:
  ```python
  dump.print_as_text()
  ```

* To compare the API of `mymod` between different versions:
  ```python
  diff = APIDiff.from_files("mymod-old.dump", "mymod-new.dump")
  diff.print_as_text()
  diff.save_as_json("mymod.diff")
  ```