semvec/pypi-packages huggingface dataset:
birankpy 1.0.1
Ranking nodes in bipartite networks with efficiency and flexibility
License: MIT

# BiRankpy

Bipartite (two-mode) networks are ubiquitous.
When calculating node centrality measures in bipartite networks, a common approach is to apply PageRank on the one-mode projection of the network.
However, the projection can cause information loss and distort the network topology.
For better node ranking on bipartite networks, it is preferable to use a ranking algorithm that fully accounts for the topology of both modes of the network.

We present the BiRank package, which implements bipartite ranking algorithms HITS, CoHITS, BGRM, and Birank.
BiRank provides convenience options for incorporating node-level weights into rank estimations, allowing maximum flexibility for different purpose.
It can efficiently handle networks with millions of nodes on a single midrange server.
Both R and Python versions.


# Overview

`birankpy` provides functions for estimating various rank measures of nodes in bipartite networks including HITS, CoHITS, BGRM, and Birank.
It can also project two-mode networks to one-mode, and estimat PageRank on it.
`birankpy` allows user-defined edge weights.
Implemented with sparse matrix, it's highly efficient.

### Example
Let's pretend we have a edge list `edgelist_df` containing ties between top nodes and bottom nodes:

top_node | bottom_node
------------ | -------------
1 | a
1 | b
2 | a


To performing BiRank on, just:

```python
bn = birankpy.BipartiteNetwork()

bn.set_edgelist(edgelist_df,  top_col='top_node', bottom_col='bottom_node')

top_birank_df, bottom_birank_df = bn.generate_birank()
```
ordered-demuxer 0.1.0
Break iterators into ordered chunks
License: MIT

# Ordered Demultiplexer in Python
Single pass approach to Demultiplexing/Demuxing

Break an iterator into multiple iterators based on a set of filters.

Typical demuxers will place elements into different iterators,
such as splitting [0,1,2,3] into ([0,2], [1,3]) based on odd or
even elements. Ordered Demuxers focus on breaking iterators into 
contiguous blocks that are meant to be immediately worked upon, 
without having to iterate over the list more than once. 

This makes them appropriate to use with iterators where the contents
cannot be fully held in memory, such as retrieving data online.

### Example
With any iterable input such as
```python
x = iter([ (_, 0), (_, 1), (MessageEnd, 2), (_, 3), (_, 4), (MessageEnd, 5) ])
```


This can be broken into;
```python
Iterator [
  Iterator [(_, 0), (_, 1), (MessageEnd, 2)], 
  Iterator [(_, 3), (_, 4), (MessageEnd, 5)]
]
```

Without passing over each element of data multiple times. This allows for methods like;

```python
for data_stream in demuxed_stream:
  for element in data_stream:
    function(element)
```

Or more interestingly;

```python
def foo(x: Iterator[T]):
  ...
  
for data_stream in demuxed_stream:
  foo(data_stream)
```

`foo` will consume part of the original iterator, up until the next break point, but still behave identically to passing it an iterator of just the data required.

Due to the way the filters are available within the Demuxer, it's also possible to send these partial iterators to functions according to the relevant filter, i.e.

```python
conditions = [
  FilterCondition(lambda x: x[0] == 'MessageEnd', 'SuccessfulMessageStream'),
  FilterCondition(lambda x: x[0] == 'MessageFailed', 'FailedMessageStream')
]

for data_stream in demuxed_stream:
  if demuxed_stream.condition_met is not None:
    match demuxed_stream.condition_met.name:
      case 'SuccessfulMessageStream':
        foo(data_stream)
      case 'FailedMessageStream':
        foo2(data_stream)
  else:
    foo3(data_stream)
```

Although it requires the consumption of each iterator entirely to make this possible.

## Installation
```bash
python -m pip install ordered-demuxer
```

