semvec/pypi-packages huggingface dataset:
addispayweb 0.1.0
Python package used to integrate Addispay web API
License: MIT

# AddispayWeb

#### Python package used to integrating Addispay web API with your project.

```python
import os
from dotenv import load_dotenv
from addispay import AddisPay
from utils import generate_unique

load_dotenv()

publickey = os.environ.get("publickey")
privatekey = os.environ.get("privatekey")
Auth = os.environ.get("Auth")
addispay = AddisPay(publickey, privatekey, Auth)
total_amount=12
tx_ref="TX-bcd"
currency="ETB"
first_name="Annis"
email="annis@gmail.com"
phone_number="0988888888"
last_name="Nelson",
session_expiration_minute=12
nonce=generate_unique([], 32)
notify_url="https://example.com/"
return_url="https://example.com/"
message="from customer to ..."
order_detail={}
response = addispay.send_request(total_amount=total_amount, tx_ref=tx_ref, currency=currency, first_name=first_name,email=email,phone_number=phone_number,last_name=last_name,session_expiration_minute=session_expiration_minute,nonce=nonce,notify_url=notify_url,return_url=return_url,message=message,order_detail=order_detail)
print(response.json)
```
flowx 0.1.0
Elegant and lightweight, yet functionally comprehensive, the Flow framework is the best choice for large models.
License: MIT
Requires Python: <3.13,>=3.9

English | [简体中文](README_zh-CN.md)


# FlowX



## What's FlowX?

**FlowX** is a lightweight framework for building LLM applications. It offers an API interface similar to LangChain's
LCEL, but with a more straightforward and simple internal implementation. Users familiar with LangChain can quickly get
started with FlowX and extend or modify it as needed.

For example, FlowX implements the core functionality of LangChain's AgentExecutor
in less than 300 lines of [code](https://github.com/zhiguoxu/FlowX/blob/main/core/agents/agent.py). This is
particularly beneficial for users who want to understand the underlying implementation of agents and make further
optimizations.

FlowX is also very easy to use, as demonstrated by the following example of an Agent:

```python
from core.tool import tool
from core.llm.openai.openai_llm import OpenAILLM
from core.agents.agent import Agent

llm = OpenAILLM(model="gpt-4o")


@tool
def multiply(left: int, right: int) -> int:
    """multiply"""
    return left * right


agent = Agent(llm=llm, tools=[multiply])
agent.invoke("what's 1024*2024?")
```

## Why do we need FlowX?


Although LangChain provides a powerful framework for building LLM applications, its complex design also brings several
issues with deeper use.

LangChain's extensive use of abstraction results in highly complex code, making it difficult to understand and maintain.
While it initially simplifies the development process, as the complexity of requirements increases, these abstractions
gradually become obstacles to productivity. Additionally, these abstractions increase the learning and debugging burden,
forcing development teams to spend significant time dealing with internal framework code rather than focusing on
application functionality.

Especially in today's rapidly evolving AI and LLM landscape, where new concepts and methods emerge weekly, a framework
that is easy to understand and iterate on quickly is crucial!

To address these issues, FlowX adopts a more concise design with more refined code implementation, balancing
abstraction and simplicity by the use of necessary abstractions without being overly complex. Ultimately, FlowX
provides the same functionality and similar interfaces as LangChain but with significantly reduced code and fewer
abstract concepts. This makes it easy to understand and modify FlowX, allowing for quick experimentation or customized
development.

The project is still under development, with more features to be added. Your valuable feedback is welcome!