semvec/pypi-packages huggingface dataset:
cditools 0.1.0
CDI Tools Package
Requires Python: >=3.9

# cditools

[![Actions Status][actions-badge]][actions-link]
[![Documentation Status][rtd-badge]][rtd-link]

[![PyPI version][pypi-version]][pypi-link]
[![Conda-Forge][conda-badge]][conda-link]
[![PyPI platforms][pypi-platforms]][pypi-link]

[![GitHub Discussion][github-discussions-badge]][github-discussions-link]

<!-- SPHINX-START -->

<!-- prettier-ignore-start -->
[actions-badge]:            https://github.com/nsls2/cditools/workflows/CI/badge.svg
[actions-link]:             https://github.com/nsls2/cditools/actions
[conda-badge]:              https://img.shields.io/conda/vn/conda-forge/cditools
[conda-link]:               https://github.com/conda-forge/cditools-feedstock
[github-discussions-badge]: https://img.shields.io/static/v1?label=Discussions&message=Ask&color=blue&logo=github
[github-discussions-link]:  https://github.com/nsls2/cditools/discussions
[pypi-link]:                https://pypi.org/project/cditools/
[pypi-platforms]:           https://img.shields.io/pypi/pyversions/cditools
[pypi-version]:             https://img.shields.io/pypi/v/cditools
[rtd-badge]:                https://readthedocs.org/projects/cditools/badge/?version=latest
[rtd-link]:                 https://cditools.readthedocs.io/en/latest/?badge=latest

<!-- prettier-ignore-end -->

## Pyright Configuration

