semvec/pypi-packages huggingface dataset:
page2vec 0.1.0
Convert knowledge base websites into vectors to load them intovector databases
License: MIT
Requires Python: >=3.8
Keywords: vector database, embeddings, web scraping, knowledge base, pinecone, chromadb, milvus

## Description

Convert your knowledge base website (or any page) into a text file that you can store as a vector in any of the existing vector databases. Uses AI browser automation to scrape and process web content.

The databases supported are:

* Pinecone
* ChromaDB
* Milvus

## Installation

```bash
pip install page2vec
```

## Example Usage

### Command Line Interface

After installation, you can use the `page2vec` command. All commands require an OpenAI API key for the LLM that browser automation agent uses.

**Pinecone**

Update all values with the ones from your account: API key, index name, namespace, etc.

```bash
page2vec \
  --database pinecone \
  --url "[INSERT A URL]"  \
  --openai-api-key "[YOUR OPENAI API KEY]"  \
  --pinecone-api-key "[YOUR PINECONE API KEY]"  \
  --pinecone-index "page2vec-testing" \
  --pinecone-namespace "page2vec-default"
```

**ChromaDB**

```bash
page2vec \
  --url "[INSERT A URL]"  \
  --database chromadb \
  --openai-api-key "[YOUR OPENAI API KEY]"  \
  --chromadb-api-key "[YOUR CHROMADB API KEY]"  \
  --chromadb-database-name "page2vec-testing"
```

**Milvus**
```bash
page2vec \
  --url "[INSERT A URL]"  \
  --database milvus \
  --openai-api-key "[YOUR OPENAI API KEY]"  \
  --milvus-output-file "milvus_data.db"  \
  --milvus-collection-name "page2vec-testing"
```

## Custom prompt example

page2vec \
  --database pinecone \
  --url "[INSERT A URL]"  \
  --openai-api-key "[YOUR OPENAI API KEY]"  \
  --pinecone-api-key "[YOUR PINECONE API KEY]"  \
  --pinecone-index "page2vec-testing" \
  --pinecone-namespace "page2vec-default"
  --custom-prompt "Find all the paragraphs of the documentation in https://docs.trychroma.com/docs/overview/contributing. Store only the first 3 paragraphs in a separate row in a CSV."

### Python API

You can also use page2vec programmatically:

```python
import asyncio
from page2vec import async_main
from argparse import Namespace

# Create arguments
args = Namespace(
    database="pinecone",
    url="https://docs.example.com",
    openai_api_key="your-openai-api-key",
    pinecone_api_key="your-pinecone-api-key",
    pinecone_index="your-index",
    pinecone_namespace="your-namespace",
    test_mode=False
)

# Run the process
asyncio.run(async_main(args))
```

## Dependencies

This project uses:
- **browser-use**: AI-powered browser automation for intelligent web scraping
- Database SDKs: Pinecone, ChromaDB, and Milvus clients

## Future Support

These databases will be supported in the future (or upon request):
- PostgreSQL
- Elasticsearch


### Development Installation
If you'd like to debug something or contribute:

```bash
git clone <repository-url>
cd page2vec
pip install -e ".[dev]"
```
pytemplate-uv 2.0.0
PyTemplate UV: A Modern Python Project Generator
License: MIT
Requires Python: >=3.11
Keywords: python, template, project-generator, uv, cookiecutter, cli

# PyTemplate UV

## Overview

PyTemplate UV is a powerful CLI tool for creating Python project templates using the `uv` package manager. It provides a seamless way to generate standardized project structures with modern development practices.

## Features

- 🚀 Quick project initialization
- 🔧 Support for multiple project templates (FastAPI, Standard Python)
- 📦 Integrated with `uv` package management
- 🧪 Comprehensive testing infrastructure
- 🔍 Linting and type checking support

## Prerequisites

- Python 3.11+
- `uv` package manager
- `cookiecutter`

## Installation

```bash
pip install pytemplate-uv
# or
uv pip install pytemplate-uv
```

## Usage

### Create a Project

```bash
# Create a standard Python project (default)
pytemplate-uv create-project

# Create a FastAPI project
pytemplate-uv create-project --template fastapi

# Create a project with a custom name
pytemplate-uv create-project --name my-awesome-project

# Create a project with custom template and name
pytemplate-uv create-project --template fastapi --name my-api-project
```

### Project Creation Options

- `--template`: Choose the project template (default: pyproject)
  - Options: `pyproject`, `fastapi`
- `--name`: Specify a custom project name
- Additional template-specific options can be passed as needed

### Next Steps After Project Creation

1. `cd` into your project directory
2. Run `uv venv` to create a virtual environment
3. Run `uv pip install -e .` to install dependencies
4. Run `make setup` to set up the development environment

## Development

### Setup

1. Clone the repository
2. Create a virtual environment:
   ```bash
   uv venv
   source .venv/bin/activate
   ```

3. Install development dependencies:
   ```bash
   uv pip install -e .[dev]
   ```

### Running Tests

```bash
pytest
```

### Linting

```bash
ruff check .
black .
mypy .
```

## Contributing

Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for details.

## License

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

## Contact

Leo Liu - [GitHub](https://github.com/yuxuzi)

---

*Simplifying Python project creation with modern best practices* 🐍✨
cmemutils 0.1.0
python memory and vector utilities
License: MIT
Requires Python: >=3.9

# cmemutils

cmemutils — simple, focused Python utilities for working with process memory and offsets.  
Created by **advantagewtf** to provide small, reusable helpers for educational, research, and development purposes.

---

> ⚠️ **IMPORTANT — Responsible use only**  
> This project is intended **for educational and research purposes only** (learning about OS internals, debugging, testing tools you own, reverse-engineering for interoperability, etc.).  
> **Do not** use this code to break terms of service, cheat in multiplayer games, or otherwise violate laws or rules. The author and maintainers are **not** responsible for bans, account suspensions, or other penalties resulting from misuse.

---

# Table of contents
- Overview
- Features
- Requirements
- Installation
- Quick start
- API
- Examples
- Testing
- Contributing
- Roadmap
- License
- Support & Contact
- Disclaimer

---

# Overview
`cmemutils` is a small collection of Python helpers that make common memory- and offset-related tasks easier:
- process discovery and lightweight process handles
- reading/writing primitive values and blobs
- helpers for dealing with module bases and offsets
- utilities for parsing and converting offset files (JSON / CSV)

The aim is clarity and portability — each utility is simple and documented so it can be composed into larger debugging or tooling workflows.

---

# Features
- Enumerate running processes and modules
- Open a process handle (cross-platform considerations documented)
- Read and write bytes and primitives (ints, floats) through a simple API
- Resolve module base address and compute absolute addresses from offsets
- Load/save offset maps (JSON) and provide convenience conversion helpers
- Small, dependency-light footprint

---

# Requirements
- Python 3.9+ recommended
- Platform-specific dependencies may be required for low-level process access (see **Platform notes** below)
- No heavy external frameworks required for the core helpers

**Platform notes**
- Some operations (open process, read/write memory) require elevated privileges on modern OSes and/or platform-specific APIs. See the documentation for platform behavior and examples.

---