semvec/pypi-packages huggingface dataset:
tfs-pandas 4.0.2
Read and write tfs files.
Requires Python: >=3.10
Keywords: MAD-X, TFS

# TFS-Pandas

[![Tests](https://github.com/pylhc/tfs/actions/workflows/coverage.yml/badge.svg?branch=master)](https://github.com/pylhc/tfs/actions/workflows/coverage.yml)
[![GitHub last commit](https://img.shields.io/github/last-commit/pylhc/tfs.svg?style=popout)](https://github.com/pylhc/tfs/)
[![GitHub release](https://img.shields.io/github/v/release/pylhc/tfs?logo=github)](https://github.com/pylhc/tfs/)
[![PyPI Version](https://img.shields.io/pypi/v/tfs-pandas?label=PyPI&logo=pypi)](https://pypi.org/project/tfs-pandas/)
[![Conda-forge Version](https://img.shields.io/conda/vn/conda-forge/tfs-pandas?color=orange&logo=anaconda)](https://anaconda.org/conda-forge/tfs-pandas)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.5070986.svg)](https://doi.org/10.5281/zenodo.5070986)

This package provides reading and writing functionality for [**Table Format System (TFS)**](https://pylhc.github.io/tfs/tfsformat.html) files.
Files are read into a `TfsDataFrame`, a class built on top of the `pandas.DataFrame`, which in addition to the normal behavior attaches a dictionary of headers to the `DataFrame`.

See the [API documentation](https://pylhc.github.io/tfs/) for details.

## Installing

Installation is easily done via `pip`:

```bash
python -m pip install tfs-pandas
```

One can also install in a `conda`/`mamba` environment via the `conda-forge` channel with:

```bash
conda install -c conda-forge tfs-pandas
```

## Example Usage

The package is imported as `tfs`, and exports top-level functions for reading and writing:

```python
import tfs

# Loading a TFS file is simple
data_frame = tfs.read("path_to_input.tfs", index="index_column")

# You can access and modify the headers with the .headers attribute
useful_variable = data_frame.headers["SOME_KEY"]
data_frame.headers["NEW_KEY"] = some_variable

# Manipulate data as you do with pandas DataFrames
data_frame["NEWCOL"] = data_frame.COL_A * data_frame.COL_B

# You can check the validity of a TfsDataFrame, speficying the
# compatibility mode as well as the behavior in case of errors
tfs.frame.validate(
    data_frame,
    non_unique_behavior="raise",  # or choose "warn"
    compatibility="mad-x",  # or choose "mad-ng"
)

# Writing out to disk is simple too
tfs.write("path_to_output.tfs", data_frame, save_index="index_column")
```

Compression is automatically supported, based on the provided file extension (for supported formats):

```python
import tfs

# Reading a compressed file is simple, compression format is inferred
df = tfs.read("path_to_input.tfs.gz")

# When writing choose the compression format by providing the appropriate file extension
tfs.write("path_to_output.tfs.bz2", df)
tfs.write("path_to_output.tfs.zip", df)
```

## License

This project is licensed under the `MIT License` - see the [LICENSE](LICENSE) file for details.
zhinst-seqc-compiler 26.1.0.361
Zurich Instruments SeqC compiler
Requires Python: >=3.10

# Zurich Instruments SeqC Compiler

The `zhinst-seqc-compiler` package contains a standalone compiler for the Zurich
Instruments [LabOne](https://www.zhinst.com/labone)&reg; AWG Sequencer programming
language, SeqC. Please see the corresponding sections in the user manuals for
more detail, e.g.,
[SHFQA](https://docs.zhinst.com/shfqa_user_manual/functional_description/generator_tab.html#shfqa.functional_description.readout_pulse_generator.sequencer.seqc),
[SHFQC](https://docs.zhinst.com/shfsg_user_manual/functional_description/awg.html#labone.functional.awg.language),
or
[HDAWG](https://docs.zhinst.com/hdawg_user_manual/functional_description/awg.html#labone.functional.awg.language).

This package exposes a single function, `zhinst.seqc_compiler.compile_seqc`,
which takes SeqC source code and returns the compiled program and waveforms as
an ELF file, which can be uploaded through the [LabOne
API](https://docs.zhinst.com/labone_programming_manual/overview.html).

The same function is available in the
[`zhinst-core`](https://pypi.org/project/zhinst-core/) package.
`zhinst.core.compile_seqc` will forward the call to
`zhinst.seqc_compiler.compile_seqc` if a compatible version of this package is
installed. A version is compatible if major and minor package versions match,
and the revision of ´zhinst-seqc-compiler´ is greater or equal to the revision
of `zhinst-core`. A warning will be issued if the versions do not match.

This package has the main purposes to enable faster deployment of bug fixes
independently from `zhinst-core` and the LabOne release cycle.
zhinst-core 26.1.0.361
Python API for Zurich Instruments Devices
Requires Python: >=3.10

# Zurich Instruments LabOne API

The `zhinst-core` package allows communication with Zurich Instruments devices from
the Python programming language. It's the native Python API of LabOne&reg;, the
Zurich Instruments control software.

![Zurich Instruments Arbitrary Waveform Generator and monitor showing LabOne Software](https://people.zhinst.com/~danielw/pypi/hdawg_labone_pic02.jpg)

The documentation for the `zhinst.core` binary extension can be accessed [online](https://docs.zhinst.com/labone_api/index.html) or via the built-in `help` command:

```Python
import zhinst.core
help(zhinst.core)
```

More information about programming with Zurich Instruments devices is available
in the [LabOne Programming
Manual](https://docs.zhinst.com/labone_programming_manual/python.html).

# Uploading wheels to PyPI

## Requirements:
- Any Python (this can be performed using any python installation, it does not
  require the installation for a particular Python build).
- twine package (pip install --upgrade twine)

## Accounts
We have accounts at the main and test PyPI repositories:

https://pypi.org
username: zhinst

https://test.pypi.org
username: zhinst

## Testing
To test, upload to test.pypi.org:
twine upload --repository-url https://test.pypi.org/legacy/ /home/archive/ziReleases/ci-artifacts/branches-18.05/_latest/*whl

## Release
To release, upload to pypi.org:
twine upload /home/archive/ziReleases/ci-artifacts/branches-18.05/_latest/*whl
vmmaster-pro 1.0.0
A professional virtual machine management library inspired by VirtualBox
Requires Python: >=3.7

# VMMaster

**VMMaster** is a professional, high-level Python library for managing virtual machines, designed to provide an experience similar to **VirtualBox**. It offers a robust API for full VM lifecycle management, advanced storage controllers, and complex network configurations.

## Key Features

- **VirtualBox-like API**: Familiar interface for those who have used VBoxManage or the VirtualBox SDK.
- **Extensive OS Support**: Pre-configured profiles for over 50+ operating systems, including:
  - **Windows**: 11, 10, Server 2022, etc.
  - **Linux**: Ubuntu, Debian, CentOS, Fedora, Arch, etc.
  - **Unix**: FreeBSD, OpenBSD, Solaris.
  - **Others**: macOS, Android-x86, ChromeOS.
- **Advanced Storage**: Support for VDI, VMDK, and VHD formats with snapshot capabilities.
- **Networking**: NAT, Bridged, Host-only, and Internal network modes.
- **Scalability**: Over 40,000 lines of optimized code for enterprise-grade virtualization management.

## Installation

```bash
pip install vmmaster-pro
```

## Quick Start

```python
from vmmaster import create_vbox_instance

# Initialize the VMMaster instance
vbox = create_vbox_instance()

# Create a new Virtual Machine
vm = vbox.get_machine("My_New_VM")
print(f"Managing VM: {vm['name']} - Status: {vm['state']}")
```

## Documentation

Comprehensive documentation is available in the `docs/` folder.

## License

MIT License
iflow-mcp_safe-swiss-cloud-ag_mcp_pdf_reader 0.1.0
An MCP enabled PDF reader
Requires Python: >=3.8

# MCP Enabled PDF Reader
Model Context Protocol (MCP) server exposes a tool called read_pdf to read a single pdf document. This has been tested on Claude Desktop and LibreChat with Ollama. Although there is no maximum size to the pdf file that can be read, the number of tokens passed to the model will be the limiting factor.

## Installation

### Prerequisites

#### Windows
1. Install Claude Desktop (or another MCP-enabled AI tool)
   - Download [Claude for Desktop](https://claude.ai/download) 
   - Follow the current installation instructions: [Installing Claude Desktop](https://support.anthropic.com/en/articles/10065433-installing-claude-for-desktop)
     
2. Install Python 3.10 or higher:
   - Download the latest Python installer from [python.org](https://python.org)
   - Run the installer, checking "Add Python to PATH"
   - Open Command Prompt and verify installation with `python --version`

3. Install uv:
   - Open Command Prompt as Administrator
   - Run `pip install --user uv`
   - Verify installation with `uv --version`

#### macOS
1. Install Claude Desktop (or another MCP-enabled AI tool)
   - Download [Claude for Desktop](https://claude.ai/download) 
   - Follow the current installation instructions: [Installing Claude Desktop](https://support.anthropic.com/en/articles/10065433-installing-claude-for-desktop)
     
2. Install Python 3.10 or higher:
   - Using Homebrew: `brew install python`
   - Verify installation with `python3 --version`

3. Install uv:
   - Using Homebrew: `brew install uv`
   - Alternatively: `pip3 install --user uv`
   - Verify installation with `uv --version`

## Configuration

Add the following to your `claude_desktop_config.json`:

```json
{
    "mcpServers": {
        "mcp-pdf-reader": {
            "command": "uvx",
            "args": [
                "--from",
                "git+https://github.com/Safe-Swiss-Cloud-AG/mcp_pdf_reader@main",
                "mcp_pdf_reader"
            ]
        }
    }
}
```
## Attribution

This software package implements the ability to read a pdf file into a MCP enabled framework and is developed by [Safe Swiss Cloud](https://safeswisscloud.com). 


## Contributing

We welcome contributions to improve these tools. Please submit issues and pull requests through our repository.

## Support

For questions and support:
1. Check our documentation
2. Submit an issue in our repository
weaviate-haystack 7.1.0
An integration of Weaviate vector database with Haystack
Requires Python: >=3.10

# weaviate-haystack

[![PyPI - Version](https://img.shields.io/pypi/v/weaviate-haystack.svg)](https://pypi.org/project/weaviate-haystack)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/weaviate-haystack.svg)](https://pypi.org/project/weaviate-haystack)

- [Integration page](https://haystack.deepset.ai/integrations/weaviate-document-store)
- [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/weaviate/CHANGELOG.md)

---

## Contributing

Refer to the general [Contribution Guidelines](https://github.com/deepset-ai/haystack-core-integrations/blob/main/CONTRIBUTING.md).

To run integration tests locally, you need a Docker container running Weaviate.
Use the provided `docker-compose.yml` file to start the container: `docker compose up -d`.