semvec/pypi-packages huggingface dataset:
flopsearch 0.2.2
Python package providing an implementation of the FLOP causal discovery algorithm for linear additive noise models
Requires Python: >=3.8
Keywords: causal discovery, DAGs, Bayesian networks, structure learning

# flopsearch

Python package providing an implementation of the [FLOP causal discovery algorithm](https://arxiv.org/abs/2510.04970) for linear additive noise models.

## Installation
flopsearch can be installed via pip:

```bash
pip install flopsearch
```

## Citing FLOP
If you use FLOP in your scientific work, please cite this paper:
```bibtex
@article{embracing2025,
  author  = {Marcel Wien{\"o}bst and Leonard Henckel and Sebastian Weichwald},
  title   = {{Embracing Discrete Search: A Reasonable Approach to Causal Structure Learning}},
  journal = {{arXiv preprint arXiv:2510.04970}},
  year    = {2025}
}
```

## Example
A simple example run of the FLOP algorithm provided by flopsearch.

``` py
import flopsearch
import numpy as np
from scipy import linalg

p = 10
W = np.diag(np.ones(p - 1), 1)
X = np.random.randn(10000, p).dot(linalg.inv(np.eye(p) - W))
X_std = (X - np.mean(X, axis=0)) / np.std(X, axis=0)
flopsearch.flop(X_std, 2.0, restarts=50)
```

## Input and Output
As input, FLOP takes the data matrix, the BIC penalty parameter (we recommend ```2.0``` as a default choice) and either a ```timeout``` (in seconds) or the number of ILS restarts to control how long the search runs.

The output of FLOP is a CPDAG encoded with an adjacency matrix whose entry in row i and column j is 1 in case of a directed edge from the i-th to the j-th variable and 2 in case of an undirected edge between those variables (in case of an undirected edge, the entry in row j and column i is also 2, that is each undirected edge induces two 2's in the matrix).
sksparse-minimal 0.3
A drop in replacement for sksparse for sparse Cholseky factorization
Requires Python: >=3.9
Keywords: cholesky, sksparse

# sksparse_minimal

This project is forked from https://github.com/rgl-epfl/cholespy

Changes made:

- Add support for all solving modes (CHOLMOD_A, CHOLMOD_L, CHOLMOD_Lt, CHOLMOD_P, etc)
- Remove support for GPU solving (because I didn't want to bother implementing it for all modes and I didn't need it)
- Emulate sksparse API for ease of use
- Change CHOLMOD configuration to match sksparse
- Update build to match recommendations from https://nanobind.readthedocs.io/en/latest/building.html

# Installing

## With PyPI (recommended)

```bash
pip install sksparse_minimal
```

## From source

```bash
git clone --recursive https://github.com/tansey-lab/sksparse_minimal.git
pip install .
```

# Example usage

```python
import numpy as np
from sksparse_minimal import SparseCholesky
from scipy.sparse import csc_matrix

M = np.array([[4, 12, -16],
           [12, 37, -43],
           [-16, -43, 98]], dtype=np.float64)

M = csc_matrix(M)

sparse_cholesky = SparseCholesky(M)

b = np.array([1, 2, 3], dtype=np.float64)

sparse_cholesky.solve_A(b)
```
knot-floer-homology 1.2.2
Python wrapper for Zoltán Szabó's HFK Calculator
Requires Python: >=3.8

Knot Floer Homology
===================

Python wrapper for Zoltán Szabó's `HFK Calculator`_.

Installing
----------

To install and test, do the following to install the current release
from `PyPI`_::

  python3 -m pip install knot_floer_homology
  python3 -m knot_floer_homology.test

You should see a result such as ``TestResults(failed=0, attempted=24)``.

Usage
-----

In Python, do::

  >>> import knot_floer_homology
  >>> PD = [(2,0,3,15),(0,6,1,5),(6,2,7,1),(3,10,4,11),(9,4,10,5),(7,12,8,13),(13,8,14,9),(11,14,12,15)]
  >>> knot_floer_homology.pd_to_hfk(PD)
  {'L_space_knot': False,
   'epsilon': 0,
   'fibered': True,
   'modulus': 2,
   'nu': 0,
   'ranks': {(-2, -2): 1, (-1, -1): 2, (0, 0): 3, (1, 1): 2, (2, 2): 1},
   'seifert_genus': 2,
   'tau': 0,
   'total_rank': 9}

It also accepts `Spherogram`_ knots as input::

  >>> import spherogram
  >>> L = spherogram.Link('K10n10')
  >>> ans = knot_floer_homology.pd_to_hfk(L)
  >>> ans['seifert_genus']
  3

It can also return the simplified UV = 0 knot Floer chain complex,
do::

  >>> help(knot_floer_homology.pd_to_hfk)

for details.



License
-------

Copyright Zoltán Szabó, Marc Culler, Nathan M. Dunfield, and Matthias
Goerner, 2017-present.  This code is released under the `GNU General
Public License, version 2`_ or (at your option) any later version as
published by the Free Software Foundation.

.. _HFK Calculator: https://web.math.princeton.edu/~szabo/HFKcalc.html
.. _PyPI: https://pypi.org
.. _Spherogram: https://github.com/3-manifolds/Spherogram
.. _GNU General Public License, version 2: https://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
low-index 1.2.1
Enumerates low index subgroups of a finitely presented group
Requires Python: >=3.8

Low Index Subgroups
===================

The low_index project provides a Python module which implements a variant
of Charles Sims' Low Index Subgroups algorithm for enumerating all of
the conjugacy classes of subgroups of a finitely presented group with
finite index less than a given bound.

The package is available on pypi, so the simplest way to install it for
Python versions 3.6 - 3.11 is to use pip:

.. code-block:: bash

    pip3 install low-index

Here is a sample computation:

.. code-block:: python

    >>> from low_index import *
    >>>  # Conjugacy classes of subgroups of F_3 with index at most 4: 
    >>> reps = permutation_reps(rank = 3, short_relators = [], long_relators = [], max_degree = 4)
    >>> len(reps)
    653
    >>> from snappy import *
    >>> G = Manifold('K11n34').fundamental_group(); G
    Generators:
       a,b,c
    Relators:
       aaBcbbcAc
       aacAbCBBaCAAbbcBc
    >>> # Degree at most 7 covers of the exterior of the Conway knot:
    >>> reps = permutation_reps(G.num_generators(), G.relators()[:1], G.relators()[1:], 7)
    >>> len(reps)
    52
    >>> reps[25]
    [[1, 0, 3, 2, 5, 6, 4], [1, 4, 0, 6, 2, 5, 3], [3, 0, 2, 6, 4, 1, 5]]


Credits
=======

Primarily developed by `Marc Culler <https://marc-culler.info>`_,
`Nathan Dunfield <http://dunfield.info>`_, and `Matthias Goerner
<http://www.unhyperbolic.org/>`_

License
=======

Copyright 2022 by Marc Culler, Nathan Dunfield, Matthias Goerner
and others.

This code is released under the `GNU General Public License, version 2
<http://www.gnu.org/licenses/gpl-2.0.txt>`_ or (at your option) any
later version as published by the Free Software Foundation.
grahana 0.2.0
Classify exoplanet candidates vs false positives from planetary features
Requires Python: >=3.9

# grahana

`grahana` is a Python package for classifying exoplanet candidates using a pre-trained Keras model. It takes planetary features as input and predicts whether an object is a "candidate" exoplanet or a "false_positive".

## Installation

Run the following command in the root of the project:

```bash
pip install grahana
```

## Usage

You can use the `predict` function to get a classification label or raw probabilities.

### Basic Usage (Get Label)

```python
from grahana import predict

label = predict(
    orbital_period_days=3.52,
    transit_depth_ppm=1500,
    transit_duration_hours=2.5,
    snr=12.0,
    insolation_flux=1.3,
)
print(label)  # Output: "false_positive" or "candidate"
```

### Advanced Usage (Get Probabilities)

```python
from grahana import predict

probs = predict(
    3.52, 1500, 2.5, 12.0, 1.3,
    return_label=False,
)
print(probs)  # Output: e.g. [0.85, 0.15]
```
woodlark 0.1.7
Woodlark runtime adapters
Requires Python: >=3.11
Keywords: codegen, database, postgresql, sql, type-safe

# woodlark

[![PyPI - Version](https://img.shields.io/pypi/v/woodlark.svg)](https://pypi.org/project/woodlark)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/woodlark.svg)](https://pypi.org/project/woodlark)

Woodlark runtime adapters.

## Installation

```console
pip install woodlark
```

## Usage

```python
from woodlark.adapters.psycopg import PsycopgAdapter, PsycopgAsyncAdapter
from generated.queries import GetUser, GetUserParams, CountUsers

def get_user(adapter: PsycopgAdapter, user_id: int) -> GetUserRow:
    return adapter.execute(GetUser, GetUserParams(id=user_id))

async def count_users(adapter: PsycopgAsyncAdapter) -> int:
    return await adapter.execute(CountUsers)
```

## License

`woodlark` is distributed under the terms of the [Apache-2.0](https://spdx.org/licenses/Apache-2.0.html) license.