semvec/pypi-packages huggingface dataset:
xid-xpm 0.0.25
Xidware Python project Manager
Requires Python: >=3.9.7

# **XPM**
Xidware Python project Manager

## **Specification**

### **Development Environment**
- **Operating System**: Windows
- **Python Version**: Python 3.10.11
- **Editor**: Visual Studio Code (VSCode)

### **Supported Environments**
- **Operating Systems**: Windows, Linux, macOS
- **Python Version**: Python 3.9.7+
- **Editor**: Any editor (VSCode, PyCharm, etc.)

## **Manual**

### **Installation**
To install `xpm`, use the following pip command:
```cmd
pip install xid-xpm
```


1. 패키지 `pip install xid-xpm` 혹은 CLI 프로그램 설치. `xid-xpm`
2. 환경 변수 등록. `PATH=...`
3. 프로젝트를 구축. `xpm new`
	- Windows: xpm.bat, project.xml
	- Linux/MacOS: xpm.sh, project.xml
4. xml 편집.
5. 프로젝트를 재구축. `xpm update`
	- Windows: project.bat, project.xml
	- Linux/MacOS: project.sh, project.xml
4. 프로젝트를 생성된 스크립트로 제어.
	- Windows: project venvUpdate
	- Linux/MacOS: ./project.sh venvUpdate
5. 바이너리 빌드.
	- Windows: project buildExecutable
	- Linux/MacOS: ./project.sh buildExecutable
6. 라이브러리 빌드.
	- Windows: project buildLibrary
	- Linux/MacOS: ./project.sh buildLibrary

```xml
<XPM Project="">
	<Project Name="" Version="" />
</XPM>
```
gitlab-async-client 1.0.0
A simple asyncronous gitlab http client
Requires Python: >=3.12

