semvec/pypi-packages huggingface dataset:
MyPMFs-py 0.1.8
Python package for mypmfs training(includes batch download from PDB)

# MyPMFs_py

The MYPMFs_py Package allows for use of mypmfs training and scoring of the statistical potentials of proteins. Additionally, includes batch download of files from the protein data bank. 

The underlying software package was obtained from https://github.com/bibip-impmc/mypmfs. Please cite the original work (https://doi.org/10.1016/j.biochi.2018.05.013) if you use this package.

# DOWNLOADING MyPMFs_py

The MyPMFs_py package can be installed via pip. Currently only available for Linux.

# DOCUMENTATION

The MyPMFs_py package includes the following functionality

batch_download - batch download of specified, using a csv file of PDB codes, pdb files from the Protein Databank 
can be called with MyPMFs_py.module.batch_download(pdbCodeFile, outputDirPath)
- pdbCodeFile - csv file containing comma seperated PDB codes to be installed
- outputDirPath - directory name for downloaded files

training - executable binary to generate statistical potentials from set of pdb files
can be called with MyPMFs_py.module.training(pdbCodeFile, pdbDirPath, outputDirPath)
- pdbCodeFile - txt files of tab seperated PDB codes to be trained on
- pdbDirPath - path to directory containing PDB files of codes in pdbCodeFile
- outputDirPath - path for output directory of training

scoring - executable binary to generate pseudo-energy of specificed protein based off a pre-generated (using training) set of statistical potenitals 
can be called with MyPMFs_py.module.scoring(pdbFile, potentialsDir)
- pdbFile - specific pdb file to be scored
- potentialsDir - directory containing trained potentials used to score the protein described in pdbFile

# SOURCE CODE

Source Repository: https://github.com/alexhold5/MyPMFs_pypipackage_recipe

# LICENSE

This code is available under the GNU General Public License (see LICENSE.TXT)
analytical-tools 0.1.0
A package to help data analysts at cotidian tasks, mainly EDA and ETL tasks
Requires Python: >=3.6

# analytical_tools

A package to help data analysts at cotidian tasks, mainly EDA and ETL tasks. Example of functions: WoE, IV, heatmap, histogram, feature importances, bivariate analysis, etc...

## Installation

```bash
pip install analytical_tools
identity-containers 1.0.2
Dicts and Sets that hash items based on identity instead of value
Requires Python: >=3.9

## Introduction

This module implements dicts and sets that compare items based on identity rather than value. This
allows them to store unhashable objects.

Usage example:

```python
from identity_containers import IdentitySet

foo = []
bar = []

id_set = IdentitySet([foo])

print(foo in id_set)  # True
print(bar in id_set)  # False
```

The following classes exist:

-   `IdentitySet`
-   `IdentityDict`
-   `IdentityDefaultDict`
pylint-google-style-guide-imports-enforcing 1.3.1
Plugin for PyLint that checks if we import only modules or packages. Direct imports of classes, functions and constants are forbidden
Keywords: pylint, google style guide, imports

How it works?
===============
It marks importing anything but modules/packages as invalid with a message `only-importing-modules-is-allowed`. This adheres to Google's Python style guide.

An example::

    from functools import partial  # invalid
    import functools  # valid
    from some_module.some_subomdule import SomeClass  # invalid
    from some_module import some_subomdule  # valid

Why?
===============
To not force people to manual check if something we imported is a module or not.

How to use it?
===============
After installing a package just run `pylint`, appending `pylint_google_style_guide_imports_enforcing` to your `--load-plugins` option.

An example::

    pylint my_cool_project --load-plugins=pylint_google_style_guide_imports_enforcing

or append it to your `pylintrc` file::

    [MASTER]
    load-plugins=pylint_google_style_guide_imports_enforcing
iqrm 0.2.0
A minimal implementation of the IQRM interference flagging algorithm
Requires Python: >=3.8

# IQRM

[![arXiv](http://img.shields.io/badge/astro.ph-2108.12434-B31B1B.svg)](https://arxiv.org/abs/2108.12434)   ![License](https://img.shields.io/badge/License-MIT-green.svg)   ![CI status](https://github.com/v-morello/iqrm/actions/workflows/CI.yml/badge.svg?branch=master)   [![codecov](https://codecov.io/gh/v-morello/iqrm/branch/master/graph/badge.svg)](https://codecov.io/gh/v-morello/iqrm)

A minimal implementation of the IQRM interference flagging algorithm for radio pulsar and transient searches. This module only provides the algorithm that infers a channel mask from some spectral statistic that measures the level of RFI contamination in a time-frequency data block. It should be useful as a reference implementation to developers who wish to integrate IQRM into an existing pipeline / search code.

**However, if you wish to clean existing SIGPROC files using IQRM, please use Kaustubh Rajwade's full implementation:**  
https://gitlab.com/kmrajwade/iqrm_apollo


## Citation

If IQRM contributes to a scientific publication, please cite the article (link will be provided soon):  
[IQRM: real-time adaptive RFI masking for radio transient and pulsar searches](https://arxiv.org/abs/2108.12434)

## Installation

The easiest method is to use pip install, which also pulls required dependencies:
```
pip install iqrm
```

Alternatively you can clone the repository and run `make install`:
```
git clone https://github.com/v-morello/iqrm
cd iqrm
make install
```

This simply runs `pip install` in [editable mode](https://pip.pypa.io/en/latest/cli/pip_install/#editable-installs), which means you can freely edit the code. It also installs any required dependencies with pip that are not present already.

## Usage

The module provides a single function: `iqrm_mask`, that operates on an array that contains a spectral statistic that captures the level of RFI contamination in each frequency channel of a search-mode data block. Here is a basic example on an artificially generated time-frequency data block:


```python
import numpy as np
from iqrm import iqrm_mask

### Generate a time-frequency block containing Gaussian noise
nsamp = 1024
nchan = 10
data = np.random.normal(size=nsamp*nchan).reshape(nsamp, nchan)

# Add simulated RFI to channels indices 5 and 6
data[:, 5] += 5 * np.sin(np.arange(nsamp))
data[:, 6] += 10 * np.sin(np.arange(nsamp))

# Use per-channel standard deviation as contamination measure
spectral_std = data.std(axis=0)

### Run IQRM
mask, votes = iqrm_mask(spectral_std, radius=2)

# 'mask' is a boolean mask where 'True' denotes a channel index deemed to be contaminated
print(np.where(mask)[0])
# Output:
# [5 6]

# 'votes' is a dictionary of sets; see section 2 of the paper for an explanation of the 'voting' system
for caster in sorted(votes.keys()):
    recipients = votes[caster]
    print(caster, recipients)
# Output:
# 3 {5}
# 4 {5, 6}
# 5 {6}
# 7 {5, 6}
# 8 {6}

# For example '7 {5, 6}' means that from the point of view of channel 7, channels 5 and 6 have an abnormally high level of RFI contamination.
```