semvec/pypi-packages huggingface dataset:
agns 0.1.6
AI Agent Name Service SDK
License: MIT
Requires Python: >=3.8

# AGNS Python SDK

A lightweight Python SDK for interacting with the Agent Name Service (AGNS). This library allows you to look up and communicate with language agents via a clean and simple interface.

---

## Installation

Install the latest version from PyPI:

```bash
pip install agns
````

For local development:

```bash
git clone https://github.com/coffer-id/agent-platform.git
cd agns
pip install -e .
```

---




## Authentication

Some AGNS endpoints and agent selection features require authentication using API keys. You can provide your keys in one of two ways:

### 1. Using a `.env` file (recommended)


Create a file named `.env` in your project root and add:

```
AGNS_API_KEY=your_agns_api_key_here
ANTHROPIC_API_KEY=your_anthropic_api_key_here
```

**AGNS_API_KEY** is required for authenticating with the Agent Name Service (AGNS) endpoints.

**ANTHROPIC_API_KEY** is required if you use agent selection or routing features that leverage Anthropic's Claude models (e.g., for LLM-based agent selection). This key is provided by Anthropic and enables access to their API for model inference.

The SDK will automatically load this file if you have the `python-dotenv` package installed (already used in the SDK).

### 2. Setting the environment variables directly

```bash
export AGNS_API_KEY=your_agns_api_key_here
export ANTHROPIC_API_KEY=your_anthropic_api_key_here
```

You can obtain these API keys from your AGNS administrator/service provider and from Anthropic, respectively. The SDK will automatically use these environment variables when making authenticated requests.

## Usage Example

```python
from agns import agns

# Lookup all available agents
result = agns.lookup()

# Choose an agent to ask a question
if isinstance(result, dict):
    agent = next(iter(result.values()), None)
elif result:
    agent = result
else:
    raise RuntimeError("No agent found.")

# Ask the agent something
question = {"text": "Hello", "target_language": "es"}
response = agent.ask(question)

print("Translated:", response["translated_text"])
```

---

## API Overview

### `lookup(name: Optional[str] = None) → dict[str, Agent] | Agent | None`

Looks up agents by name, or returns all if no name is provided.

* If `name` is provided: returns a single `Agent` or `None`
* If not: returns a dictionary of agents keyed by name

---

## Running Tests

Install development dependencies:

```bash
pip install -r requirements-dev.txt
```

Run tests using `pytest`:

```bash
pytest
```

---

## Project Structure

```
src/
  agns/
    __init__.py
    client.py
    agent.py
    agent_card.py
tests/
  test_integration.py
pyproject.toml
README.md
```

---

## License

MIT License. See [`LICENSE`](LICENSE) for details.

---

## Contributing

Contributions are welcome! Please:

1. Fork this repository
2. Create a feature branch
3. Commit your changes
4. Open a pull request

---
Palmto-gen 0.3.3a3
Generate synthetic trajectories using PLMs
License: MIT
Keywords: trajectory generationProbablistic Language Models

Trajectory data sourced, from GPS-enabled devices such as smart vehicles and smart phones, offers valuable insights into human
movement patterns across various modes of transportation. However, there is limited availability of such large datasets for testing and
benchmarking tools and solutions. Drawing on similarities between trajectories in mobility data and natural language sentences, we
explore the application of probabilistic language models to generate arbitrarily large realistic trajectories by treating sequences of GPS
points as sequences of tokens, akin to sentences in natural language. Our experiments have shown that, using a small sample of real taxi
trajectories, the proposed approach can generate a diverse set of synthetic trajectories that follows closely the distribution of the
original sample.



Change Log
==========

0.1 (02/06/2024)
-----------------
- First Release

0.3a1 (16/06/2025)
-----------------
- First pre-release version following bug fix in version 0.2

0.3b1 (18/06/2025)
-----------------
- First beta version

0.3b2 (18/06/2025)
-----------------
- Second beta version

0.3b3 (18/06/2025)
-----------------
- Third beta version

0.3 (29/07/2025)
-----------------
- Third Release

0.3.2 (01/08/2025)
-----------------
- Release a patch that add additonal metadata to the library

0.3.3a1 (04/10/2025)
-----------------
- Add new function and classes for handling 3D trajectory data

0.3.3a2 (04/10/2025)
-----------------
- Fix attribute error in 3D representation of Shapely Point objects

0.3.3a3 (04/10/2025)
-----------------
- Fix a minor error in how 3D data is processed
segpaste 0.2.0
A Python package for copy-paste functionality. Torch only reimplementation of https://arxiv.org/abs/2012.07177
License: MIT
Requires Python: >=3.11

# segpaste

A PyTorch implementation of "Simple Copy-Paste is a Strong Data Augmentation Method for Instance Segmentation" ([arXiv:2012.07177](https://arxiv.org/abs/2012.07177)).

This package also provides integration with `torchvision` ecosystem.

## Installation

```bash
pip install segpaste
```

Or install from source:

```bash
git clone https://github.com/NoeFontana/segpaste.git
cd segpaste
pip install -e .
```

## Usage

### TorchVision Integration

Convenience types and wrappers are provided to ease integration with `torchvision` datasets and transforms.

- `PaddingMask`: A TVTensor representing a padding mask.
- `CocoDetectionV2`: A CocoDetection dataset that presents an interface compatible with `torchvision.transforms.v2` and with support for padding masks.
- `SanitizeBoundingBoxes`: A small wrapper around `torchvision.transforms.v2.SanitizeBoundingBoxes` that adds support for `PaddingMask`.

### Collator

The recommended interface is through the `CopyPasteCollator` which can be used in lieu of a standard collate function in a PyTorch `DataLoader` as long as the batch_size is greater than 1.

```python
from segpaste import CopyPasteAugmentation, CopyPasteCollator, CopyPasteConfig