[![package test](https://github.com/Vladimir-Titov/gitlab-async-client/actions/workflows/package-test.yml/badge.svg?branch=main)](https://github.com/Vladimir-Titov/gitlab-async-client/actions/workflows/package-test.yml)

```
import aiohttp
import asyncio
from gitlab_async_client.client import GitlabHTTPClient, GitlabAuthType

async def main():
    async with aiohttp.ClientSession() as session:
        client = GitlabHTTPClient(
            base_url="https://gitlab.com",
            access_token="your_access_token",
            session=session,
            auth_type=GitlabAuthType.header
        )

        projects = await client.get_projects()
        print(projects)


asyncio.run(main())
```
apidag 0.2.2
A Python library using asyncio and aiohttp to build declarative API call flows
Requires Python: >=3.7

<img style="display: block; margin-left: auto; margin-right: auto; width: 30%;" src="img/apidag.png" alt="apidag logo" />

# APIDAG

APIDAG is a Python library for building and executing Directed Acyclic Graphs (DAGs) of API calls and transformations. It allows you to create complex workflows where the output of one API call can be transformed and used as input for subsequent calls.

## Features

- Create DAGs with HTTP API calls and data transformations
- Automatic retry handling for failed requests
- Concurrent execution of independent nodes
- JSONPath-based response parsing
- Error handling with custom handlers
- Rate limiting support
- Detailed execution history

## Installation

```bash
pip install apidag
```

## Example

Here's a simple example that fetches an XKCD comic and looks up the definition of its first word:

```python
from apidag.nodes.http import HTTPNode
from apidag.nodes.source import SourceNode
from apidag.nodes.transformer import TransformerNode
from apidag.graph import DAGGraph
from apidag.executor import DAGExecutor

# Create a DAG
dag = DAGGraph()

# Source node with comic ID
source = SourceNode(
    node_id="input_source",
    id="2630"
)

# XKCD API node
xkcd_node = HTTPNode(
    node_id="xkcd_api",
    url_template="https://xkcd.com/\${id}/info.0.json",
    http_method="GET",
    output_map={
        "title": "$.safe_title"
    }
)

# Dictionary API node
dictionary_node = HTTPNode(
    node_id="dictionary_api",
    url_template="https://api.dictionaryapi.dev/api/v2/entries/en/\${word}",
    http_method="GET",
    output_map={
        "definitions": "$[0].meanings[*].definitions[*].definition"
    }
)

# Transform XKCD title to dictionary input
transformer = TransformerNode(
    node_id="title_transformer",
    transform_function=lambda outputs: {
        "word": outputs["xkcd_api.title"].split()[0].lower()
    }
)

# Add nodes and connections
dag.add_node(source)
dag.add_node(xkcd_node)
dag.add_node(transformer)
dag.add_node(dictionary_node)

dag.add_edge("input_source", "xkcd_api")
dag.add_edge("xkcd_api", "title_transformer")
dag.add_edge("title_transformer", "dictionary_api")

# Execute the DAG
executor = DAGExecutor(dag)
results = await executor.execute()
```

## Node Types

- **HTTPNode**: Makes HTTP requests with templated URLs and bodies
- **SourceNode**: Provides initial input values
- **TransformerNode**: Transforms data between nodes

## Features in Detail

### HTTP Node Configuration
- URL templating with variable substitution
- JSONPath-based response parsing
- Custom error handlers per status code
- Configurable retry behavior
- Rate limiting support

### Execution
- Concurrent execution of independent nodes
- Detailed execution history
- Progress tracking
- Error handling and recovery
nanoagents 0.1.0
A nano, minimalistic, and lightweight library for building ReACT-based AI agents that use tools to solve tasks.
Requires Python: <4.0,>=3.11

# 🤖 **nanoagents**

---

### _A nano, minimalistic, and lightweight library for building ReACT-based AI agents that use tools to solve tasks._

### **📦 Installation**

```bash
pip install nanoagents
```

### **🕹️ Usage**

```python
from nanoagents import Agent
from groq import Groq

# You can define a function to make any llm call, it should take a string as input.
def call_llm(prompt: str) -> str:
    api_key = "$YOUR_API_KEY"
    client = Groq(api_key=api_key)

    messages = [{"role": "user", "content": prompt}]
    response = client.chat.completions.create(
        model="llama-3.3-70b-versatile",
        messages=messages
    )
    return response.choices[0].message.content


agent = Agent(llm=call_llm)

@agent.tool("add") # Create a tool named "add"
def add(a: int, b: int) -> int:
    """Add two numbers."""
    return a + b

result = agent.run("Calculate 2 + 3")
print(result)
```
⚠️  _This is still a work in progress, feel free to contribute!_
dualbounds 2.0.0
Dual bounds for model-agnostic inference
Requires Python: >=3.9

A python implementation of the dual bounds framework for inference on partially identified estimands (and the solutions to optimization problems more generally). See https://dualbounds.readthedocs.io/en/latest/ for detailed documentation and tutorials.

## Installation

To install ``dualbounds``, just use pip:

``pip install dualbounds``

## Documentation

Documentation and tutorials are available at https://dualbounds.readthedocs.io/en/latest/.

## Quickstart

Given a response vector ``y``, binary treatment vector ``W``, covariate matrix ``X``, and an (optional) propensity score vector ``pis``, dualbounds allows analysts to perform inference on partially identified estimands of the form `E[f(Y(0), Y(1), X)]`, for any choice of f. For example, the code below shows how to perform inference on `P(Y(0) < Y(1))`, the proportion of individuals who benefit from the treatment. Dual bounds can wrap on top of *any* machine learning model to provide provably valid confidence intervals in randomized experiments.

```
	import dualbounds as db
	from dualbounds.generic import DualBounds

	# Generate synthetic data
	data = db.gen_data.gen_regression_data(n=900, p=30, sample_seed=123)

	# Initialize dual bounds object
	dbnd = DualBounds(
	    f=lambda y0, y1, x: y0 < y1,
	    covariates=data['X'],
	    treatment=data['W'],
	    outcome=data['y'],
	    propensities=data['pis'],
	    outcome_model='ridge',
	)

	# Compute dual bounds and observe output
	results = dbnd.fit(alpha=0.05).results()


```

## Reference

If you use ``dualbounds`` in an academic publication, please consider citing [Ji, Lei, and Spector (2023)](https://arxiv.org/abs/2310.08115). The bibtex is below:

```
@misc{ji2023modelagnostic,
      title={Model-Agnostic Covariate-Assisted Inference on Partially Identified Causal Effects}, 
      author={Wenlong Ji and Lihua Lei and Asher Spector},
      year={2023},
      eprint={2310.08115},
      archivePrefix={arXiv},
      primaryClass={econ.EM}
}
```