semvec/pypi-packages huggingface dataset:
pr22 2.2.0.22
Passport Reader Interface
Requires Python: >=3.6


What is pr22
------------

The Passport Reader is a travel document reader and analyzer system
by ADAPTIVE RECOGNITION.
 
The main features of the PR system are:
 - Image scanning with different illuminations
 - Document, character and barcode recognition
 - Authentication of visual elements of documents
 - Reading and authenticating of electronic documents

This software component is the general python SDK for the Passport Reader
system.

Installation and dependencies
-----------------------------

The pr22 requires the Passport Reader software to be installed, and it
works with special ID scanner hardware only. On Windows OS, the required
bitness (32/64) of the Passport Reader software depends on the used
python.exe and not on the operating system architecture.

The pr22 can cooperate with PyQt as it can pass and get images, but
installation of PyQt is not mandatory.

Install with the following command
```commandline
py -m pip install pr22
```
After that, the ready state of pr22 can be tested with
```commandline
py -m pr22
```
The documentation of classes and functions is available through pydoc
documentation starting as
```commandline
py -m pydoc -b
```
and then selecting the pr22 package.

Usage
-----

The source distribution of pr22 contains a tutorial folder with command
line sample programs. With the help of these programs, you can go through
the options of different topics. Also, there is a gui folder with more
lifelike examples but these demonstrate fewer options of the API than
command line samples.

### Tutorial programs:

#### pr01_open

Shows the possibilities of opening a device.

The following tutorials show the easy way of opening in their open_dev()
methods.

#### pr02_hwinfo

Shows how to get general information about the device capabilities.

#### pr03_scanning

Shows how to parametrize the image scanning process.

#### pr04_analyze

Shows the main capabilities of the image processing analyzer function.

#### pr05_doctype

Shows how to generate document type string. This example needs some additional
source files from the pr22ext folder.

#### pr06_ecard

Shows how to read and process data from ECards (including RFID documents).
After ECard selection, before starting reading ECard data, some authentication
processes have to be called for accessing the data files. This program performs
the steps of the reading process one by one.

### GUI programs:

Currently, only the PyQt dependent version of these examples are available.

#### ScannerSample

At first, it captures images with selected illuminations, utilizing motion
detection. Then, it analyzes image data. Finally, it shows the read data in
different representation forms.

#### ReadCard

Reads ECard data after executing the related authentications. The files read
can be saved by right-click on the filenames. The program performs the entire
reading process in the background.
thisworddoesnotexist 0.2.3
Fetch a fake word from thisworddoesnotexist.com
Requires Python: >=3.6

# ThisWordDoesNotExist

Fetches a fake word from thisworddoesnotexist.com.

## Installation

```bash
pip install -r requirements.txt
```

## Usage

```python
from thisworddoesnotexist import get_fake_word

# Get a random fake word
word = get_fake_word()
print(word)  # Prints a randomly generated fake word
```

## Requirements

- Python 3.6+
- requests
- beautifulsoup4

## License

MIT
single-doc-retrieval 0.2.0
A retrieval pipeline for single documents.
Requires Python: >=3.10

# Single Document Retrieval Pipeline

A Python library to perform retrieval on a single, pre-parsed document. 
It identifies relevant text sections from a document based on a query (label description) and, if necessary, refines the search query iteratively to find the most sufficient context.

## Testing

The main way to use the library is by calling the `find_relevant_context` function.

```python
DOC_FILES_DIRECTORY = ""

OPENAI_API_KEY_INPUT = ""

LABELS_FILE_PATH = "labels.json" 
LABEL_NAME_TO_USE = "governing_law_clause"

EMBEDDING_MODEL_NAME = "text-embedding-3-large" 
CHAT_MODEL_NAME = "gpt-4o"      

# Derive doc_id and extraction_dir from DOC_FILES_DIRECTORY
doc_id_from_path = os.path.basename(DOC_FILES_DIRECTORY)
extraction_dir_from_path = os.path.dirname(DOC_FILES_DIRECTORY)

# Prepare pipeline options if custom models are specified
pipeline_opts = {}
pipeline_opts["embedding_model"] = EMBEDDING_MODEL_NAME

pipeline_opts["chat_model"] = CHAT_MODEL_NAME

relevant_context = find_relevant_context(doc_id=doc_id_from_path,
                                         label_name=LABEL_NAME_TO_USE,
                                         extraction_dir=extraction_dir_from_path,
                                         labels_file_path=LABELS_FILE_PATH,
                                         openai_api_key=OPENAI_API_KEY_INPUT,
                                         pipeline_options=pipeline_opts)
```