config = CopyPasteConfig()
augmentation = CopyPasteAugmentation(config)
collate_fn = CopyPasteCollator(augmentation)
torch.utils.data.DataLoader(
        dataset, # Your dataset here
        batch_size=batch_size, # Must be > 1
        collate_fn=collate_fn,
    )

```

Examples of usage can be found in the test suite.

### Transform (Unstable API)

A minimal working example with `CopyPasteTransform` can be found in the [examples](https://github.com/NoeFontana/segpaste/tree/main/examples).

### Further

The public API is exposed in the `segpaste` namespace. It is subject to breaking changes, without prior notice, until version 1.0.0.

## Development

This project uses [Ruff](https://github.com/astral-sh/ruff) for linting/formatting and [mypy](http://mypy-lang.org/) for type checking.

```bash
# Install development dependencies
pip install -e ".[dev,coco]"

# Format, lint, and type-check
ruff format . && ruff check --fix . && mypy .

# Run tests
pytest
```

## Contributing

Contributions are welcome. Please open an issue to discuss major changes or submit a pull request.

## Citation

If you use this implementation in your research, please consider citing the original paper:

```bibtex
@article{ghiasi2020simple,
  title={Simple Copy-Paste is a Strong Data Augmentation Method for Instance Segmentation},
  author={Ghiasi, Golnaz and Cui, Yin and Srinivas, Aravind and Qian, Rui and Lin, Tsung-Yi and Cubuk, Ekin D and Le, Quoc V and Zoph, Barret},
  journal={arXiv preprint arXiv:2012.07177},
  year={2020}
}
```

## License

This project is licensed under the MIT License.
bundles 0.1.0
A mass, single import option
License: MIT
Requires Python: >=3.8

# Bundles
## "The only bundle of imports you'll ever need."

"**bundles**" is a python module I made, intended to help in mass imports. If you are going to simply need only one to five imports, **don't use bundles**. 

### BUT

If you think you'll be needing alot of imports, or don't care being an import over, **use bundles**.

# Bundles
## "The only bundle of imports you'll ever need."
devpossible-ton 0.1.3
Python library for parsing, validating, and serializing TON (Text Object Notation) files
License: MIT
Requires Python: >=3.8
Keywords: ton, parser, serializer, validator, schema, configuration, data-format

# DevPossible.Ton - Python Library

**Developed by DevPossible, LLC**
**Contact: support@devpossible.com**

Python implementation of the TON (Text Object Notation) parser, serializer, formatter, and validator.

## Installation

```bash
pip install devpossible-ton
```

## Quick Start

```python
import devpossible_ton as ton

# Parse TON data
document = ton.parse("""
{
  name: "My App"
  version: "1.0.0"
}
""")

# Access data
root = document.get_root()
print(root.get('name'))  # "My App"

# Serialize back to TON
serialized = ton.serialize(document)
print(serialized)

# Format TON files
from devpossible_ton import TonFormatter
formatted = TonFormatter.pretty(ton_text)
```

## Features

- ✅ Full TON specification parser with async support
- ✅ Comprehensive schema validation with 30+ validation rule types
- ✅ Code formatter with compact and pretty styles
- ✅ Type annotations and hints
- ✅ Enum and EnumSet support
- ✅ Array support with mixed types
- ✅ Pretty and compact serialization
- ✅ Async file operations
- ✅ Schema collections and definitions

## Advanced Usage

### Schema Validation

```python
from devpossible_ton import (
    TonSchemaDefinition, 
    TonPropertySchema, 
    ValidationRuleType, 
    TonValidationRule
)

# Create a schema
schema = TonSchemaDefinition('User')
name_prop = TonPropertySchema('name', 'string')
name_prop.add_validation(TonValidationRule(ValidationRuleType.REQUIRED))
name_prop.add_validation(TonValidationRule(ValidationRuleType.MIN_LENGTH, 3))
schema.add_property('name', name_prop)
```

### Formatting

```python
from devpossible_ton import TonFormatter, TonFormatStyle

# Format with different styles
compact = TonFormatter.compact(ton_text)
pretty = TonFormatter.pretty(ton_text)
sorted_output = TonFormatter.sorted(ton_text)

# Async formatting
import asyncio
formatted = await TonFormatter.format_file_async('input.ton', TonFormatStyle.PRETTY)
```

### Serialization Options

```python
from devpossible_ton import TonSerializeOptions, TonFormatStyle

# Use presets
options = TonSerializeOptions.compact()
options = TonSerializeOptions.pretty()
options = TonSerializeOptions.optimized()

# Custom options
options = TonSerializeOptions(
    format_style=TonFormatStyle.PRETTY,
    indent_size=2,
    sort_properties=True,
    include_header=True
)
```

## License

MIT License - Copyright © 2024 DevPossible, LLC

## Support

**DevPossible, LLC**
Email: support@devpossible.com

---

**© 2024 DevPossible, LLC. All rights reserved.**