semvec/pypi-packages huggingface dataset:
cronox 0.1.2
A toolkit for uncertainty quantification in causal inference.
Requires Python: >=3.8

# Cronox: Causality, Reproducibility, Uncertainty and Experimentation.

Cronox is a highly adaptable Python toolkit for uncertainty quantification in causal inference. Cronox provides a modular framework where causal approaches can be easily developed, tested and deployed by using any back-end modelling framework (Torch, TensorFlow, GPy, scikit-learn, etc.). Models developed in these frameworks can be used within the set of tools offered in Cronox, which include:

- **General causal inference approaches** like covariate adjustment methods, matching, propensity score methods, etc. as well as methods to deal with situations with unobserved confounders.
- **Mediation analysis methods** that allow to disentangle cause and effect for any type of variables in the presence of intermediate factors that regulate the effects.
- **Approaches to combine observational and interventional data.** These models can be used to either improve the estimation of causal effects or to provide external validation of effects across populations. 
- **Interpretable models**: causal inferecen is key to understand how much we can interpret machine learning models as data generators of a phisical mechanism.
- **Decision approaches**. These are methods make use of the previous models to drive experimentation and data collection.

# Contributing

This project welcomes contributions and suggestions. Most contributions require you to
agree to a Contributor License Agreement (CLA) declaring that you have the right to,
and actually do, grant us the rights to use your contribution. For details, visit
https://cla.microsoft.com.

When you submit a pull request, a CLA-bot will automatically determine whether you need
to provide a CLA and decorate the PR appropriately (e.g., label, comment). Simply follow the
instructions provided by the bot. You will only need to do this once across all repositories using our CLA.

This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/)
or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.

# Trademarks 

This project may contain trademarks or logos for projects, products, or services. Authorized use of Microsoft trademarks 
or logos is subject to and must follow [Microsoft's Trademark & Brand Guidelines](https://www.microsoft.com/en-us/legal/intellectualproperty/trademarks/usage/general). 
Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft 
sponsorship. Any use of third-party trademarks or logos are subject to those third-party's policies.
openpd 0.2.5
OpenPD, standing for Open Peptide Dynamics, is a python package for peptide dynamics simulation
Requires Python: >=3.7
Keywords: Peptide dynamics simulation package

# OpenPD: Opened Peptide Dynamics package

[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
[![Build Status](https://img.shields.io/travis/zhenyuwei99/openpd/main.svg?label=Travis%20CI)](https://travis-ci.org/zhenyuwei99/openpd)
[![codecov](https://codecov.io/gh/zhenyuwei99/openpd/branch/main/graph/badge.svg?token=2O1CV31X7S)](https://codecov.io/gh/zhenyuwei99/openpd)
[![Documentation Status](https://readthedocs.org/projects/openpd/badge/?version=latest)](https://openpd.net/en/latest/?badge=latest) 
[![PyPi Version](https://img.shields.io/pypi/v/openpd.svg)](https://pypi.org/project/openpd/) 

## Introduction

OpenPD, standing for **Open** **P**eptide **D**ynamics, is a python package, distributed freely under the terms of
GNU Public License Version 3 (GPLv3), for peptide dynamics simulation. It was designed to simulate the folding dynamics of protein efficiently with the assistance of **P**eptide **D**ynamics **F**orce **F**ield (PDFF), which is a solvent considered, high-level coarse-grained force field focusing on the peptide interaction. 

OpenPD is developed and maintained by Zhenyu Wei (zhenyuwei99@gmail.com), from Yunfei Chen's group in Southeast University. As a newly developed program, we always welcome developers to contact us.

The OpenPD distribution includes following files and folders:

|   Name    |             Description             |
| :-------: | :---------------------------------: |
|  README   |              This file              |
|  LICENSE  |             MIT License             |
|   docs    |            Documentation            |
|  openpd   | Source code of openpd python module |
| tutorials |  Folder contains tutorial notebook  |
| setup.py  |     Build script for setuptools     |

## Need help?

To get more information, please check out the project [documentation](https://openpd.net/en/latest).
TemporalBackbone 0.1.6
A tool to detect the backbone in temporal networks
Requires Python: >=3.6

# A tool to detect the backbone in temporal networks

An efficient and fast tool to detect the backbone network in temporal networks. For accurate results, it should be applied to networks with at least 1,000 nodes.

The computational time is O(N_E I_{max}^2), where N_E are the number of unique edges in the network and I_{max} the maximum number of intervals. I_{max} can be computed as T (total time steps) divided by the minimum length of the interval, \Delta I_{min}. 

For sparse networks (like most of the large networks), the computational time is O(N I_{max}^2)


How to install it 

```
pip install TemporalBackbone
```

In order to run the library, additional packages should be installed

```
pip install wget 
wget https://raw.githubusercontent.com/matnado/TemporalBackbone/main/TemporalBackbone/requirements.txt
pip install -r requirements.txt
```

This implementation assumes that packages like `copy`, `collections`, and `time` are already present, because they cannot be installed via `pip install`. 


How to run the package

```
import TemporalBackbone as TB

data = TB.Read_sample()
TB.Temporal_Backbone(data)
```

Input: 
- **df** pandas dataframe with three columns: ***node1, node2, time*** *(order is important)*
- **I_min** minimum length of the interval, written in seconds: ***default 1 day or 60x60x24 seconds** (time step is taken from the data)*
- **is_directed** whether the network is directed or not: ***default True***
- **Bonferroni** whether to use the Bonferroni correction: ***default True***
- **alpha** threshold to determine the significance of a link: ***default 0.01***
    
Output:
- list with the significant links    




### Please cite

The methodology is first introduced in 
*Nadini, M., Bongiorno, C., Rizzo, A., & Porfiri, M. (2020). **Detecting network backbones against time variations in node properties.** Nonlinear Dynamics, 99(1), 855-878.*
    
Then was deemed as appropriate for large temporal networks, having a good trade-off between false positives and false negatives. See
*Nadini, M., Rizzo, A., & Porfiri, M. (2020). **Reconstructing irreducible links in temporal networks: which tool to choose depends on the network size.** Journal of Physics: Complexity, 1(1), 015001.*
pretty-text 0.1.2
Add font and color to your Python text.
Requires Python: >=3.7,<4.0
Keywords: text

# Pretty Text 

This package enables you to print pretty text like below
![image](https://github.com/khuyentran1401/pretty-text/blob/master/pretty_hello.png?raw=True).

To install this package, use 

```bash
pip install pretty-text
```