semvec/pypi-packages huggingface dataset:
decorapy 0.1.0
DecoraPy - A Collection of Powerful Python Decorators
Requires Python: >=3.12

# `decorapy` - A Collection of Powerful Python Decorators  

`decorapy` is a lightweight yet versatile Python package that provides a variety of decorators to enhance code functionality. It includes utilities for performance benchmarking, memoization, retries, logging, validation, circuit breaking, and more. Designed for both synchronous and asynchronous functions, `pydeco` helps improve code efficiency, maintainability, and reliability with minimal effort.

**Key Features:**  
✔ **Performance Tracking** – `benchmark`, `timer`  
✔ **Caching & Memoization** – `memoize`, `lru_memoize`  
✔ **Resilience & Fault Handling** – `retry`, `CircuitBreaker`  
✔ **Logging & Tracing** – `log_calls`, `trace`  
✔ **Rate Limiting** – `throttle`  
✔ **Singleton Pattern** – `singleton`  
✔ **Input Validation** – `validate`  

Ideal for developers looking to streamline function behavior with minimal boilerplate! 🚀
pyslalib 1.0.10
f2py and numpy based wrappers for SLALIB
Requires Python: >=3.8

pySLALIB v1.0.2  (Dec 2010)
---------------

This is archive contains new f2py-generated (and hand-tweaked to
eliminate unnecessary function/subroutine arguments) wrappers for the
Fortran version of P.T. Wallace's SLALIB positional astronomy library.
SLALIB used to be hosted by the STARLINK site, although that service
has been suspended.  The version of SLALIB included here is 2.5-4
(with several additional tweaks) and is released under the GPL.

