semvec/pypi-packages huggingface dataset:
HelixNet 0.7.0
A powerful simple Neural Network building blocks based on MyGrad
Requires Python: >=3.9

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

A small, extensible, and lightweight framework for building powerful neural networks in Python, built on `mygrad`.

HelixNet is designed to be a transparent and easy-to-understand tool for learning and experimentation. It is powerful enough to run complex models like CNNs and LSTMs, but simple enough to run efficiently on modest hardware.

---

## Key Features

* **Lightweight & Simple:** No complex compilation or heavy dependencies. Just plug and play.
* **Extensible by Design:** A clean, object-oriented structure (`Layer`, `Optimiser`) makes it easy to create your own custom layers and optimizers.
* **Modern Architecture:** Includes common layers like `Dense`, `Conv2D`, `MaxPooling2D`, `LSTM`, and `Embedding`.
* **Powerful Optimizers:** Comes with robust implementations of `SGD` (with momentum), `RMSProp` and`Adam`.
* **Full Documentation:** Comprehensive documentation available [here](https://helixnet.readthedocs.io/en/latest/).

## Installation

```bash
# For the latest stable version
pip install HelixNet

# For development (editable) mode
pip install -e .
```

## Quickstart: Training a Model

Here's a quick example of how to build and train a model on the classic "spiral" dataset.

```python
import numpy as np
import mygrad as mg
import helixnet.layers as layers
import helixnet.optimisers as optimisers
import helixnet.activations as activations
import helixnet.models as models
from nnfs.datasets import spiral_data

# Create dataset
X, y = spiral_data(samples=100, classes=3)
X = mg.tensor(X)
y = mg.tensor(y, dtype=int)

# Build model
model = models.Sequental([
    layers.Dense(2, 64, activation=activations.ReLU),
    layers.Dense(64, 3, activation=(lambda x: x)) # Logits
])

optim = optimisers.Adam(learning_rate=0.05, decay=5e-7)

# Train the model
for epoch in range(10001):
    logits = model.forward(X)
    loss = mg.nnet.losses.softmax_crossentropy(logits, y)

    loss.backward()
    optim.optimise(model)
    model.null_grads()

    if epoch % 100 == 0:
        accuracy = np.mean(np.argmax(logits.data, axis=1) == y.data)
        print(f'Epoch: {epoch}, Loss: {loss.data:.4f}, Accuracy: {accuracy:.4f}')
```

## Documentation

For a full guide to all layers, optimizers, and functionalities, please see the **[Full HelixNet Documentation](https://helixnet.readthedocs.io/en/latest/)**.

## Contributing

Contributions are welcome! If you find a bug or have a feature request, please open an issue. If you'd like to contribute code, please see the notes on our own contributions to `mygrad` ([#445](https://github.com/rsokl/MyGrad/pull/445)) for an example of our development philosophy.
psi_toml 0.0.8
A very lite implementation of a toml parser, reader, and writer
Requires Python: >=3.11

# psi_toml

A very lite implementation of a toml parser, reader, and writer

It is not a **1.0.0-compliant** [TOML](https://toml.io/) library, nor is it intended to be.

It can parse basic toml files to a dict, and write a dict to a toml file using the *load* and *dump* methods.

## Usage

```python
from psi_toml import toml as toml
    result = toml.load(f_toml)
```

```python
    toml.dump(data, f_toml)
```

```python
    toml.parse(strings)
```

where *f_toml* is the handle to the toml file, *data* is a python dict and *strings* is a list of strings representing key value pairs. E.g.

```python
    nl = '\n'
    strings = [
        'a = 1',
        'b = -1',
        'c = .5',
        'd = abc',
        'e = 3.14',
        'f = "1.414"',
        'g = true',
        'h = "false"',
        (f'i = [{nl}'
            f'"a",{nl}'
            f'"b",{nl}'
            f'"c",{nl}'
            f'"d",{nl}'
            f']'),
        (f'j = {{{nl}'
            f'"a": 1,{nl}'
            f'"b": 2,{nl}'
            f'"c": 3,{nl}'
            f'"d": 4,{nl}'
            f'}}')
    result = toml.parse(strings)

```

## Installation

If you are using [Poetry](https://poetry.eustace.io),
add `psi_toml` to your `pyproject.toml` file by using:

```bash
poetry add psi_toml
```

If not, you can use `pip`:

```bash
pip install psi_toml
simple-hwp2pdf 1.0.6
MS Word를 이용해 HWP 파일을 PDF로 변환하는 라이브러리
Requires Python: >=3.8

# simple-hwp2pdf

[![PyPI version](https://badge.fury.io/py/simple-hwp2pdf.svg)](https://badge.fury.io/py/simple-hwp2pdf)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

한컴오피스 설치 유무에 따라 HWP(.hwp, .hwpx) 파일을 PDF로 변환하는 파이썬 라이브러리입니다.

## ✨ 주요 특징

-   **듀얼 엔진 지원**: 한컴오피스를 이용하는 **Office 엔진**과, 설치가 필요 없는 **Standalone 엔진**을 모두 지원합니다.
-   **자동 모드**: 파일 확장자에 따라 최적의 엔진을 자동으로 선택합니다.
-   **선택적 설치**: 필요한 기능에 따라 라이브러리를 설치할 수 있습니다.

## ⚙️ 엔진 별 특징

| 엔진 종류 | 필요 조건 | 장점 | 단점 |
| :--- | :--- | :--- | :--- |
| **Standalone** | (없음) | 한컴오피스 불필요, 모든 OS 지원 | `.hwpx`만 완벽 지원, 레이아웃 깨질 수 있음 |
| **Office** | Windows + 한컴오피스 | 완벽한 레이아웃 보장, `.hwp` 지원 | Windows 환경 및 한컴오피스 설치 필수 |

## 📦 설치

**기본 설치 (Standalone 엔진만 사용)**
```shell
pip install simple-hwp2pdf
```
## 전체 설치(Office 엔진 포함)
* Office 엔진을 사용하려면 [office]옵션을 추가하여 설치하세요
```shell
pip install simple-hwp2pdf[office]
```
## 🚀 사용법
* 메인 convert 함수를 사용하여 변환을 수행할 수 있습니다. method 파라미터를 통해 사용할 엔진을 지정할 수 있습니다.
    * method='auto' (기본값): .hwpx는 Standalone, .hwp는 Office 엔진을 시도합니다.
    * method='standalone': 한컴오피스 없이 변환합니다.
    * method='office': 한컴오피스를 이용해 변환합니다.
```python
from simple_hwp2pdf import convert
# 1. Auto 모드 사용 (가장 간편한 방법)
# sample.hwpx -> standalone 엔진 사용
# report.hwp -> office 엔진 사용
convert("sample.hwpx", "sample_auto.pdf", method='auto')
convert("report.hwp", "report_auto.pdf") # method 기본값이 'auto'

# 2. Standalone 엔진 사용
# 한컴오피스 없이 변환 (hwpx 파일 권장)
convert("another.hwpx", "another_standalone.pdf", method='standalone')

# 3. Office 엔진 사용
# Windows + 한컴오피스 환경에서 완벽한 변환이 필요할 때
convert("final.hwp", "final_office.pdf", method='office')
```