The labels.json file should be formatted as follows:

```python
{
    "label_1": {
    "description": "",
    "examples": []
    },
    "label_2": {
    "description": "",
    "examples": []
    }
}
```
dnacauldron 2.0.12
Cloning simulation for DNA assembly (Golden Gate, Gibson...)
Keywords: DNA, assembly, cloning, simulator, synthetic biology

DNA Cauldron
============

DNA Cauldron provides a generic cloning simulation framework to predict
constructs sequences and detect assembly flaws.
It can simulate Golden-Gate, with extra features like enzyme or
connector parts autoselection, and other methods like Gibson Assembly,
LCR Assembly, BASIC assembly, BioBrick assembly.
It supports single and combinatorial assemblies, hierarchical assemblies, and
produces nice reports for traceability and troubleshooting.


Infos
-----

**PIP installation:**

.. code:: bash

  pip install dnacauldron

**Web documentation:** `<https://edinburgh-genome-foundry.github.io/DnaCauldron/>`_

**Github Page:** `<https://github.com/Edinburgh-Genome-Foundry/DnaCauldron>`_

**Live demo:** `<http://cuba.genomefoundry.org/simulate_gg_assemblies>`_

**License:** MIT

Copyright 2020 Edinburgh Genome Foundry, University of Edinburgh


More biology software
---------------------

.. image:: https://raw.githubusercontent.com/Edinburgh-Genome-Foundry/Edinburgh-Genome-Foundry.github.io/master/static/imgs/logos/egf-codon-horizontal.png
  :target: https://edinburgh-genome-foundry.github.io/

DNA Cauldron is part of the `EGF Codons <https://edinburgh-genome-foundry.github.io/>`_ synthetic biology software suite for DNA design, manufacturing and validation.
fashiondata00 0.1.4
Excel-style conditional aggregation with AND/OR logic for pandas
Requires Python: >=3.13

# fashiondata00

`fashiondata00` is a lightweight Python package that provides a single versatile function `all()`  
for Excel-style conditional aggregation in pandas, supporting AND / OR logic.

---

## 📦 Installation

```bash
pip install fashiondata00
```

---

## 🧠 Function: `all()`

```python
all(df, target_col=None, agg='sum', logic='and', **conditions)
```

### Parameters:

- `df`: pandas DataFrame
- `target_col`: column to aggregate (optional if using `count`)
- `agg`: aggregation type - `'sum'`, `'mean'`, `'count'`, `'min'`, `'max'`
- `logic`: `'and'` (default) or `'or'` for combining conditions
- `**conditions`: keyword arguments specifying conditions  
  (e.g., `Gender='F', City='Seoul'`)

---

## ✅ Examples

```python
from fashiondata00 import all
import pandas as pd

df = pd.DataFrame({
    'Gender': ['F', 'M', 'F', 'F'],
    'City': ['Seoul', 'Busan', 'Seoul', 'Busan'],
    'Score': [90, 70, 85, 95]
})

# AND condition: Female AND lives in Seoul → sum of scores
all(df, target_col='Score', agg='sum', logic='and', Gender='F', City='Seoul')
# Output: 175

# OR condition: Female OR lives in Seoul → average score
all(df, target_col='Score', agg='mean', logic='or', Gender='F', City='Seoul')
```

---

## 👤 Author

Made by [Kwon Ki Yong]
downly 0.3.1
Yet another download manager in python.
Requires Python: >=3.9
Keywords: download, url, fast, download manager

# Downly - Python Download Manager

