semvec/pypi-packages huggingface dataset:
lefshift 0.5.3
Predict 19F chemical shift
Requires Python: >=3.8

# Local Environment of Fluorine (LEF) Shift Prediction Tools

## Getting Started

A PyPi package is available:
```
pip install lefshift
```

You can also clone the repo manually and then install the lefshift package:
```
git clone https://github.com/PatrickPenner/lefshift.git
cd lefshift
pip install .
```
Be aware that the `data/` and `model/` directory used in the following are in
the `lefshift` repo.

Running `lefshift --help` should give you an overview of how to use the lefshift
commandline tool. You can quickly train a model using the Enamine data in `data/`
like this:
```
lefshift train data/train.csv --model models/my_model --id-column 'Catalog ID' --shift-column 'Shift 1 (ppm)' --smiles-column 'SMILES' --verbose
```
Training requires 3 columns: an ID column, a chemical shift column, and a
SMILES column. The above command gives the name of those columns explicitly.
You can also check the `lefshift train --help` output to see the default column
names that lefshift expects.

You can perform a prediction with the model you just trained with the following command:
```
lefshift predict data/test.csv --model models/my_model data/test_predicted.csv --smiles-column 'SMILES' --verbose
```
Prediction only requires a SMILES column. This is once again give explicitly,
but you can also ensure that there is an input column named "SMILES".

To split a data set into those samples in the applicability domain of the model
and those not in the applicability domain run this command:
```
lefshift split data/test.csv --model models/my_model data/test_known.csv data/test_unknown.csv --verbose
```
Splitting also only requires a SMILES column. The SMILES column in the input is
already called "SMILES" so we don't have to be explicit.

For more advanced usage please check the `--help` output of `lefshift` and the
subtools `train`, `predict`, and `split`. There is also a
`QM Assisted ML Tutorial.md` that describes a workflow to combine `lefshift`
and `lefqm`.

## Development

### Formatting pre-commit hook

Pre-commit is only used for consistent formatting. The core of that is the
black formatter and code style.

Install the formatting pre-commit hook with:
```
pre-commit install
```

### Code Quality

All quality criteria have a range of leniency.

| Criteria               | Threshold     |
| -------------          |:-------------:|
| pylint                 | \>9.0         |
| coverage (overall)     | \>90%         |
| coverage (single file) | \>80%         |

### Utility commands

Pre-commit on one file:
```
pre-commit run --files
```

Test command:

```
python -m unittest tests
```

PyLint command:

```
pylint lefshift tests > pylint.out
```

Coverage commands:
```
coverage run -m unittest tests
coverage html
```
distinguishedname 1.0.2
I parse and create RFC2253 compliant distinguished names (DNs)
Requires Python: >=3.8
Keywords: distinguishedname,dn,rdn,rfc2253,pki

# distinguishedname
Parse RFC 2253 Distinguished Names from strings and create strings from DNs (which
are implemented here as lists of RDNs - which are lists of strings in "TAG=VALUE" 
format).

# Examples
```python
>>> string_to_dn(r'CN=   James \"Bond\" +UID= 007, OU = 00 Division\, Special Services, O=MI5,C=UK')
[['CN=James "Bond"', 'UID=007'], ['OU=00 Division, Special Services'], ['O=MI5'], ['C=UK']]

>>> dn_to_string([['CN="Pinkie" Stevens', 'UID=1'], ['O= Name With Spaces ']])
'CN=\\"Pinkie\\" Stevens+UID=1,O=\\20Name With Spaces\\20'
```

# Rationale
I couldn't find any existing libraries for this.  In theory, [python-ldap][1] has a DN class that 
should be able to do this, but I've never been able to `pip install` it successfully.

This is essentially a single file, so you could also just drop this file into your project, ansible
module, CLI script or whatever.


[1]: https://www.python-ldap.org/en/python-ldap-3.4.3/ "python-ldap"
pylint-to-ruff 0.3.0
Introspect a Pylint configuration and convert it to Ruff
Requires Python: >=3.9
Keywords: lint,pylint,ruff

# pylint-to-ruff

A friend of [flake8-to-ruff](https://pypi.org/project/flake8-to-ruff/),
this project attempts to introspect your Pylint configuration and figure out
what Ruff rules to enable or disable.

## Compatibility

Ruff versions 0.1.4 (November 2023) and newer are supported.

## Usage

You need to be in an environment where both your target Pylint version and
your target Ruff version are available to execute.

Then, run the program – easiest is `pipx`:

```bash
pipx run pylint-to-ruff
```

or if you have installed the package already with Pip, simply

```bash
pylint-to-ruff
```

The tool will output a TOML segment you can paste or interpolate into your
Ruff configuration file.