semvec/pypi-packages huggingface dataset:
crowdsec-tracker-api 1.102.4
This is the API to manage Crowdsec Live Exploit Tracker service
License: MIT
Requires Python: >=3.11

# crowdsec_tracker_api

**crowdsec_tracker_api** is a Python SDK for the [CrowdSec Tracker API](https://docs.crowdsec.net/u/tracker_api/intro/).
This library enables you to manage CrowdSec Live Exploit Tracker resources such as CVEs data, IPs from a specific CVE and manage integrations.

## Installation

```bash
pip install crowdsec_tracker_api
```

## Usage

You can follow this [documentation](https://docs.crowdsec.net/u/tracker_api/intro/) to see the basic usage of the SDK.

## Documentation
You can access the full usage documentation [here](https://github.com/crowdsecurity/crowdsec-tracker-api-sdk-python/tree/main/doc).

## Contributing

This SDK is auto-generated from the API specification. You can open an issue on this repository if you find a bug or if you want to add a feature.
ansys-api-systemcoupling 0.3.1
Autogenerated python gRPC interface package for ansys-api-systemcoupling, built on 11:30:16 on 06 February 2026
License: MIT
Requires Python: >=3.7

### ansys-api-systemcoupling gRPC Interface Package

This Python package contains the auto-generated gRPC Python interface files for
System Coupling.


#### Installation

Provided that these wheels have been published to public PyPI, they can be
installed with:

```
pip install ansys-api-systemcoupling
```

#### Build

To build the gRPC packages, run:

```
pip install build
python -m build
```

This will create both the source distribution containing just the protofiles
along with the wheel containing the protofiles and build Python interface
files.

Note that the interface files are identical regardless of the version of Python
used to generate them, but the last pre-built wheel for ``grpcio~=1.30`` was
Python 3.7, so to improve your build time, use Python 3.7 when building the
wheel.


#### Manual Deployment

After building the packages, manually deploy them with:

```
pip install twine
twine upload dist/*
```

Note that this is automatically done through CI/CD.


#### Automatic Deployment

This repository contains GitHub CI/CD that enables the automatic building of
source and wheel packages for these gRPC Python interface files. By default,
these are built on PRs, the main branch, and on tags when pushing. Artifacts
are uploaded for each PR.

To publicly release wheels to PyPI, ensure your branch is up-to-date and then
push tags. For example, for the version ``v0.5.0``.

```bash
git tag v0.5.0
git push --tags
```
avantis-trader-sdk 0.8.16
SDK for interacting with Avantis trading contracts.
License: MIT
Requires Python: >=3.6
Keywords: trading sdk blockchain ethereum web3 avantis

# Avantis Trader SDK

Python SDK for trading on [Avantis](https://avantisfi.com/) - a perpetual trading platform on Base.

## Installation

```bash
pip install avantis-trader-sdk
```

## Quick Start

```python
import asyncio
from avantis_trader_sdk import TraderClient
from avantis_trader_sdk.types import TradeInput, TradeInputOrderType

async def main():
    # Initialize client
    trader_client = TraderClient("https://mainnet.base.org")
    trader_client.set_local_signer("0xYOUR_PRIVATE_KEY")
    
    trader = trader_client.get_signer().get_ethereum_address()
    
    # Check and approve USDC allowance
    allowance = await trader_client.get_usdc_allowance_for_trading(trader)
    if allowance < 100:
        await trader_client.approve_usdc_for_trading(100)
    
    # Open a 10x long ETH position with $100 collateral
    trade_input = TradeInput(
        trader=trader,
        pair_index=1,  # ETH/USD
        collateral_in_trade=100,
        is_long=True,
        leverage=10,
        tp=5000,  # take profit
        sl=2500,  # stop loss
    )
    
    tx = await trader_client.trade.build_trade_open_tx(
        trade_input, TradeInputOrderType.MARKET, slippage_percentage=1
    )
    receipt = await trader_client.sign_and_get_receipt(tx)
    print("Trade opened!", receipt.transactionHash.hex())

asyncio.run(main())
```

## Get Open Trades

```python
trades, pending_orders = await trader_client.trade.get_trades(trader)

for trade in trades:
    print(f"Pair: {trade.trade.pair_index}, Leverage: {trade.trade.leverage}x")
    print(f"Entry: {trade.trade.open_price}, Liq: {trade.liquidation_price}")
```

## Close a Trade

```python
trade = trades[0]
close_tx = await trader_client.trade.build_trade_close_tx(
    pair_index=trade.trade.pair_index,
    trade_index=trade.trade.trade_index,
    collateral_to_close=trade.trade.collateral_in_trade,
    trader=trader,
)
await trader_client.sign_and_get_receipt(close_tx)
```

## AI-Assisted Development

Building with AI tools? We provide optimized documentation:

- [AGENT.md](./AGENT.md) - Comprehensive guide for AI agents. Copy to your project or paste into AI chat.
- [.cursorrules](./.cursorrules) - Auto-loaded by Cursor IDE.

```bash
curl -o AGENT.md https://raw.githubusercontent.com/Avantis-Labs/avantis_trader_sdk/main/AGENT.md
```

## Resources

- [Documentation](https://sdk.avantisfi.com/)
- [Examples](https://github.com/Avantis-Labs/avantis_trader_sdk/tree/main/examples)
- [Avantis Docs](https://docs.avantisfi.com/)

## License

MIT
pydantic-avro 0.10.0
Converting pydantic classes to avro schemas
License: MIT
Requires Python: <4.0,>=3.8.1
Keywords: pydantic, avro

[![Python package](https://github.com/godatadriven/pydantic-avro/actions/workflows/python-package.yml/badge.svg)](https://github.com/godatadriven/pydantic-avro/actions/workflows/python-package.yml)
[![codecov](https://codecov.io/gh/godatadriven/pydantic-avro/branch/main/graph/badge.svg?token=5L08GOERAW)](https://codecov.io/gh/godatadriven/pydantic-avro)
[![PyPI version](https://badge.fury.io/py/pydantic-avro.svg)](https://badge.fury.io/py/pydantic-avro)
[![CodeQL](https://github.com/godatadriven/pydantic-avro/actions/workflows/codeql-analysis.yml/badge.svg)](https://github.com/godatadriven/pydantic-avro/actions/workflows/codeql-analysis.yml)

# pydantic-avro

This library can convert a pydantic class to a avro schema or generate python code from a avro schema.

### Install

```bash
pip install pydantic-avro
```

### Pydantic class to avro schema

```python
import json
from typing import Optional

from pydantic_avro.base import AvroBase


class TestModel(AvroBase):
    key1: str
    key2: int
    key2: Optional[str]


schema_dict: dict = TestModel.avro_schema()
print(json.dumps(schema_dict))

```

### Avro schema to pydantic

```shell
# Print to stdout
pydantic-avro avro_to_pydantic --asvc /path/to/schema.asvc

# Save it to a file
pydantic-avro avro_to_pydantic --asvc /path/to/schema.asvc --output /path/to/output.py
```

### Specify expected Avro type

```python
from datetime import datetime
from pydantic import Field
from pydantic_avro.base import AvroBase 

class ExampleModel(AvroBase):
    field1: int = Field(..., avro_type="long")  # Explicitly set Avro type to "long"
    field2: datetime = Field(..., avro_type="timestamp-millis")  # Explicitly set Avro type to "timestamp-millis"
```

### Install for developers

###### Install package

- Requirement: Poetry 1.*

```shell
poetry install
```

###### Run unit tests
```shell
pytest
coverage run -m pytest  # with coverage
# or (depends on your local env) 
poetry run pytest
poetry run coverage run -m pytest  # with coverage
```

##### Run linting

The linting is checked in the github workflow. To fix and review issues run this:
```shell
black .   # Auto fix all issues
isort .   # Auto fix all issues
pflake .  # Only display issues, fixing is manual
```