semvec/pypi-packages huggingface dataset:
pyCausalFS 0.23
Fork of pyCausalFS - implementation of local structure learning algorithms
Requires Python: >=3.6

﻿# pyCausalFS：A Python Library of Causality-based Feature Selection for Causal Structure Learning and Classification

## Overview

This is a fork of pyCausalFS that removes example files and data to allow for easier integration as a python module. The original repository can be found here: https://github.com/wt-hu/pyCausalFS. This fork may have tweaks to make it easier to pip install.
You can install this via pypi:

    pip install pyCausalFS

The pyCausalFS library provides access to a wide range of well-established and state-of-the-art causality-based feature selection approaches. The library is designed to facilitate the development of new algorithms in this research area and make it easier to compare new methods and existing ones available.  
  	
The pyCausalFS library implements 30 representative causality-based feature selection methods. Specifically, it consists of 25 methods using conditional independence tests (16 single MB learning algorithms, 3 multiple MB learning algorithms, and 6 PC learning algorithms), and 5 score-based approaches. 
  
1）	Constraint-based MB learning methods:

	GSMB, IAMB, IAMBnPC, Inter-IAMB, Fast-IAMB, Inter-IAMBnPC, LRH, BAMB, FBEDk, MMMB, PCMB, HITON-MB,
	Semi-HITON-MB, IPCMB, STMB, MBOR

2）	Multiple MB learning methods:

	KIAMB, TIE*(TIE and TIE_p)

3）	Constraint-based PC learning methods:

	PC-simple, MBtoPC, HITON-PC, Semi-HITON-PC, GetPC, MMPC

4）	score-based MB learning methods:

	SLL, S^2TMB, S^2TMB_p

5）	score-based PC learning methods:

	SLL-PC, S^2TMB-PC

Furthermore, using the pyCausalFS library, users can easily generate different local structure learning methods and local-to-global structure learning methods, which includes 3 local BN structure learning algorithms and three local-to-global BN learning algorithms.

6）	local BN structure learning algorithms:

	PCD-by-PCD, MB-by-MB, CMB

7）	local-to-global BN learning algorithms:

	MMHC, GSBN, MBGSL
    
All implementation details please read the manual documentation.
cmakeutils 1.9.2
Helper functions with CMake
Requires Python: >=3.7
Keywords: CMake

# CMake Utils

[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.1488084.svg)](https://doi.org/10.5281/zenodo.1488084)
[![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/scivision/cmakeutils.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/scivision/cmakeutils/context:python)
[![PyPi versions](https://img.shields.io/pypi/pyversions/cmakeutils.svg)](https://pypi.python.org/pypi/cmakeutils)
[![PyPi Download stats](http://pepy.tech/badge/cmakeutils)](http://pepy.tech/project/cmakeutils)

![Actions Status](https://github.com/scivision/cmakeutils/workflows/ci/badge.svg)

CMake is a powerful and easy to use build system for a wide variety of languages including:

* C / C++
* modern object-oriented Fortran 2008 / 2018
* Python
* pMatlab / GNU Octave](https://github.com/scivision/matlab-cmake-mex)

It's important to use a recent CMake version to be effective and clean with CMake script.
This can be done via the Python package described below, or from CMake >= 2.8.12 by:

```sh
cmake -P install_cmake.cmake
```

if you need to compile CMake from source, for example on BSD or ARM 32-bit using existing CMake >= 3.13:

```sh
cmake -P build_cmake.cmake
```

## Install

```sh
pip install cmakeutils
```

or

```sh
git clone https://github.com/scivision/cmakeutils
pip install -e cmakeutils
```

## convert CMake hierarchy .dot to SVG or PNG

CMake plots
[dependency graphs](https://www.scivision.dev/fortran-dependency-graph)
for programs like:

```sh
cmake -B build --graphviz=gfx/block.dot
```

Then convert to PNG or SVG like:

```sh
python -m cmakeutils.graph ~/myprog/gfx
```

## Install CMake binary

```sh
python -m cmakeutils.cmake_setup
```

takes only a minute to install binary and includes `cmake-gui`.
It works for Linux, MacOS, native Windows and Windows Subsystem for Linux.

Ninja is recommended in general for use with CMake on Windows, Mac and Linux:

```sh
python -m cmakeutils.ninja_setup
```

## Build CMake

CMake can be builts from source using either:

* older version of CMake,
* without CMake using the "bootstrap" method

The bootstrap method is only for Unix-like systems, while the CMake-based build can also be used on Windows.
Any platform for which Kitware doesn't distribute binaries use this script, including IBM Power and ARM.

```sh
python -m cmakeutils.cmake_compile
```

This downloads the latest CMake release source and builds from scratch.

Requirements:

* SSL library
* C++ compiler
* GNU Make or Ninja

## Examples

* Download with [git](./fetchgit) using [FetchContent](https://cmake.org/cmake/help/latest/module/FetchContent.html)
* Download and extract [ZIP](./zip)
* measure [system](./system) parameters with CMake. Note Cygwin reports really small RAM and zero virtual memory.
ucaller 0.0.2
Library for using service https://ucaller.ru/doc
Requires Python: >=3.7

# ucaller

# Установка

pip install ucaller

# Использование

from ucaller_package.ucaller import UCaller

SERVICE_ID = ''
KEY = ''
uc = UCaller(service_id=SERVICE_ID, key=KEY)

# Первый звонок
init_call = uc.init_call(phone_number=79999999999)

# Повторный бесплатный звонок
repeat_free_call = uc.init_repeat(uid=init_call.get('ucaller_id'))

# Баланс
balance = uc.get_balance()

# Информация о звонке
info = uc.get_info(uid=init_call.get('ucaller_id')
oppai-ng 0.2.2
Fast bindings for oppai-ng in Python

difficulty and pp calculator for osu!, with some modifications for [gulag](https://github.com/cmyui/gulag) (mostly relax support)

this is a wrapper around the actual oppai-ng implementation you can view [here](https://github.com/Francesco149/oppai-ng)

to build, all you have to do is run `./build`

and then move the pyd/so file (OS-dependent) file to wherever you would like to import from.

example usage:

```py
import oppai

with oppai.OppaiWrapper() as ezpp: # has __enter__ and __exit__ to manage c memory for you
  ezpp.configure(mode=0, acc=99.5, mods=0, combo=100, nmiss=2) # positional is optional, but must be provided in this order if not
  ezpp.calculate("example map path.osu") # you can also pass bytes to ezpp.calculate_data(bytes)
  
  pp = ezpp.get_pp()
  sr = ezpp.get_sr()
```