semvec/pypi-packages huggingface dataset:
polars_access_mdbtools 0.1.2
A library for reading tables from an Access database into Polars dataframes, using mdbtools
Requires Python: >=3.11
Keywords: access, database, dataframe, mdbtools, polars

# polars_access_mdbtools
A library for reading tables from an Access database into Polars dataframes, using mdbtools

## What is this?

A tiny, `subprocess`-based tool for reading a 
[MS Access](https://products.office.com/en-us/access) 
database (`.mdb`, `.accdb`, `.rdb`) as a [Python Polars Dataframe](https://docs.pola.rs).

## Installation

To read the database, this package thinly wraps 
[MDBTools](https://github.com/mdbtools/mdbtools).

If you are on `macOS`, install it via [Homebrew](http://brew.sh/):

```sh
$ brew install mdbtools
```

If you are on `Debian`, install it via apt:
```sh
$ sudo apt install mdbtools
```

If you are on `Windows`, it's a little tougher. Install `mdbtools` for [Windows](https://github.com/lsgunth/mdbtools-win). Manually add to PATH.
1. Download the mdb-tools files from Windows link above. Visit the Releases section, then download the part that says "Source Code (zip)".
2. Extract that to somewhere like `C:/bin/mdbtools-win/mdbtools-win-1.0.0`.
3. Follow these instructions to [add that folder to your environment path](https://linuxhint.com/add-directory-to-path-environment-variables-windows/) (Method 1, but use the path to the mdbtools executable files).
4. Restart your computer or just close and re-open the program you're running it from. You can test that it works by opening a terminal and running `mdb-tables --help` and see that it doesn't fail.

Finally, on all OS's:
```sh
$ pip install polars_access_mdbtools
```

## Example Usage

```python
import polars as pl
import polars_access_mdbtools as pl_access

file_path = "path_to_file.mdb"
print(pl_access.list_table_names(file_path))

df: pl.DataFrame = pl_access.read_table(file_path, table_name="your_table_name")
```

## Acknowledgements

This code is based heavily on [jbn's `pandas_access` library](https://github.com/jbn/pandas_access).

## Contributing

Please Star this repo. 

Please submit bug reports as GitHub Issues. Feel free to submit a PR to fix an issue!
sphinx_gemini_builder 2.0.1
Build gemini blog
Requires Python: >=3.8
Keywords: sphinx, gemini, gemlog

sphinx_gemini_builder
#####################

Build `Gemini <https://gemini.circumlunar.space/>`_ blog from
`Sphinx <https://www.sphinx-doc.org>`_ with
`ABlog <https://ablog.readthedocs.io/>`_ compatibility.


Gemini is a simple protocol between gopher and web. Sphinx is
a documentation tool. This project builds Gemini capsule from
Sphinx documentation. It supports ABlog extensions and manage
Atom feeds.

Installation and use
--------------------

Install with `python setup.py install` and do `make gemini` in
your project.


You can add a `gemini_footer` in config, formatted under the
Gemini specification. You need to set `gemini_baseurl` for
good url in Atom feeds.


This project contains some parts of code from Sphinx and from
ABlog.
ExtraFerm 0.0.2
Quantum circuit simulator for particle number conserving extended matchgate circuits
Requires Python: >=3.11

# ExtraFerm

```bash
pip install extraferm
```

## Overview

This library can be used to estimate Born rule probabilities of measurement outcomes from particle-number conserving extended matchgate circuits:

- **Extended matchgate**: the universal gate set consisting of matchgates + controlled‑phase gates  
- **Particle-number conserving**: the Hamming weight of initial state is preserved at all points by the circuit

## Circuit Extent

Our simulator runs most efficiently when the circuit’s **extent** is close to one. The extent is defined as:

$$
\xi^* = \prod_{j=1}^k \bigl(\cos(\theta_j/4) + \sin(\theta_j/4)\bigr)^2
$$

where $\theta_j$ is the angle of the $j$-th controlled-phase gate.

## Use

Users should interact with the simulator through the [`outcome_probabilities`](python/extended_matchgate_simulator/interface.py) function in `interface.py`. 

## Example

```python
import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit.library import XXPlusYYGate

from extraferm import outcome_probabilities

# Create a small circuit
seed = 123
rng = np.random.default_rng(seed=seed)
angles = rng.uniform(0, 2 * np.pi, size=12)
qc = QuantumCircuit(4)
qc.x([0, 2])
qc.append(XXPlusYYGate(theta=angles[0], beta=angles[1]), [0, 1])
qc.cp(theta=angles[3], control_qubit=1, target_qubit=2)
qc.append(XXPlusYYGate(theta=angles[4], beta=angles[5]), [1, 2])
qc.cp(theta=angles[6], control_qubit=0, target_qubit=1)
qc.p(theta=angles[7], qubit=0)
qc.append(XXPlusYYGate(theta=angles[8], beta=angles[9]), [2, 3])
qc.append(XXPlusYYGate(theta=angles[10], beta=angles[11]), [0, 1])

# Estimate a few bitstring probabilitites
bitstrings = [0b0101, 0b1100, 0b0011]
probs = outcome_probabilities(
    circuit=qc, outcome_states=bitstrings, trajectory_count=100_000, seed=seed
)

# Show results
print(probs)
qc.draw("mpl", scale=0.8, fold=-1)
```

[5.09355260e-01 1.56195696e-33 8.07714813e-02]

![Quantum Circuit](tutorials/circuit.png)
yxseq 0.0.7
Xu Yuxing's personal tools for biology sequence analysis
Requires Python: >=3.5

# yxseq
Xu Yuxing's personal tools for biology sequence analysis

## Installation
```bash
pip install yxseq
```

## Usage
---
### 1. `fq2fa` Convert fastq to fasta
```bash
yxseq fq2fa -o output.fa -1 input.fq
yxseq fq2fa -o output.fa -1 input_1.fq -2 input_2.fq
```