*A fast and efficient Python download manager.*

(For downloading torrents visit [torrentix](https://github.com/Amir-Hossein-ID/torrentix))

## 🚀 Features
- **Synchronous downloads** for faster performance
- **Resume support** for interrupted downloads (even if the process is killed!)
- **Multiple downloads** with a single instance
- **Progress tracking** with a clean CLI output

## 📦 Installation
```sh
pip install downly
```

## 💻 Command Line Usage

```sh
downly https://example.com/file.zip [options]
```

Use `downly --help` to see options.

## 🐍 Direct Usage

```python
import asyncio
from downly import Downly

async def main():
    downly = Downly()
    download = downly.new_download("https://example.com/file.zip")
    await download.start()

if __name__ =='__main__':
    asyncio.run(main())
```

### Non-Blocking Downloads
```python
async def main():
    downly = Downly()
    download = downly.new_download("https://example.com/file.zip")
    await download.start(block=False)

    await asyncio.sleep(3) # do other stuff while downloading

    await downly.await_downloads() # wait for download to finish
```

### Pause and resume Downloads
```python
async def main():
    downly = Downly()
    download = downly.new_download("https://example.com/file.zip")
    await download.start(block=False)

    await download.pause()

    # do other stuff

    await download.start() # resume download
```

### Multiple Downloads
```python
async def main():
    downly = Downly()
    downly.new_download("https://example.com/file.zip")
    downly.new_download("https://example.com/file2.zip")
    downly.new_download("https://example.com/file3.zip")
    await downly.await_downloads()
```

### Automatically Saves download state
- Start download: `await download.start()`
- Something Happens and the process terminates:
```sh
file.zip  29% ━━━━━━━━━━━╸━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 4.4/15.1 MB 0:00:03 0:00:07 1.6 MB/s
Ctrl^C (Keyboard Interrupt)
```
- Start Download Again: `await d.start()`
- Download starts from where it was stopped:
```sh
file.zip  29% ━━━━━━━━━━━╸━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 4.4/15.1 MB 0:00:03 0:00:07 1.6 MB/s
```

## 🛠 Configuration
You can customize download's settings by passing options:
```python
async def main():
    downly = Downly()
    download = downly.new_download(
        "https://example.com/file.zip",
        path='myfolder/myfilename.zip',
        chunk_size=1024*1024*2, # 2MB
        n_connections=16 # 16 synchronous connections 
    )
    await download.start()
```


## 🔥 Roadmap
- [ ] Proxies Support
- [ ] More control over User agents, number of retries, ...

## 📜 License
MIT License. See [LICENSE](LICENSE) for details.
crazydoc 0.2.2
Read genetic sequences from stylized docx files
Keywords: dna-sequence, bioinformatics, systems-biology, docx

CrazyDoc
========

Crazydoc is a Python library to parse one of the most common DNA representation formats: the joyfully coloured and stylishly annotated MS Word document.

.. image:: https://raw.githubusercontent.com/Edinburgh-Genome-Foundry/crazydoc/master/images/screenshot.png
   :alt: [logo]
   :align: center
   :width: 600px

While other standards such as FASTA or Genbank are better supported by modern sequence editors, none enjoys the same popularity among molecular biologist as MS Word's ``.docx`` format, which is limited only by the sophistication and creativity of the user.

Infos
-----

**PIP installation:**

.. code:: bash

  pip install crazydoc

**Github Page:** `<https://github.com/Edinburgh-Genome-Foundry/crazydoc>`_

**License:** MIT

2018, 2025 Edinburgh Genome Foundry, University of Edinburgh


More biology software
---------------------

.. image:: https://raw.githubusercontent.com/Edinburgh-Genome-Foundry/Edinburgh-Genome-Foundry.github.io/master/static/imgs/logos/egf-codon-horizontal.png
  :target: https://edinburgh-genome-foundry.github.io/

Crazydoc is part of the `EGF Codons <https://edinburgh-genome-foundry.github.io/>`_ synthetic biology software suite for DNA design, manufacturing and validation.
easy-dna 0.4.1
Methods for DNA sequence reading, writing and editing.
Keywords: DNA, sequence, Genbank, record, editing

Easy DNA
========

Easy_dna is a Python library implementing useful routines for manipulating DNA
sequences, either as "ATGC" strings or Biopython records. It aims at providing
a simpler interface than Biopython for common operations related to DNA sequence
design and genbank generation.

**Github Page**: `<https://github.com/Edinburgh-Genome-Foundry/easy_dna>`_

**License:** MIT

Copyright 2019, 2020, 2021, 2024 Edinburgh Genome Foundry, University of Edinburgh


More biology software
---------------------

.. image:: https://raw.githubusercontent.com/Edinburgh-Genome-Foundry/Edinburgh-Genome-Foundry.github.io/master/static/imgs/logos/egf-codon-horizontal.png
  :target: https://edinburgh-genome-foundry.github.io/

Easy DNA is part of the `EGF Codons <https://edinburgh-genome-foundry.github.io/>`_ synthetic biology software suite for DNA design, manufacturing and validation.
pylintsql 0.0.9
a tool that lints/fixes SQL code within Python strings using SQLFluff
Requires Python: >=3.0

# PyLintSQL

A tool that lints/fixes SQL code within Python strings using SQLFluff.

## Installation

```shell
# Install from PyPI
pip install pylintsql
```


## Usage
### Lint SQL in Python files in the current directory
```shell
pylintsql lint
```

### Fix SQL in Python files in a specific directory
```shell
pylintsql fix path/to/directory
```

### Use a custom configuration file
```shell
pylintsql lint --config /path/to/config
```

## SQL String Identification
PyLintSQL identifies SQL strings by looking for the --sql marker at the beginning of the string. Only strings with this marker will be processed:
```python
# This SQL string will be linted
sql = """--sql
    SELECT
      user_id,
      COUNT(*) as order_count
    FROM orders
    WHERE created_at > '2023-01-01'
    GROUP BY user_id
"""

# This regular string will be ignored
other_text = """
    This is not SQL and won't be processed
"""
```

## Configuration
PyLintSQL uses `pyproject.toml` for configuration, which is also a configuration file for SQLFluff itself. This means you can:
* Use all standard SQLFluff configuration options under `[tool.sqlfluff.*]` sections
* Define pylintsql-specific settings under `[tool.pylintsql]`

Example configuration:
```toml
# SQLFluff configuration
[tool.sqlfluff.core]
dialect = "bigquery"  # Or your preferred dialect
max_line_length = 99
exclude_rules = ["RF01", "RF02", "RF04", "ST06"]

[tool.sqlfluff.indentation]
tab_space_size = 2
indented_joins = false
indented_ctes = false

# PyLintSQL specific configuration
[tool.pylintsql]
exclude = [ # Directories/files to exclude
    ".venv/**",  
    "build/**",
    "dist/**",
    "tests/**"
]
```
ben42code.myitertools 0.0.5
Providing some additional capabilities on top of itertools.
Requires Python: >=3.9

# ben42code.myitertools
Providing some additional capabilities on top of itertools.

## Example for `ben42code.myitertools.islice_extended`
`islice_extended` does support negative start/stop indexes and negative step.

```python
from ben42code.myitertools import islice_extended

input = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
result = list(islice_extended(input, -1, -5, -1))
print(f"Result: {result}")

exit()
```
Ouput:
```
Result: [9, 8, 7, 6]
```
pyrayapp 1.0.6
Python Ray debug client
Requires Python: >=3.8
Keywords: ray, rayapp

# pyray

Python [Ray](https://myray.ap) debugging client.

This package allows you to send structured debug payloads to Ray.app from your Python application,
including rich content like text, images, HTML, and formatted dumps — all with optional delayed sending.

## Features

- Send payloads like strings, booleans, images, dumps, and more
- Lazy evaluation — chain multiple calls and send once
- Stack trace origin support
- Compatible with Ray.app (https://myray.app)

## Installation

```bash
pip install pyrayapp
```

## Usage

```python
from pyrayapp import ray

ray("Hello from Python!").color("green").notify("Payload sent!").pause()
```

## License

MIT — see [LICENSE](./LICENSE)
vibepy 0.2.4
have your terminal talking to and running codes from open-ai
Requires Python: <3.11,>=3.10

# Vibepy

Talking to and running codes from open-ai.

## Installation

```bash
pip install vibepy
```
Or if use uv  

```bash
uv  pip install --no-cache vibepy==0.2.3
```

## Usage

Have OPENAI_API_KEYS as one of your environment variables.  

1. Start the vibepy CLI, and have conversation with open-ai

    Default gpt-4o-mini

```bash
vibepy
```
2. Specify model

```bash
vibepy --model gpt-4.1-mini
```

3. automatically run the returned code blocks:  

```bash
vibepy -e
```

This will automatically run the returned code blocks once and present again a user input prompt.  
If the execution returns errors,  
You can then either 
    - press any key, or add say anything (add information) to continue, then it will catch the error messages and input to the model to debug until 5 times
    - press q to quit

Cases when running `vibepy -e`

> Welcome to Vibepy!
> Press 'q' to exit
> Say something: print hello world
> 
> Vibepy: To print "hello world" in Python, you just need to use the `print()` function. Here is the code you should execute:
> 
> ```python
> print("hello world")
> ```
> 
> hello world
> Press 'q' to exit
> Say something: calculate 1+1
> 
> Vibepy: ```bash
> source .venv/bin/activate
> ```
> 
> ```python
> result = 1 + 1
> print(result)
> ```
> 
> 2
> Press 'q' to exit
> Say something: q
> 
> Vibepy: It seems like your message got cut off. Could you please provide more details or clarify your request?
> 
> 
> Exiting vibepy...

## Development

```bash
# Install development dependencies
pip install -e ".[dev]"
```

## License

MIT License
camera-stage-mapping 0.1.10
Calibration and mapping between stage and camera coordinates in a microscope
Requires Python: >=3.9

# Camera Stage Mapping calibration

This Python module allows you to calibrate a microscope's stage against the camera.  By moving the sample a known number of steps, and tracking how far the image translates, it is possible to recover the number of steps per pixel.  This code goes a step further, and recovers a 2x2 affine transformation matrix, so it will cope with rotation, flipping, and non-uniform scaling of the X and Y axes.  The calibration routines are designed to be relatively robust and minimally parameterised, so they start by determining a sensible step size automatically.

As part of the calibration, you can use either FFT-based or directly calculated cross correlation to track motion of the sample.  This code is probably useful on its own, and is found in the ``fft_image_tracking`` and ``correlation_image_tracking`` submodules.  The underlying mechanism of tracking stage and camera coordinates simultaneously is handled by the ``CameraStageTracker`` class, in ``camera_stage_tracker``.  The main calibration function is ``camera_stage_calibration_1d.calibrate_backlash_1d``.  For 2D calibration, I recommend running this once for X and once for Y, then using ``camera_stage_calibration_1d.image_to_stage_displacement_from_1d`` to combine the two calibrations.  This is more robust than the 2D grid calibration method.

## Hardware interface
Rather than tie these functions to a specific class interface, as found in many lab control frameworks, the calibration routines simply require functions to be passed in as arguments.  This is done for maximum flexibility, and to impose the fewest necessary constraints on the hardware we are controlling.  In the future, we may define a class interface to use, and would welcome input on how to do this without forcing a particular taxonomy of laboratory instruments upon everyone using the library.

## Installing
```
pip install camera-stage-mapping
```
This package is published on PyPI and can be installed using ``pip``.  It's managed using ``poetry`` and can be installed by cloning the repository and running ``poetry install``.  For details of how to set up a development environment, please see [CONTRIBUTING].

## Documentation
The functions all have fairly extensive docstrings and the module is documented on [readthedocs].

[readthedocs]: https://camera-stage-mapping.readthedocs.io/en/latest/index.html
[CONTRIBUTING]: ./CONTRIBUTING.md