semvec/pypi-packages huggingface dataset:
pynooj 0.1.4
Python librairy for parsing NooJ's dictionary files
Requires Python: >=3.11
Keywords: nlp, nooj, linguistics

# pynooj

Python library for parsing NooJ's dictionary files.

## Overview

**pynooj** is a Python library that parses NooJ dictionary files (`.dic`) and extracts lexical information including inflected forms, lemmas, grammatical categories, and morphological traits.

For more information about NooJ, visit the [NooJ website](https://nooj.univ-fcomte.fr/).

## Installation

```bash
pip install pynooj
```

## Usage

### Basic Example

```python
from pynooj import read_dic

# Parse a NooJ dictionary file
entries = read_dic("path/to/dictionary.dic")

# Each entry is a dictionary containing:
# - "inflected form": the word form
# - "lemma": the base form (optional)
# - "category": grammatical category (e.g., "V", "N", "A")
# - "traits": morphological attributes

for entry in entries:
    print(entry["inflected form"], "→", entry["lemma"])
    print(f"  Category: {entry['category']}")
    print(f"  Traits: {entry['traits']}")
```

### Dictionary File Format

NooJ dictionary files use a comma-separated format:

```
inflected_form,lemma,category+Trait1=Value1+Trait2=Value2
```

Examples:
```
amo,amare,V+Theme=INF+FLX=GP1_INF+GP=1
casa,casa,N+Number=SG+Gender=F
```

### API Reference

#### `read_dic(path)`

Parses a NooJ dictionary file and returns a list of lexical entries.

**Parameters:**
- `path` (str): Path to the `.dic` file

**Returns:**
- List of dictionaries, each containing:
  - `"inflected form"`: the word form (string)
  - `"lemma"`: the base form (string, optional)
  - `"category"`: grammatical category (string)
  - `"traits"`: dictionary of morphological traits (dict)


## Running Tests

To run the test suite with unittest:

```bash
python -m unittest discover -s tests
```

## Publishing to PyPI

### Prerequisites

Ensure you have the necessary tools installed:

```bash
pip install build twine
```

### Steps

1. **Update version** in `pyproject.toml`

2. **Build the package:**
   ```bash
   python -m build
   ```

3. **Upload to PyPI:**
   ```bash
   twine upload dist/*
   ```

4. **Upload to TestPyPI** (optional, for testing):
   ```bash
   twine upload --repository testpypi dist/*
   ```

## Contributing

Contributions are welcome! Please feel free to submit issues and pull requests.

## License

See the [LICENSE](LICENSE) file for details.

## Related Resources

- [NooJ Official Website](https://nooj.univ-fcomte.fr/)
- [NooJ Manual](https://nooj.univ-fcomte.fr/)
- [GitHub Repository](https://github.com/crispyfunicular/pynooj)
python-multipart 0.0.22
A streaming multipart parser for Python
Requires Python: >=3.10

# [Python-Multipart](https://kludex.github.io/python-multipart/)

[![Package version](https://badge.fury.io/py/python-multipart.svg)](https://pypi.python.org/pypi/python-multipart)
[![Supported Python Version](https://img.shields.io/pypi/pyversions/python-multipart.svg?color=%2334D058)](https://pypi.org/project/python-multipart)

---

`python-multipart` is an Apache2-licensed streaming multipart parser for Python.
Test coverage is currently 100%.

## Why?

Because streaming uploads are awesome for large files.
lynxkite-app 0.3.0
The LynxKite application, with web server and UI
Requires Python: >=3.11

# LynxKite MM

This is an experimental rewrite of [LynxKite](https://github.com/lynxkite/lynxkite). It is not compatible with the
original LynxKite. The primary goals of this rewrite are:

- Target GPU clusters instead of Hadoop clusters. We use Python instead of Scala, RAPIDS instead of Apache Spark.
- More extensible backend. Make it easy to add new LynxKite boxes. Make it easy to use our frontend for other purposes,
  configuring and executing other pipelines.

## Development

To run the backend:

```bash
uv pip install -e .
cd ../examples && LYNXKITE_RELOAD=1 lynxkite
```

To run the frontend:

```bash
cd web
npm i
npm run dev
```

To update the frontend types with the backend types:

```bash
$ uv run pydantic2ts --module lynxkite_core.frontend_types --output ./web/src/apiTypes.ts --json2ts-cmd "npx json-schema-to-typescript"
```
pydaraja 1.0.0
Python wrapper for Mpesa's Daraja API
Requires Python: >=3.12
Keywords: mpesa, daraja

# pydaraja
[![PyPI version](https://badge.fury.io/py/pydaraja.svg)](https://badge.fury.io/py/pydaraja)
[![Wheel Status](https://img.shields.io/badge/wheel-yes-green.svg)](https://pypi.python.org/pypi/pydaraja/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
## Description
This Python wrapper allows developers to seamlessly interact with the MPESA's Daraja API and manage payment requests within their Python applications.

 It streamlines and abstracts the complexity of integrating with the MPESA's Daraja API, providing developers with a convenient and efficient means of handling payment transactions

Daraja API services offered by pydaraja are:
- Lipa na M-PESA online API also known as M-PESA express (STK Push/NI push)
- STK push query API -> Used to check the status of Lipa na Mpesa online payment

More services will come soon.

## Installation
```
pip install -U pydaraja
```

## Usage
1. Lipa na Mpesa Online API (STK push) and STK push query API.


```python
from pydaraja import MpesaPaymentGateway

# Create MpesaPaymentGateway instance
mpesa = MpesaPaymentGateway(
    api_host="https://sandbox.safaricom.co.ke",
    consumer_key="consumer_key",
    consumer_secret="consumer_secret",
    business_shortcode="business_shortcode",
    passkey="passkey"
    callback_url="your_callback_url"
    account_reference="account_reference" # name of your business
)

# Trigger STK push prompt
response = mpesa.trigger_stk_push(phone_number="+254700000000", amount=1)

print(response.json())
# Output
{
    'MerchantRequestID': '2654-4b64-97ff-b827b542881d164797',
    'CheckoutRequestID': 'ws_CO_18072024175449513769356298',
    'ResponseCode': '0',
    'ResponseDescription': 'Success. Request accepted for processing',
    'CustomerMessage': 'Success. Request accepted for processing'
}


# use checkout_request_id from the above stk push as parameter for the function below
response = mpesa.query_stk_push(checkout_request_id=your_checkout_request_id)

print(response.json())
# Output
{
    'ResponseCode': '0',
    'ResponseDescription': 'The service request has been accepted successsfully',
    'MerchantRequestID': '2654-4b64-97ff-b827b542881d164797',
    'CheckoutRequestID': 'ws_CO_18072024175449513769356298',
    'ResultCode': '0',
    'ResultDesc': 'The service request is processed successfully.'
 }
```

## Daraja API Environments
Sandbox(Test environment) - https://sandbox.safaricom.co.ke

Production(Live environment for real transactions) - https://api.safaricom.co.ke

## Contributing
To contribute to this project, we kindly request you to review the [CONTRIBUTING.md](https://github.com/raykipkorir/pydaraja/blob/main/CONTRIBUTING.md)  file for detailed guidelines.


## License
This python package is available as open source under the terms of the [MIT License](https://opensource.org/license/mit/)
lynxkite-graph-analytics 0.3.0
The graph analytics executor and boxes for LynxKite
Requires Python: >=3.11

# LynxKite Graph Analytics

This is a LynxKite plugin that provides a graph analytics environment.
Includes a batch executor operating on graph bundles and a collection of GPU-accelerated graph data science operations.

To use this, install both LynxKite and this plugin.
Then "LynxKite Graph Analytics" will show up as one of the workspace types in LynxKite.

```bash
pip install lynxkite lynxkite-graph-analytics
```

Run LynxKite with `NX_CUGRAPH_AUTOCONFIG=True` to enable GPU-accelerated graph data science operations.