semvec/pypi-packages huggingface dataset:
syncra 1.0.3
A utility for creating synchronous and asynchronous compatible methods.
Requires Python: >=3.6

# syncra

?? Syncra provides async harmony. See the examples below to learn how to create functions and classes that work in both synchronous and asynchronous contexts.

## Features

- **Async and Sync Compatibility**: Easily create functions that work in both synchronous and asynchronous contexts.
- **Flexible Initialization**: Use `AsyncObj` for classes requiring asynchronous initialization.
- **Decorator for Async Methods**: Simplify async method usage with the `sync_compat` decorator.

## Installation

Install via pip:

```bash
pip install syncra
```

## Usage

### sync_async_factory

_Create a function that can be called synchronously or asynchronously:_

```python
from syncra import sync_async_factory
import asyncio

def sync_func(x):
    return x * 2


async def async_func(x):
    await asyncio.sleep(0.1)
    return x * 2


syncra = sync_async_factory(sync_func, async_func)

# Usage:
result = syncra(5)  # Synchronous


async def main():  # Asynchronous
    result = await syncra(5)
```

### `@sync_compat` Decorator

Make an async function compatible with sync calls

```python
from syncra import sync_compat
import asyncio


@sync_compat
async def async_function(x):
    await asyncio.sleep(0.1)
    return x * 2


# Usage:
result = async_function(5)  # Synchronous


async def main():  # Asynchronous
    result = await async_function(5)

```


### `AsyncObj` Class

Create a class that can be initialized asynchronously:

```python
from syncra import AsyncObj


class MyAsyncClass(AsyncObj):
    async def __ainit__(self, x):
        self.x = x


# Usage:
async def main():
    obj = await MyAsyncClass(10)
    print(obj.x)
```

### Licence
This project is licensed under the MIT License.
scikit-fuzzy 0.5.0
Fuzzy logic toolkit for SciPy

scikit-fuzzy
============

`scikit-fuzzy` is a fuzzy logic toolkit for SciPy.

The goals of scikit-fuzzy are:
* To provide the community with a robust toolkit of independently developed and
  implemented fuzzy logic algorithms
* To increase the attractiveness of scientific Python as a valid alternative to
  closed-source options.

Please cite [![DOI](https://zenodo.org/badge/8872608.svg)](https://zenodo.org/badge/latestdoi/8872608)
if you find scikit-fuzzy useful.  A formal paper describing this package is in
preparation.

Source
------

https://github.com/scikit-fuzzy/scikit-fuzzy

Documentation
-------------

The documentation of the library can be found here: https://scikit-fuzzy.github.io/scikit-fuzzy/

Online Discussion & Mailing List
--------------------------------

Please join the discussion in our public chat room on Gitter.im
[![Gitter](https://badges.gitter.im/JoinChat.svg)](https://gitter.im/scikit-fuzzy/scikit-fuzzy?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

or view/post on the Google Groups mailing list
http://groups.google.com/group/scikit-fuzzy

Installation
------------

Scikit-Fuzzy depends on
  
  * Matplotlib >= 3.1
  * NumPy >= 1.6
  * SciPy >= 0.9
  * NetworkX >= 1.9

and is available on PyPi! The latest stable release can always be obtained
and installed simply by running

    $ pip install -U scikit-fuzzy

which will also work to upgrade existing installations to the latest release.


If you prefer to install from source or develop this package, you can fork and
clone this repository then install SciKit-Fuzzy by running

	$ pip install -e .

or develop locally by running

	$ pip install -e ".[develop]"

If you prefer, you can use SciKit-Fuzzy without installing by simply exporting
this path to your PYTHONPATH variable.

License
-------

Please read LICENSE.txt in this directory.

IEEE Rounding for Matlab users
------------------------------

It should be noted that Matlab rounds incorrectly. The IEEE standard (which is
how this package behaves) requires rounding to the nearest EVEN number if
exactly between, e.g. 1.5 --> 2; 2.5 --> 2; 3.5 --> 4; 4.5 --> 4, etc. This
minimizes systematic rounding error. Thus, if re-implementing algorithms from
Matlab code, slight inconsistencies in rounded results are expected. These are
not bugs, and will not be fixed.
mimirs 0.0.3
Mimir is a dict-subclass that calculates missing values through its well attribute.
Requires Python: >=3.11

======
mimirs
======

Overview
--------

Mimir is a dict-subclass that calculates missing values through its well attribute.

Installation
------------

To install mimirs, you can use `pip`. Open your terminal and run:

.. code-block:: bash

    pip install mimirs

Links
-----

* `Download <https://pypi.org/project/mimirs/#files>`_