semvec/pypi-packages huggingface dataset:
enthusiast-agent-user-manual-search 1.2.0
User Manual Search Agent for Enthusiast
Requires Python: <4,>=3.10

# Enthusiast User Manual Search Agent

The User Manual agent operates over a collection of product manuals and provides precise, context-aware answers to user or support-team questions. Responses include direct citations with links back to the relevant section of the manual, and the agent performs a sanity check to ensure the answer aligns with the documented information before returning it.

## Installing the User Manual Search Agent

Run the following command inside your application directory:
```commandline
poetry add enthusiast-agent-user-manual-search
```

Then, register the agent in your config/settings_override.py.

```python
AVAILABLE_AGENTS = {
    "enthusiast-agent-user-manual-search": {
        "name": "User Manual Search",
        "agent_directory_path": "enthusiast_agent_user_manual_search"
    },
}
```
bctrl 0.0.1
Remote browser automation for AI agents - Python SDK
Requires Python: >=3.8
Keywords: ai, automation, browser, playwright, puppeteer, scraping, selenium, web

# bctrl

**Remote browser automation for AI agents**

Run browser automation code locally while browsers execute on remote servers.

## Status

The Python SDK is under development. For now, use the TypeScript/JavaScript SDK:

```bash
npm install bctrl
```

## What is bctrl?

bctrl provides a seamless, local-feeling API for browser automation that actually executes on remote infrastructure. Instead of managing browser instances locally, your code sends stateless HTTP commands to a control plane that manages browser lifecycles on remote host machines.

**Features:**
- No local browser setup - browsers run remotely
- Anti-detection built-in via Kameleo
- Human-like mouse movements via ML
- AI-native with Stagehand integration
- Puppeteer, Playwright, or Selenium APIs

## Coming Soon

```python
from bctrl import BctrlClient

client = BctrlClient(base_url="http://your-control-plane:3000")

session = client.sessions.create(driver="playwright", humanize=True)

page = session.page
page.goto("https://example.com")
page.click("#login")

# AI-powered automation
session.stagehand.act("Search for 'TypeScript tutorials'")

session.stop()
```

## Links