The `pyrightconfig.json` file configures the
[Pyright type checker](https://github.com/microsoft/pyright) for this project.
It sets the type checking mode to "basic" for less strict analysis and disables
warnings about missing type stubs and untyped base classes. This helps minimize
unnecessary alerts from third-party libraries that lack type information,
allowing you to focus on type issues within your own codebase.
cognee-community-vector-adapter-azure 0.0.2
Azure AI search vector database adapter for cognee
Requires Python: <=3.13,>=3.10

# Azure AI Search Adapter for Cognee

This adapter provides integration between Cognee and Azure AI Search (formerly Azure Cognitive Search) for vector storage and retrieval operations.

## Features

- Full vector search capabilities using Azure AI Search
- Hybrid search (combining text and vector search)
- HNSW algorithm for efficient similarity search
- Async/await support for all operations
- Batch operations for improved performance

## Installation

If published, the package can be simply installed via pip:

```bash
pip install cognee-community-vector-adapter-azure
```

In case it is not published yet, you can use poetry to locally build the adapter package:

```bash
pip install poetry
poetry install # run this command in the directory containing the pyproject.toml file
```

## Configuration

The adapter requires the following credentials:
- `endpoint`: Your Azure AI Search service endpoint (e.g., `https://your-service.search.windows.net`)
- `api_key`: Your Azure AI Search API key
- `embedding_engine`: An instance of EmbeddingEngine for text vectorization

## Usage

```python
from cognee.infrastructure.databases.vector.embeddings.EmbeddingEngine import EmbeddingEngine
from packages.vector.azureaisearch import AzureAISearchAdapter

# Initialize the adapter
embedding_engine = EmbeddingEngine(...)  # Your embedding engine
adapter = AzureAISearchAdapter(
    endpoint="https://your-service.search.windows.net",
    api_key="your-api-key",
    embedding_engine=embedding_engine
)

# Create a collection (index)
await adapter.create_collection("my_collection")

# Add data points
await adapter.create_data_points("my_collection", data_points)

# Search
results = await adapter.search(
    collection_name="my_collection",
    query_text="search query",
    limit=10
)

# Batch search
results = await adapter.batch_search(
    collection_name="my_collection",
    query_texts=["query1", "query2"],
    limit=10
)
```

## Key Differences from Other Vector Databases

1. **Collections as Indexes**: In Azure AI Search, what other vector databases call "collections" are called "indexes"
2. **Document Structure**: Documents in Azure AI Search have a specific schema with defined fields
3. **Batch Operations**: Azure AI Search doesn't have native batch search, so batch operations are parallelized
4. **Scoring**: Azure AI Search returns `@search.score` which is normalized differently than other vector databases

## Vector Search Configuration

The adapter uses HNSW (Hierarchical Navigable Small World) algorithm with the following default parameters:
- `m`: 4 (number of bi-directional links)
- `efConstruction`: 400 (size of the dynamic list)
- `efSearch`: 500 (size of the dynamic list for search)
- `metric`: cosine (similarity metric)

These parameters can be adjusted in the `create_collection` method if needed.
helloworldmatheus 0.0.1
teste
Requires Python: >=3.8

# package_name

Description. 
The package package_name is used to:
	- 
	-

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install package_name

```bash
pip install package_name
```

## Usage

```python
from package_name import file1_name
file1_name.my_function()
```

## Author
My_name

## License
[MIT](https://choosealicense.com/licenses/mit/)
Claridata 0.1.0
A modular data preprocessing pipeline for Python
Requires Python: >=3.7

# Claridata v0.1.0

Automated data cleaning and preprocessing for pandas DataFrames.

## Features

- Handle duplicates
- Impute missing values (numerical and categorical)
- Handle outliers (winsorization or deletion)
- Encode categorical features (OneHot or Label)
- Extract datetime features
- Automatic logging

## Installation

```bash
pip install .
pyspnego 0.12.0
Windows Negotiate Authentication Client and Server
Requires Python: >=3.9
Keywords: windows, spnego, negotiate, ntlm, kerberos, sspi, gssapi, auth

# Python SPNEGO Library

[![Test workflow](https://github.com/jborean93/pyspnego/actions/workflows/ci.yml/badge.svg)](https://github.com/jborean93/pyspnego/actions/workflows/ci.yml)
[![codecov](https://codecov.io/gh/jborean93/pyspnego/branch/main/graph/badge.svg)](https://codecov.io/gh/jborean93/pyspnego)
[![PyPI version](https://badge.fury.io/py/pyspnego.svg)](https://badge.fury.io/py/pyspnego)
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/jborean93/pyspnego/blob/master/LICENSE)

Library to handle SPNEGO (Negotiate, NTLM, Kerberos) and CredSSP authentication. Also includes a packet parser that can
be used to decode raw NTLM/SPNEGO/Kerberos tokens into a human readable format.


## Requirements

See [How to Install](#how-to-install) for more details

* CPython 3.9+
* [cryptography](https://github.com/pyca/cryptography)
* [sspilib](https://github.com/jborean93/sspilib) - Windows only

### Optional Requirements

The following Python libraries can be installed to add extra features that do not come with the base package:

* [python-gssapi](https://github.com/pythongssapi/python-gssapi) and [pykrb5](https://github.com/jborean93/pykrb5) for Kerberos authentication on Linux
* [ruamel.yaml](https://pypi.org/project/ruamel.yaml/) for YAML output support on `pyspnego-parse`


## How to Install

To install pyspnego with all basic features, run

```bash
pip install pyspnego
```

### Kerberos Authentication

While pyspnego supports Kerberos authentication on Linux, it isn't included by default due to its reliance on system
packages to be present.

To install these packages, run the below

```bash
# Debian/Ubuntu
apt-get install gcc python3-dev libkrb5-dev

# Centos/RHEL/Fedora
dnf install gcc python-devel krb5-devel

# Arch Linux
pacman -S gcc krb5
```

Once installed you can install the Python packages with

```bash
pip install pyspnego[kerberos]
```

Kerberos also needs to be configured to talk to the domain but that is outside the scope of this page.

## How to Use

See [the examples section](docs/examples) for examples on how to use the authentication side of the library.

_Note: While server/acceptor authentication is available for all protocols it is highly recommended you have the system GSSAPI and NTLM system libraries present for acceptor authentication. Pyspnego NTLM acceptor authentication should work but it is not as thoroughly tested as the GSSAPI implementation._


### CredSSP Authentication

Since version 0.2.0, pyspnego can be used for CredSSP authentication. While this isn't part of the SPNEGO/Negotiate
protocol it uses common features and code like ASN.1 structures and even Negotiate auth as part of the CredSSP process.
Both `initiate` and `accept` usages are supported when specifying `protocol='credssp'` but there are no guarantees the
acceptor is free of any bugs so use with caution.


## Backlog

* Add support for anonymous authentication
* See if `pywinrm` wants to use this
message-proto 0.1.0
A simple messaging protocol written on top of TCP using sockets
Requires Python: >=3.9

# Message Protocol

> Originially developed by [Raj Adhikari](https://github.com/r-adhikari97)

A simple **length-prefixed framing protocol** for TCP sockets, designed
for building echo servers, chat systems, or any application requiring
structured message exchange.

---

## 🔄 Changelog !

> View change log : [here](CHANGELOG.md)

---

## 📦 Overview

Message Protocol (MP) wraps raw TCP streams into discrete messages using
the following structure:

    [ 2-byte header ][ payload ]

- **Header**: Unsigned 16-bit big-endian integer (`u16`, network
  order).Represents the number of bytes in the payload.Max: 4096 bytes (configurable).\
- **Payload**: Raw application data (`bytes`).

This framing ensures each call to `read_frame()` returns **exactly one
complete message**, regardless of how TCP splits or merges packets.

---

## ⚙️ Features

- ✅ Works on both client & server with the same class\
- ✅ Protects against partial reads (`recv_exact` guarantees n bytes)\
- ✅ Guards against oversized messages (`_MAX_PAYLOAD = 4096`)\
- ✅ Clean separation of **framing** and **application payload**

---

## 🖥️ Usage

**NOTE**: Requires socket!

### Installation

```
pip install message-proto
```

### Sending a message

```python
from message_protocol import MessageProtocol

msg = b"hello world"
MessageProtocol.write_frame(sock, msg)
```

### Receiving a message

```python
payload = MessageProtocol.read_frame(sock)
if payload is None:
    print("Connection closed")
else:
    print("Got:", payload.decode())
```

---

## 📑 Protocol Rules

1. All messages MUST be framed using `MessageProtocol.write_frame`.\
2. Payloads MUST NOT include their own headers (the class adds one
   automatically).\
3. Messages longer than `_MAX_PAYLOAD` (default 4096 bytes) will be
   rejected.\
4. Payloads of length `0` are valid (useful for pings/keepalives).

---

## 🧪 Example Wire Format

For `payload = b"ABC"`:

    0003 41424

- `0003` → header = 3 bytes\
- `414243` → payload (`"ABC"`)

---