semvec/pypi-packages huggingface dataset:
langchain-hana-prototype 1.1.0
An integration package connecting SAP Hana Cloud and LangChain
License: MIT
Requires Python: <4.0,>=3.9

[![REUSE status](https://api.reuse.software/badge/github.com/SAP/langchain-integration-for-sap-hana-cloud)](https://api.reuse.software/info/github.com/SAP/langchain-integration-for-sap-hana-cloud)

# LangChain integration for SAP HANA Cloud

## About this project

Integrates LangChain with SAP HANA Cloud to make use of vector search, knowledge graph, and further in-database capabilities as part of LLM-driven applications.

## Requirements and Setup

### Prerequisites

- **Python Environment**: Ensure you have Python 3.9 or higher installed.
- **SAP HANA Cloud**: Access to a running SAP HANA Cloud instance.


### Installation

Install the LangChain SAP HANA Cloud integration package using `pip`:

```bash
pip install -U langchain-sap-hana-cloud
```

### Setting Up Vectorstore

The `HanaDB` class is used to connect to SAP HANA Cloud Vector Engine.

Here’s how to set up the connection and initialize the vector store:

```python
from langchain_sap_hana_cloud import HanaDB
from hdbcli import dbapi

# use a LangChain Embeddings class
embeddings = ...  

# Establish the SAP HANA Cloud connection
connection = dbapi.connect(
    address="<hostname>",
    port=3<NN>MM,
    user="<username>",
    password="<password>"
)

# Initialize the HanaDB vector store
vectorstore = HanaDB(
    connection=connection,
    embeddings=embeddings,
    table_name="<table_name>"  # Optional: Default is "EMBEDDINGS"
)

```


## Support, Feedback, Contributing

This project is open to feature requests/suggestions, bug reports etc. via [GitHub issues](https://github.com/SAP/langchain-integration-for-sap-hana-cloud/issues). Contribution and feedback are encouraged and always welcome. For more information about how to contribute, the project structure, as well as additional contribution information, see our [Contribution Guidelines](CONTRIBUTING.md).

## Security / Disclosure
If you find any bug that may be a security problem, please follow our instructions at [in our security policy](https://github.com/SAP/langchain-integration-for-sap-hana-cloud/security/policy) on how to report it. Please do not create GitHub issues for security-related doubts or problems.

## Code of Conduct

We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone. By participating in this project, you agree to abide by its [Code of Conduct](https://github.com/SAP/.github/blob/main/CODE_OF_CONDUCT.md) at all times.

## Licensing

Copyright 2025 SAP SE or an SAP affiliate company and langchain-integration-for-sap-hana-cloud contributors. Please see our [LICENSE](LICENSE) for copyright and license information. Detailed information including third-party components and their licensing/copyright information is available [via the REUSE tool](https://api.reuse.software/info/github.com/SAP/langchain-integration-for-sap-hana-cloud).
multicall.py 1.3.7
Ethereum multiple contract/rpc calls
License: MIT
Requires Python: >=3.6
Keywords: ethereum jsonrpc contract multicall

# Multicall

fork from https://github.com/banteg/multicall.py, but implements the multicall in client's side.

## Install

```bash
pip install multicall-py
```

## Example

```python

from decimal import Decimal
from multicall import Multicall, Call

mc = Multicall("https://mainnet.infura.io/v3/xyz")

def from_wad(value):
    return Decimal(value) / 10 ** 18


def from_ray(value):
    return Decimal(value) / 10 ** 27


def from_rad(value):
    return Decimal(value) / 10 ** 45


def from_ilk(values):
    print(values)
    return {
        "Art": from_wad(values[0]),
        "rate": from_ray(values[1]),
        "spot": from_ray(values[2]),
        "line": from_rad(values[3]),
        "dust": from_rad(values[4]),
    }


result = mc.aggrate(
    [
        Call(
            target="0xdac17f958d2ee523a2206206994597c13d831ec7",
            function="balanceOf(address)(uint256)",
            args=("0xa929022c9107643515f5c777ce9a910f0d1e490c",),
            returns=[],
        ),
        Call(
            target="0xdac17f958d2ee523a2206206994597c13d831ec7",
            function="balanceOf(address)(uint256)",
            args=("0x47ac0fb4f2d84898e4d9e7b4dab3c24507a6d503",),
            request_id="0x47ac0fb4f2d84898e4d9e7b4dab3c24507a6d503",
        ),
        Call(
            "0x35d1b3f3d7966a1dfe207aa4514c12a259a0492b",
            "ilks(bytes32)((uint256,uint256,uint256,uint256,uint256))",
            args=[b"ETH-A"],
            request_id="ETH-A",
            returns=[
                ["Art", from_wad],
                ["rate", from_ray],
                ["spot", from_ray],
                ["line", from_rad],
                ["dust", None],
            ],
        ),
    ]
)

print(result)
```

> response as below:

```python
[{'request_id': '5a7bd54c680592746135b37a6476eb6c',
  'result': 1701108488000000},
 {'request_id': '0x47ac0fb4f2d84898e4d9e7b4dab3c24507a6d503',
  'result': 1350000115495224},
 {'request_id': 'ETH-A',
  'Art': Decimal('2789424592.115625600914086111'),
  'rate': Decimal('1.059237159709500809006237604'),
  'spot': Decimal('3001.379310344827586206896552'),
  'line': Decimal('3090847838.001970634131021155'),
  'dust': 10000000000000000000000000000000000000000000000000}]
```
dain 0.2.0
A minimalist Python CUDA library
License: MIT
Requires Python: >=3.8

# dain

A minimalist Python CUDA library.

[![View on GitHub](https://img.shields.io/badge/View%20on-GitHub-blue)](https://github.com/danwahl/dain)
[![Documentation](https://img.shields.io/badge/View-Documentation-green)](https://danwahl.github.io/dain/)

## Features

- CUDA-accelerated neural network operations
- Clean Python interface with NumPy integration
- Core operations:
    - Matrix multiplication
    - Element-wise addition (with broadcasting)
    - ReLU activation
    - MSE loss
- Example implementations:
    - XOR neural network

## Requirements

- CUDA Toolkit
- Python 3.8+
- NumPy

## Installation

### From Source

1. Install system dependencies:
    ```bash
    apt install clang-format nvidia-cuda-toolkit
    ```

2. Install package with development dependencies:
    ```bash
    pip install ".[dev]"
    ```

3. Run tests:
    ```bash
    pytest tests
    ```

## Usage

Basic example using the library:

```python
import numpy as np
from dain import matmul, add, relu

# Initialize random matrices
a = np.random.randn(3, 2).astype(np.float32)
b = np.random.randn(2, 4).astype(np.float32)

# Perform operations
c = matmul(a, b)              # Matrix multiplication
d = relu(c)                   # ReLU activation
bias = np.zeros((1, 4))       # Broadcasted bias
output = add(d, bias)         # Add bias with broadcasting
```

### Examples

See `examples/xor.py` for a complete neural network implementation that learns the XOR function:

```bash
python examples/xor.py
```

## License

MIT License

## Contributing

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