semvec/pypi-packages huggingface dataset:
ycleptic 2.0.3
A YAML-format configuration generator
Requires Python: >=3.7

# Ycleptic
> YAML configuration generator

YAML is a popular markup language for input files, with its easy syntax and clear
mapping to lists and dicts.  Ycleptic allows a developer to specify all keys, datatypes,
default values, choice restrictions, and other features of YAML-format input 
files for use in their own apps. This makes the specification of input file syntax on top 
of YAML for any particular application a bit easier than just using pure YAML.  In addition,
ycleptic can also automatically build the RST/Sphinx doctree for your app's configuration
file.

## Installation

```bash
pip install ycleptic
```

Once installed, the developer has access to the ``Yclept`` class.

## Release History
* 2.0.3
    * refactored to change `directive` to `attribute` throughout
* 1.9.0
    * new `update_user` method
* 1.8.1
    * fixed faulty special update of dict-like values with defaults
* 1.8.0
    * more informative error messages via `raise_clean`
* 1.7.0
    * Restructured code-base and expanded documentation
* 1.6.2
    * `footer-style` argument added to `make-docs`
* 1.5.0
    * `example` subfield in `docs` directive enabled
* 1.4.1
    * `case_sensitive` boolean attribute enabled for all `str`-types
* 1.3.0
    * `__init__` optionally accepts a dict instead of only a file name
* 1.2.0
    * `make-doc` subcommand upgraded to put RST links at the top of every RST file
* 1.1.0
    * bugfix: shows default values for any dict-type parameters
    * bugfix: `choices` in interactive help did not work with integer choices
* 1.0.7
    * bugfix: bad string in doc builder
* 1.0.6
    * interactive mode implemented
    * `config-help` subcommand added
    * `make-doc` subcommand added
* 1.0.5
    * added support for a user dotfile/rcfile
* 1.0.4
    * added `**kwargs` to `console_help` to allow override of `print`
* 1.0.3.3
    * fixed spurious output
* 1.0.3.2
    * fixed version detection bug
* 1.0.2
    * Updated documentation; added version detection
* 1.0.1
    * Include example base config
* 1.0.0
    * Initial version

## Meta

Cameron F. Abrams – cfa22@drexel.edu

Distributed under the MIT license. See ``LICENSE`` for more information.

[https://github.com/cameronabrams](https://github.com/cameronabrams/)

[https://github.com/AbramsGroup](https://github.com/AbramsGroup/)

## Contributing

1. Fork it (<https://github.com/AbramsGroup/HTPolyNet/fork>)
2. Create your feature branch (`git checkout -b feature/fooBar`)
3. Commit your changes (`git commit -am 'Add some fooBar'`)
4. Push to the branch (`git push origin feature/fooBar`)
5. Create a new Pull Request
PottsPlayground 0.3.0
For creating and solving Potts-model representations of combinatorial optimization problems
Requires Python: >=3.6

PottsPlayground is for constructing and simulating combinatorial optimization problems represented as Potts Models.  It includes a system for constructing weight matrices in Python and a C++/CUDA extension for minimizing the Potts model energy on a CPU or GPU using various flavors of simulated annealing. It is intended as a demonstration of what the Potts model is and is not capable of, and as a tool for further research with the Potts model of computation.

Read the full docs `here <https://williamow.github.io/PottsPlayground/index.html>`_.

Built-in combinatorial problems can be generated and solved easily:

.. code-block:: python

	import PottsPlayground
	PottsTask = PottsPlayground.Tasks.TravelingSalesman(ncities=10, ConstraintFactor=1.5)
	temp = PottsPlayground.Schedules.SawtoothTempLog2Space(MaxTemp=1., MinTemp=0.05, nTeeth=3, nIters=1e4)
	results = PottsPlayground.Anneal(PottsTask, temp)
	final_best_soln = results['MinStates'][-1,:]
	PottsTask.DisplayState(final_best_soln)

There is also a BaseTask class that can be used to try out any Potts Model problem representations you can think of, and anneal it using the high-performance backend.

Features:

* Structured construction of Potts Models
* Automatic conversion from Potts to Ising models
* Minor Embedding of Ising models
* GPU accelerated annealing and sampling
* Parallel replicates
* Parallel updating
* Comprehensive statistical reporting
scrapy-vectors 0.2.2
Vector embeddings generation and storage for Scrapy
Requires Python: >=3.9
Keywords: scrapy, vectors, embeddings, s3, llm

# scrapy-vectors

[![Tests](https://github.com/kyleissuper/scrapy-vectors/actions/workflows/tests.yml/badge.svg)](https://github.com/kyleissuper/scrapy-vectors/actions/workflows/tests.yml)
[![Code Quality](https://github.com/kyleissuper/scrapy-vectors/actions/workflows/checks.yml/badge.svg)](https://github.com/kyleissuper/scrapy-vectors/actions/workflows/checks.yml)
[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](https://opensource.org/licenses/ISC)
[![PyPI version](https://badge.fury.io/py/scrapy-vectors.svg)](https://badge.fury.io/py/scrapy-vectors)

Vector embeddings generation and storage for Scrapy spiders.

## Features

- **Embeddings Pipeline**: Generate vector embeddings using LiteLLM (supports OpenAI, Cohere, and other providers)
- **S3 Vectors Storage**: Store embeddings in AWS S3 Vectors service

## Platform Support

**Supported Platforms:**
- ✅ **Linux** - Fully supported
- ✅ **macOS** - Fully supported
- ❌ **Windows** - Not supported (requires `uvloop` to use `litellm[proxy]`, which is Unix-only)

## Installation

```bash
pip install scrapy-vectors
```

## Quick Start

In your `scrapy_settings.py`:
```python
ITEM_PIPELINES = {
    # Outputs as jsonlines in Pinecone format, which s3-vectors can use
    "scrapy_vectors.EmbeddingsLiteLLMPipeline": 300,
}
EXTENSIONS = {
    "scrapy.extensions.feedexport.FeedExporter": None,  # Disable standard
    "scrapy_vectors.S3VectorsFeedExporter": 300,        # Use custom
}
FEED_STORAGES = {
    "s3-vectors": "scrapy_vectors.S3VectorsFeedStorage",
}
FEEDS = {
    "s3-vectors://vectors-bucket/vectors-index": {
        "format": "jsonlines",
        "batch_item_count": 100,
    }
}

# LiteLLM will route for you
LITELLM_API_KEY = "your_provider_api_key"          # (e.g. OpenAI API Key)
LITELLM_EMBEDDING_MODEL = "text-embedding-3-small" # This is default when unspecified

AWS_REGION_NAME = "us-east-1"
AWS_ACCESS_KEY_ID = "access_key_id"
AWS_SECRET_ACCESS_KEY = "access_key"
```

In your scraper:
```python
import scrapy


class MySpider(scrapy.Spider):
    name = "example"
    start_urls = ["https://example.com"]

    # Must yield with: id, page_content, and metadata
    def parse(self, response):
        yield {
            "id": response.url,
            "page_content": response.css("article::text").get(),
            "metadata": {
                "title": response.css("h1::text").get(),
                "url": response.url,
            }
        }
```

## Configuration

### Embeddings Pipeline Settings

- `LITELLM_API_KEY`: API key for your embedding provider (required)
- `LITELLM_EMBEDDING_MODEL`: Model to use (default: OpenAI's `text-embedding-3-small`)

### S3 Vectors Storage Settings

- `AWS_REGION_NAME`: AWS region (required)
- `AWS_ACCESS_KEY_ID`: AWS access key
- `AWS_SECRET_ACCESS_KEY`: AWS secret key