semvec/pypi-packages huggingface dataset:
pyDMM6500 2025.0.5
A Python library for Keithley's DMM6500
Requires Python: >=3.9
Keywords: DMM6500, Keithley, Instrument Control, Test and Measurement


# pyDMM6500: A Python library for Keithley's DMM6500


⚠️ This package is a work in progress

This project is a Python library for [Keithley's Digital Multimeter 6.5 digits]((https://www.tek.com/en/products/keithley/digital-multimeter/dmm6500)).

It currently supports basic functionnalities such as configuring the multimeter for DC or resistance measurements,
and measurements buffers.


# Installation

```bash
pip install pyDMM6500
```

# Documentation

## Project structure description

```
.
├── LICENSE
├── README.md
├── pyproject.toml
├── src
│   └── pydmm6500
│       ├── __init__.py
│       └── dmm6500.py          DMM6500 Python library source file
└── tests
    ├── integration             Tests performed with a DMM6500
    │   └── test.py
    └── unit                    Unit testing of the package
        └── test.py
```


# References

* [DMM6500 Datasheet](https://www.tek.com/en/datasheet/dmm6500-6-1-2-digit-bench-system-digital-multimeter-datasheet)
* [DMM6500 User’s Manual](https://www.tek.com/en/manual/model-dmm6500-6-1-2-digit-multimeter-user-manual)
* [DMM6500 Reference Manual](https://www.tek.com/en/tektronix-and-keithley-digital-multimeter/dmm6500-manual/model-dmm6500-6-1-2-digit-multimeter-3)

# Publish to PyPi

1. Remove build files

```bash
rm -rf dist build *.egg-info
```

2. Update version in [`pyproject.toml`](pyproject.toml)

```toml
[project]
version = "202x.x.x"
```

3. Build new version

```bash
python3 -m build
```

4. Upload new version to PyPi

```bash
python3 -m twine upload dist/*
```
ensembl-py 3.0.1
Ensembl Python Base Library
Requires Python: >=3.10
Keywords: ensembl, bioinformatics, python, setup

# Ensembl Python Base Library

[![License](https://img.shields.io/badge/license-Apache_2.0-blue.svg)](https://github.com/Ensembl/ensembl-py/blob/main/LICENSE)
[![Coverage](https://ensembl.github.io/ensembl-py/coverage/coverage-badge.svg)](https://ensembl.github.io/ensembl-py/coverage)
[![CI](https://github.com/Ensembl/ensembl-py/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/Ensembl/ensembl-py/actions/workflows/ci.yml)
[![Release](https://img.shields.io/pypi/v/ensembl-py)](https://pypi.org/project/ensembl-py)

Centralise generic Python code use across all other project within Ensembl, more particularly database access layers and ORMs, reusable eHive components, etc.

## Getting Started

### Installing the development environment with `venv`

```
python -m venv <VIRTUAL_ENVIRONMENT_NAME>
source <VIRTUAL_ENVIRONMENT_NAME>/bin/activate
git clone https://github.com/Ensembl/ensembl-py.git
cd ensembl-py
pip install -e .[cicd,dev,docs]
```

### Testing with `pytest`

Run test suite from the root of the repository is as simple as to run:
```
pytest
```

To run tests, calculate and display testing coverage stats:
```
coverage run -m pytest
coverage report -m
```

### Generate documentation via `mkdocs`
```
mkdocs build
```
Open automatically generated documentation page at `site/index.html`.

### Automatic formatting (PEP8 compliance)
```
black --check .
```
Use `--diff` to print a diff of what Black would change, without actually changing the files.

To actually reformat all files in the repository:
```
black .
```

### Linting and type checking
```
pylint src/python/ensembl
pylint --recursive=y src/python/tests
mypy src/python/ensembl
mypy src/python/tests
```
`pylint` will check the code for syntax, name errors and formatting style. `mypy` will use type hints to statically type check the code.

It should be relatively easy (and definitely useful) to integrate both `pylint` and `mypy` in your IDE/Text editor.

## Useful resources

### Python Documentation
- [Official Python Docs](https://docs.python.org/3/)

### Python virtual environments management
- [Python venv](https://docs.python.org/3/library/venv.html)

### Auto-generating documentation
- [mkdocs](https://www.mkdocs.org)

### Linting, type checking and formatting
- [Pylint](https://www.pylint.org/)
- [Mypy](https://mypy.readthedocs.io/en/stable/)
- [Black](https://black.readthedocs.io/en/stable/)
- [Google Python Style Guide](https://google.github.io/styleguide/pyguide.html#38-comments-and-docstrings)

### Testing
- [pytest](https://docs.pytest.org/en/6.2.x/)
- [Coverage](https://coverage.readthedocs.io/)

### CI/CD
- [GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/)

### Development tools
- [IPython](https://ipython.org/)

### Distributing
- [Packaging Python](https://packaging.python.org/tutorials/packaging-projects/)
- [Apache 2.0 License](https://www.apache.org/licenses/LICENSE-2.0#apply)
- [Semantic Versioning](https://semver.org/)
py-kanban-cli 0.1.4
Personal kanban management in command line
Requires Python: >=3.9

# Kanban cli management

This is a command-line tool to manage simple kanban boards.

## Installation

The recommended way is to use [`pipx`](https://pypi.org/project/pipx), which installs the software in a separate Python environment automatically without you needing to worry about Python at all:

```sh
pipx install py-kanban-cli
```

You also don't need sudo privileges here.

Alternatively, if you have a specific Python environment that is active, a simple `pip install` should work as well:

```sh
pip install py-kanban-cli
```

## Usage

Notice that, despite the awkward package name `py-kanban-cli`, the cli command is simply `kanban-cli`.

For general help on the full commands, type

```sh
kanban-cli --help
```

and it will show all available options and commands.

The most commont involve management of tasks and categories, which you can get more details with the folowing:

```sh
kanban-cli tasks --help
kanban-cli categories --help
```

See the [repository page](https://github.com/fillipe-gsm/kanban-cli) for more complete examples and configuration.
escapism 1.1.0
Simple, generic API for escaping strings.
Requires Python: >=3.9
Keywords: escape

# Escapism

Simple escaping of text, given a set of safe characters and an escape character.

## Usage

Not much to it. Two functions:

```python
escaped = escapism.escape('string to escape')
# 'string_20to_20escape'
original = escapism.unescape(escaped)
```

There are two optional arguments you can pass to `escape()`:

- `safe`: a string or set of characters that don't need escaping. Default: ascii letters and numbers.
- `escape_char`: a single character used for escaping. Default: `_`.
  `escape_char` will never be considered a safe value.

`unescape()` accepts the same `escape_char` argument as `escape()` if a value other than the default is used.

```python
import string
import escapism
safe = string.ascii_letters + string.digits + '@_-.+'
escape_char = r'%'
escaped = escapism.escape('foø-bar@%!xX?', safe=safe, escape_char=escape_char)
# 'fo%C3%B8-bar@%25%21xX%3F'
original = escapism.unescape(escaped, escape_char=escape_char)
```

### Slugs

escapism 1.1 adds a `safe_slug` API (extracted from kubespawner 7).

When to use `safe_slug` instead of `escape`:

- you don't need to recover the original string (`safe_slug` is lossy), but you do need:
- length requirements
- start/end rules
- arbitrary other validity requirements
- uniqueness

`safe_slug` takes an `is_valid` callable,
which you can use to specify whether a key passes a validity check.
If it passes, the string is returned unmodified.

The default `is_valid` callable applies a strict subset of various kubernetes rules,
so it will always return a unique string that is valid in just about any kubernetes field (object name, label values, etc.)

- min length of 1
- max length of 63
- contains only lowercase ascii letters, numbers, and '-'
- starts with a letter
- ends with a letter or number

If the input string does not pass the `is_valid` check,
it is stripped and hashed to ensure validity and uniqueness.

This does:

- cast to lowercase
- strip all non-alphanumeric characters
- if it doesn't start with a letter, prefix with `x-`
- truncate the safe subset
- append a hash of the original name, utf8-encoded, after `---`

Examples:

```python
safe_slug("valid-slug") # "valid-slug"
safe_slug("4start") # "x-4start---3a570dbd"
safe_slug("a" * 64, max_length=20) # "aaaaaaaaa---ffe054fe"
safe_slug("üñîçø∂é") # "x---4072f5a6"
```

Note: the 'safe' result is not customizable,
which means that `safe_slug` can only be used if this trim-and-hash result is valid in your scheme.