- [GitHub](https://github.com/bctrl/bctrl)
- [TypeScript SDK](https://www.npmjs.com/package/bctrl)

## License

ISC
mdx2 1.0.3
Macromolecular diffuse scattering data reduction
Requires Python: >=3.9

[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.10519719.svg)](https://doi.org/10.5281/zenodo.10519719)

# *mdx2*: macromolecular diffuse scattering data reduction in python

## References

Publications describing [ando-lab/mdx2](https://github.com/ando-lab/mdx2):

- Meisburger SP & Ando N. Scaling and merging macromolecular diffuse scattering with *mdx2*. Acta Cryst. D**80**, 299-313. [DOI](https://doi.org/10.1107/S2059798324002705)
- Meisburger SP & Ando N. Chapter Two - Processing macromolecular diffuse scattering data. In *Methods in Enzymology* Volume **688**, 43-86. [DOI](https://doi.org/10.1016/bs.mie.2023.06.010), [BioRxiv](https://www.biorxiv.org/content/10.1101/2023.06.04.543637v1)

*Mdx2* is based on algorithms and general philosophy of [ando-lab/mdx-lib](https://github.com/ando-lab/mdx-lib), described here:

- Meisburger SP, Case DA & Ando N. Diffuse X-ray scattering from correlated motions in a protein crystal. *Nature Communications* **11**, 1271 (2020). [DOI](https://doi.org/10.1038/s41467-020-14933-6)
- Meisburger SP, Case DA, & Ando N. Robust total X-ray scattering workflow to study correlated motion of proteins in crystals. *Nature Communications* **14**, 1228 (2023). [DOI](https://doi.org/10.1038/s41467-023-36734-3)

## Examples

- Introductory walkthrough using a small insulin dataset: [examples/insulin-tutorial](examples/insulin-tutorial/README.md)
- Scripts and notebooks to regenerate the figures from Meisburger & Ando, Acta Cryst. D (2024): [examples/insulin-multi-crystal](examples/insulin-multi-crystal).

## Versions

### Version 1.0.3

- Performance boost for `mdx2.import_data` using parallel read and write. The `data.nxs` file contains a virtual dataset linking to neXus files in a subdirectory (`datastore/` by default).
- `mdx2.reintegrate` -- New command-line tool to create fine maps after scaling (single-sweep only: multi-crystal datasets not yet implemented)
- Optional pre-scaling in `mdx2.scale` to correct anisotropic background
- Improved handling of command-line arguments via `dataclass` attributes and `simple-parsing` package
- Updated examples

### Version 1.0.2

- Rudimentary Bragg peak integration, in development
- Support for non-reference space group settings
- Bug fixes, including:
  - Symmetry operators now rotate in the correct direction
  - Gracefully skip missing or masked data chunks

## Installation

### Prerequisites

For a conda-based installation, you'll need [micromamba](https://mamba.readthedocs.io/en/latest/installation/micromamba-installation.html) or equivalent.

### User install (conda environment)

```bash
micromamba create -f https://raw.githubusercontent.com/ando-lab/mdx2/refs/tags/v1.0.3/env.yaml
micromamba activate mdx2
pip install mdx2==1.0.3
```

You'll probably want these packages too:

```bash
micromamba install -c conda-forge dials nexpy jupyterlab xia2
```

### Developer install

See The Diffuse Project's [fork](https://github.com/diff-use/mdx2) for instructions.
enthusiast-agent-ocr-to-order 1.2.0
Purchase Order OCR Agent for Enthusiast
Requires Python: <4,>=3.10

# Enthusiast Purchase Order OCR Agent

The Purchase Order OCR agent converts handwritten notes, scans, and filled purchase-order PDFs into structured orders created directly in your e-commerce system. It can also detect when the provided input is incomplete or unclear; in those cases, it initiates a human-in-the-loop clarification step to confirm missing details before creating the order.

## Installing the Purchase Order OCR Agent

Run the following command inside your application directory:
```commandline
poetry add enthusiast-agent-ocr-to-order
```

Then, register the agent in your config/settings_override.py.

```python
AVAILABLE_AGENTS = {
    "enthusiast-agent-ocr-to-order": {
        "name": "Purchase Order OCR",
        "agent_directory_path": "enthusiast_agent_ocr_to_order"
    },
}
```
enthusiast-agent-catalog-enrichment 1.2.0
Catalog Enrichment Agent for Enthusiast
Requires Python: <4,>=3.10

# Enthusiast Catalog Enrichment Agent

The Catalog Enrichment agent processes unstructured vendor product sheets - PDFs, scans, or raw text - and extracts product attributes and details for use in your catalog. It can be customized per category to pull different attribute sets and can flag unclear or missing information, triggering a human-in-the-loop step when clarification is required.

## Installing the Catalog Enrichment Agent

Run the following command inside your application directory:
```commandline
poetry add enthusiast-agent-catalog-enrichment
```

Then, register the agent in your config/settings_override.py.

```python
AVAILABLE_AGENTS = {
    "enthusiast-agent-catalog-enrichment": {
        "name": "Catalog Enrichment",
        "agent_directory_path": "enthusiast_agent_catalog_enrichment"
    },
}
```
capeify 1.1.3
Win cursor package to .cape file converter
Requires Python: <=3.12,>=3.10

<h1 align="center">capeify</h1>
<p align="center">A tool to convert Windows cursor packs to Mousecape capes</p>
<p align="center">
<a href="https://github.com/mmemoo/capeify"><img width="300" alt="capeify logo" src="logo.png"></a></br>
</p>

# Downloading

</br>

**Imagemagick**

To use this tool you need Imagemagick, download it following the guide according to your OS :

**Debian/Ubuntu** : https://docs.wand-py.org/en/0.6.2/guide/install.html#install-imagemagick-debian

**Fedora/CentOS** : https://docs.wand-py.org/en/0.6.2/guide/install.html#install-imagemagick-redhat

**MacOS** : https://docs.wand-py.org/en/0.6.2/guide/install.html#install-imagemagick-mac

**Windows** : https://docs.wand-py.org/en/0.6.2/guide/install.html#install-imagemagick-windows

</br>

**Capeify**

To download Capeify itself, simply:
```
pip install capeify
```

# How to use it
To convert a Windows cursor pack , run :
```
capeify convert --path PATH/TO/THE/CURSORPACK --inf-file INF_FILE_NAME --out OUT_FILE_PATH
```

# How it works
The program first parses the INF file and reads the [Strings],[AddReg] etc. entries and gets the cursor names and their corresponding cur/ani files,
after that those cur/ani files are parsed and their hotspot position,frame duration,frame count etc. are saved and they're converted to pngs, also the cursor names are translated into MacOS cursor identifiers.

After that a ready cape file template is filled with those data and its ready to use.

# Contributing
To contribute to this project, create issues telling me if there are any problems like if a Win cursor name is translated into the wrong MacOS identifier or if a identifier is missing,if a cursors hotspot is wrong etc.

Also you can recommend features to contribute and further develop this project.

# TODO
- [x] Fix the pillow version in pyproject.toml
- [x] Fix the issue with .ani files caused by the mousecape frame count limit
- [x] Fix the issue caused by cur files in ani files having varying height
- [x] Fix the issue with ani files caused by the wrong calculation of the frame count
- [ ] Fix the false frame duration issue with .ani files
- [ ] Fix issues caused by non-centered .cur and (possibly) .ani files
- [ ] Add min cursor size and cursor size capping
- [ ] Add cape to windows cursor pack conversion
selfmemory 0.5.2
Enhanced Memory Management for AI Agents with zero-setup simplicity
Requires Python: >=3.10
Keywords: memory, ai, ml, vector, search, embeddings, agents, llm, artificial-intelligence, qdrant, semantic-search

# SelfMemory

**Store AI memories for you and your agents**

It is a open-source universal memory engine where users can store and retrieve their AI conversations and context across different models. Users can add memories through MCP, SDK, or a website selfmemory.com Over time, this will evolve into a one-stop memory hub with note-taking and chatbot features. For B2B, it becomes a knowledge backbone, storing project context, organizational knowledge, documents, and data sources to power company-wide AI systems.

## 🚀 Quick Start

```bash
pip install selfmemory
```

```python
from selfmemory import SelfMemory

memory = SelfMemory()

# Add memories
memory.add("Can you find the nearest BMW car showroom for me.", user_id="user")

# Search memories
results = memory.search("Can you find a car washing service near me?", user_id="user")
print(results)
```

## 📚 Full Documentation

**Visit [docs.selfmemory.com](https://docs.selfmemory.com) for complete documentation, guides, and examples.**
**Changelog**: See [CHANGELOG.md](CHANGELOG.md) for a detailed list of changes and updates.

## 🤝 Contributing

We welcome contributions! [CONTRIBUTING.md](CONTRIBUTING.md).

## 🔗 Links

- **Discord**: [discord.com/invite/selfmemory](https://discord.com/invite/YypBvdUpcc)
- **Brand Assets** (Logos, Slides, etc.): [Storage Link](https://drive.google.com/drive/folders/1paB9DkpPGv58_MC3P5C1el_Bw7lzYh-3?usp=sharing)
biobb-flexserv 5.2.0
biobb_flexserv is a BioBB category for biomolecular flexibility studies on protein 3D structures.
Requires Python: >=3.10
Keywords: Bioinformatics Workflows BioExcel Compatibility Flexibility Ensembles Protein Structure

biobb_flexserv allows the generation of protein conformational ensembles from 3D structures and the analysis of its molecular flexibility.