The python wrappers cover every function in SLALIB and a comprehensive
set of unit tests are available in the test/ directory.  The only
external dependency is numpy (http://numpy.scipy.org).  These wrappers
are not related to the older (and apparently abandoned) pySLALIB that
was once available on the Web (and which depended on Numeric as
opposed to numpy).

Installation
------------
Most users will only need to do:
  > python setup.py install
to generate the wrappers, build, and install the library.

Once slalib.so has been installed in your PYTHONPATH, you can run the
unittests via:
  > python test/test_slalib.py

Example Usage (using IPython)
-------------
In [1]: from pyslalib import slalib

In [2]: slalib.sla_veri()
Out[2]: 2005004

In [3]: slalib.sla_caldj(1999, 12, 31)
Out[3]: (51543.0, 0)

In [4]: slalib.sla_etrms(1976.9)
Out[4]: array([ -1.62161710e-06,  -3.31007009e-07,  -1.43529663e-07])

In [5]: slalib.sla_fk45z(1.234, -0.123, 1984)
Out[5]: (1.2446165107316911, -0.12141858395865548)

In [6]: slalib.sla_dafin("-00 03 34.6", 1)
Out[6]: (12, -0.0010404101596610642, 0)

In [7]: slalib.sla_obs(0, "GBT")
Out[7]:
('GBT',
 'Green Bank Telescope                    ',
 1.3934679949996727,
 0.67078450520692623,
 880.0)

If you import "sladoc" you can print the original Fortran doc
strings using something like:

In [1]: from pyslalib import slalib, sladoc

In [2]: print sladoc['sla_caldj']
"""
*     - - - - - -
*      C A L D J
*     - - - - - -
*
*  Gregorian Calendar to Modified Julian Date
*
*  (Includes century default feature:  use sla_CLDJ for years
*   before 100AD.)
*
*  Given:
*     IY,IM,ID     int    year, month, day in Gregorian calendar
*
...

Thanks go to Prasanth for adding the docstring capabilities!

If you would like to build a shared library for linking with other
programs, a simple Makefile is also included that should work with
only minor tweaks for most Unix-like OSs.

Please let me know if you find any problems.

Scott

----------------------------------
Scott M. Ransom <sransom@nrao.edu>
http://www.cv.nrao.edu/~sransom
operator-precedence-high-roller 1.2.1
dice command parser/roller discord bot
Requires Python: >=3.8

# Operator Precedence High Roller Package

This is a package for a discord bot. I call it High Roller as a play on its original use for TTRPG rolling, as well as a joking reference to gambling. Also recently I added a !gamble command to make the joke more literal.

How to run -
Enter the main directory in terminal.
python -m operator_precedence_high_roller.high_roller

Commands -

! is the general character to put before a discord message to be read by the bot.

Command => '!' [EXPR]

Command => '!gamble'

Command => [BET]

Command => '!' [RECALL]

EXPR => [EXPR] '+' [EXPR]

EXPR => [EXPR] '-' [EXPR]

EXPR => [EXPR] '\*' [EXPR]

EXPR => [EXPR] '/' [EXPR]

EXPR => '(' [EXPR] ')'

EXPR => [NUM]

EXPR => [ROLL]

ROLL => 'd' [NUM]

ROLL => 'e' [NUM]

ROLL => [NUM] 'd' [NUM]

ROLL => [NUM] 'e' [NUM]

NUM => [0..9]+

BET => 'odds'

BET => 'evens'

RECALL => 'h'

RECALL => 'h' '(' [NUM] ',' [ROLL] ')'

Version history -

1.1.2 - everything except RECALL commands works

1.1.3 - now everything works like it should

1.1.4 - small bug-fix

1.2.0 - big update, all unit tests done, general functional changes

1.2.1 - [

- XdYkhZ syntax added
- roll X dice, each of which has Y sides, and keep the highest Z of the results
- X and Z must not be equal
- Z must be greater than 0
- Z can be left blank in the command, in which case it will be set to 1

- disallow rolls with 0 dice

- disallow rolls of dice with 0 sides

- dice roll functions return None instead of (0,0) in the case of errors

- high_roller.py had to be moved to the outermost directory
- i'm not at all sure why, but before making the change, calls made from high_roller.py to functions from other files seemingly referenced old versions of them.
  ]
r-mutex 1.1.0
A simple Redis based lock
Requires Python: >=3.12

### **Overview**
A distributed asynchronous lock built on top of the Redis PubSub, Get and Set methods. This takes inspiration from the asyncio Lock whereby futures are used instead of the polling done by the multiprocessing Lock.

It's free to be built upon locally for your needs. Optionally you can do `pip install r-mutex`

### **Requirements**
- Redis
- Python 3.12.6
If you don't have Redis but have docker you can simply run this command.
`docker run --name <name> -d -p 6379:6379`

If you want to see the messages being sent back and forth in real-time you can do
```
docker exec -it <name> redis-cli
SUBSCRIBE <key>.live or <key>.broadcast
```

### **Contact**
https://www.linkedin.com/in/jadore-t-49379a295/
https://twitter.com/jtzenz
AsyncHttpX 0.0.2
AsyncHttpX Library is a high-performance, asynchronous HTTP client built on top of the powerful httpx library. Designed for developers who need a robust and flexible way to make HTTP requests in Python
Requires Python: >=3.0

# AsyncHttpX Library

**AsyncHttpX Library** is a high-performance, asynchronous HTTP client built on top of the powerful [httpx](https://www.python-httpx.org/) library. Designed for developers who need a robust and flexible way to make HTTP requests in Python, this library extends `httpx` with enhanced features such as request retries, connection pooling, automatic response parsing, and built-in support for common authentication mechanisms.

## Features

- **Asynchronous Support**: Built on top of the `httpx` library, making it fully asynchronous and optimized for high-performance applications.
- **Automatic Response Parsing**: Automatically parses JSON, XML, or other common response types.
- **Request Retries**: Configurable retries for failed requests, ensuring reliability in case of transient issues.
- **Connection Pooling**: Efficient management of HTTP connections to optimize performance.
- **Authentication Support**: Built-in support for basic authentication, bearer tokens, and other common mechanisms.
- **Customizable**: Easily extendable and customizable for your specific HTTP client needs.

## Installation

You can install the `AsyncHttpX` library using `pip`:

```bash
pip install AsyncHttpX

```
langchain-goodfire 0.2.4
Goodfire integration for LangChain
Requires Python: >=3.8.1

# LangChain Goodfire Integration

This package contains the LangChain integration for the [Goodfire API](https://docs.goodfire.ai/).

## Installation

```bash
pip install langchain-goodfire
```

## Usage

```python
from langchain_goodfire import ChatGoodfire
from langchain_core.messages import SystemMessage, HumanMessage
import goodfire

chat = ChatGoodfire(
    model=goodfire.Variant("meta-llama/Llama-3.3-70B-Instruct"),
    goodfire_api_key="your-api-key"
)

messages = [
    SystemMessage(content="You are a helpful assistant."),
    HumanMessage(content="Hello!")
]

response = chat.invoke(messages)
print(response)
```

### Async Environment Usage

When using this package in an environment with an existing event loop (**e.g., Jupyter notebook**):
- Use the async versions of methods since an event loop is already running
- Replace `chat.invoke(messages)` with `await chat.ainvoke(messages)`
- Similarly, use `await chat.abatch(...)`, `await chat.astream(...)`, etc.

**Technical Note:** Synchronous methods won't work in environments with an existing event loop because the Goodfire client library uses asyncio internally. When an event loop is already running, you must use async methods to properly interface with the Goodfire client library.

## Development

To install the package in development mode:

```bash
pip install -e .
```

## Testing

Run tests using pytest:

```bash
# run unit tests without network access
poetry run pytest --disable-socket --allow-unix-socket --asyncio-mode=auto tests/unit_tests
```

```bash
# run integration tests
poetry run pytest --asyncio-mode=auto tests/integration_tests
```

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## Support

For support, please open an issue on the GitHub repository.
image-processing-drigonato 0.0.1
Processamento de imagens usando Skimage
Requires Python: >=3.8

# package_name

Description.
The package package_name is used to:
Image Processing - Histogram matching - Structural similarity - Resize image

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install package_name

```bash
pip install package_name
```

## Author

Dorival

## License

[MIT](https://choosealicense.com/licenses/mit/)