## Usage
```python
>>> from ordered_demuxer import FilterCondition, OrderedDemuxer
>>> x = [1, 2, 3, 4]
>>> y = FilterCondition(lambda x: x == 2)
>>> splt = OrderedDemuxer(data_source=iter(x), filter=y, split_after=True)
>>> x_iter = splt.__next__()
>>> print(list(x_iter))
  [1, 2]
```
pymodaq-plugins-picoquant 0.1.0
Set of PyMoDAQ plugins for Picoquant instruments (TimeHarp260, ...)
License: MIT

pymodaq_plugins_picoquant (Picoquant)
#####################################

.. image:: https://img.shields.io/pypi/v/pymodaq_plugins_picoquant.svg
   :target: https://pypi.org/project/pymodaq_plugins_picoquant/
   :alt: Latest Version

.. image:: https://readthedocs.org/projects/pymodaq/badge/?version=latest
   :target: https://pymodaq.readthedocs.io/en/stable/?badge=latest
   :alt: Documentation Status

.. image:: https://github.com/CEMES-CNRS/pymodaq_plugins_picoquant/workflows/Upload%20Python%20Package/badge.svg
    :target: https://github.com/CEMES-CNRS/pymodaq_plugins_picoquant

PyMoDAQ plugin for Picoquant instruments (TimeHarp260, ...)


Authors
=======

* Sebastien J. Weber

Instruments
===========
Below is the list of instruments included in this plugin


Viewer1D
++++++++

* **TH260**: Timeharp TH260 for *photon counting* and *time tagging*
pymodaq-plugins-flim 0.1.0
Set of PyMoDAQ plugins for FLIM Measurements (Fluorescence Lifetime Imaging Microscopy) (using a conjugation of Time-Correlated Single Photon Counting (TSCPC) and xy stages)
License: MIT

pymodaq_plugins_flim (Fluorescence Lifetime Imaging Microscopy)
###############################################################

.. image:: https://img.shields.io/pypi/v/pymodaq_plugins_flim.svg
   :target: https://pypi.org/project/pymodaq_plugins_flim/
   :alt: Latest Version

.. image:: https://readthedocs.org/projects/pymodaq/badge/?version=latest
   :target: https://pymodaq.readthedocs.io/en/stable/?badge=latest
   :alt: Documentation Status

.. image:: https://github.com/CEMES-CNRS/pymodaq_plugins_flim/workflows/Upload%20Python%20Package/badge.svg
    :target: https://github.com/CEMES-CNRS/pymodaq_plugins_flim

Set of PyMoDAQ plugins for Fluorescence Lifetime Imaging Microscopy. Current instruments are using Picoquant time to
digital counting card and piezoconcept XY piezo stage


Authors
=======

* Sebastien J. Weber

Instruments
===========
Below is the list of instruments included in this plugin

ViewerND
++++++++

* **FLIM**: FLIM using piezoconcept XY stage and picoquant timeharp TH260"
pymodaq-plugins-femto 0.1.0
Plugin to simulate acquisition from ultrashort pulse measurement device based on the pypret package
License: MIT

pymodaq_plugins_femto (Femto Characterization)
##############################################

.. image:: https://img.shields.io/pypi/v/pymodaq_plugins_femto.svg
   :target: https://pypi.org/project/pymodaq_plugins_femto/
   :alt: Latest Version

.. image:: https://readthedocs.org/projects/pymodaq/badge/?version=latest
   :target: https://pymodaq.readthedocs.io/en/stable/?badge=latest
   :alt: Documentation Status

.. image:: https://github.com/CEMES-CNRS/pymodaq_plugins_femto/workflows/Upload%20Python%20Package/badge.svg
    :target: https://github.com/CEMES-CNRS/pymodaq_plugins_femto

Plugins wrapping the Pypret package to simulate femtosecond pulse characterization


Authors
=======

* _S. J. Weber

Instruments
===========
Below is the list of instruments included in this plugin

Viewer1D
++++++++

* **femto**: Fake detector mocking typically a spectrometer acquiring FROG traces
  (but not limited to FROG)