semvec/pypi-packages huggingface dataset:
juzi 0.1.3
juzi
Requires Python: >=3.11

# :tangerine: juzi

Various methods for analyzing cancer cell states and types using single-cell sequencing data (experimental).

- [Installation](#installation)
- [Usage](#usage)
  - [cell states (`cs`)](#cell-states-cs)
  - [marker genes (`mg`)](#marker-genes-mg)

## Installation

```bash
pip install juzi
```

## Usage

### cell states (`cs`)

Identification of recurrent gene programs across multiple cancer samples (inspired by [Gavish et al. 2023](https://www.nature.com/articles/s41586-023-06130-4)).

```python
import juzi as jz

# Perform NMF across each unique sample at multiple factor resolutions
subset = jz.cs.nmf(
    adata,
    key="sample_id",
    layer="counts",
    genes="highly_variable",
    min_cells=100,
    k=[7, 8, 9, 10],
    max_iter=1000,
    n_jobs=8,
    seed=123
)

# Prune recurrent intra-sample factors based on overlapping top genes
jz.cs.prune(
    subset,
    top_k=50,
    min_similarity=0.7,
    min_k=1,
    n_jobs=1
)

# Compute inter-sample similarity matrix between factors
jz.cs.similarity(
    subset,
    distance="jaccard",
    top_k=50,
    intra_sample=True,
    drop_zeros=True,
    min_similarity=0.2,
    n_jobs=8,
    prefer="threads"
)

# Cluster factor similarity matrix by iterative merging
jz.cs.cluster(
    subset,
    threshold=0.1,
    min_cluster=5
)

# Plot clustered factor similarity matrix (i.e. gene programs)
jz.cs.plot_programs(
    subset,
    vmin=0.,
    vmax=1.,
    figsize=(5., 5.),
    cbar_label="Similarity"
)
```

### marker genes (`mg`)

Various marker genes for cell types, subtypes, and pathways.

```python
from juzi.mg import available_sets

# Check available marker gene sets
print(available_sets())

# Load breast cancer gene sets (e.g. PAM50)
from juzi.mg import CancerBreast
markers = CancerBreast()

# Load cancer pathway gene sets (e.g. HIPPO)
from juzi.mg import CancerPathways
markers = CancerPathways()

# Load cell cycle gene sets (e.g. G1S)
from juzi.mg import CellCycle
markers = CellCycle()

# List available sets in a given marker class
markers.info()

# Get all genes from all sets in a flattened list
markers.all()
```
esp-idf-diag 0.2.0
Diagnostic tool for ESP-IDF
Requires Python: >=3.7
Keywords: espressif, embedded, diagnostic, bug, report

# ESP-IDF Diag Tool (**esp-idf-diag**)

The esp-idf-diag tool gathers information about the ESP-IDF environment, the
system information, and the ESP-IDF project into a report directory to help
with troubleshooting problems.

## Installation

You can install the esp-idf-diag tool from the Python Package Index (PyPI) using:

    $ pip install esp-idf-diag

## Creating report directory

In an activated ESP-IDF environment, execute the following in your ESP-IDF project:

    $ esp-idf-diag create

By default, this will create a report directory named `diag-UUID`, where `UUID`
is a randomly generated Universally Unique Identifier. For example
`diag-5aaa949b-40dc-4d53-96f1-1280c801585a`. You can change the output
directory using the `--output` option. This directory will contain files that
were collected and generated by esp-idf-diag. You can review the contents and
add or remove files as necessary.

## Creating a zipped archive of the report directory

Once the report directory is prepared, it can be compressed into a zip archive with:

    $ esp-idf-diag zip diag-5aaa949b-40dc-4d53-96f1-1280c801585a

Please be aware that the report directory name is taken from the create example
mentioned earlier. This name will vary with each create run unless the
`--output` option is specified.

The zip archive can be attached to a GitHub issue to provide more context for a
problem you are experiencing.

## Recipes

The data collected by esp-idf-diag is managed through recipes, which are
straightforward YAML files containing commands whose outputs are saved in the
report directory. For further details, please refer to the [Recipe format
description](esp_idf_diag/data/recipes/README.md).


## Redacting sensitive data

When a report directory is created, its contents are scanned for sensitive
information, such as passwords or tokens in URLs. This process is guided by a
purge file, in YAML format, that specifies which matching regular expressions
should be replaced. For further details, refer to the [Purge format
description](esp_idf_diag/data/purge/README.md). A default purge file is
available, but you can provide a custom one using the `--purge` option. It is
recommended to review the generated report directory for sensitive data before
sharing it.
torch-secorder 0.0.1
A PyTorch library for second-order optimization and analysis
Requires Python: >=3.11

# torch-secorder

A PyTorch-native library for efficient second-order computations in deep neural networks.

## Overview

Torch-Secorder provides efficient implementations of second-order optimization utilities for PyTorch, including:

- Hessian-Vector Products (HVP)
- Jacobian-Vector Products (JVP)
- Vector-Jacobian Products (VJP)
- Gauss-Newton matrix computations
- Hessian trace estimation

These tools are essential for:
- Second-order optimization methods
- Natural gradient descent
- Curvature-based regularization
- Neural network analysis and debugging

## Features

- **Hessian-Vector Products (HVP)**
  - Computation of Hv for any vector v
  - Trace estimation using Hutchinson's method
  - Support for distributed computation
  - Automatic parameter handling

- **Hessian Diagonal**
  - Computation of Hessian diagonal elements
  - Trace estimation using diagonal elements
  - Support for custom vectors
  - Gradient requirement validation

- **Trace Estimation**
  - HVP-based: Uses Hutchinson's method with random vectors
  - Diagonal-based: Uses exact diagonal elements
  - Both methods compute the same quantity
  - Choose based on model size and accuracy requirements

- **Model Integration**
  - PyTorch model integration
  - Parameter management
  - Loss function support
  - Model-specific computations

## Installation

```bash
pip install torch-secorder
```

Or install from source:
```bash
git clone https://github.com/pybrainn/torch-secorder.git
cd torch-secorder
pip install -e .
```

## Quick Start

See our [documentation](https://torch-secorder.readthedocs.io/) for detailed examples and tutorials.

## Documentation

- [API Reference](https://torch-secorder.readthedocs.io/en/latest/api/core.html)
- [Examples](https://torch-secorder.readthedocs.io/en/latest/examples.html)

## Contributing

We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.

## License

This project is licensed under the Apache 2.0 License - see the [LICENSE](LICENSE) file for details.

## Citation

If you use this library in your research, please cite:

```bibtex
@software{torch_secorder2025,
  author = PyBrainn,
  title = {Torch-Secorder: Second-Order Optimization for PyTorch},
  year = {2025},
  publisher = {GitHub},
  url = {https://github.com/pybrainn/torch-secorder}
}
```
jaxrwkvkernel 0.0.0
RWKV Kernels for JAX
Requires Python: >=3.10

# RWKV Kernels in Jax

This repo contains cuda kernels for jaxrwkv. See the [main project](https://github.com/bsarkar321/jaxrwkv) for more details.

## Install Instructions

Use pip to install this package.
``` bash
  pip install -v .
```
painless-timeit-6ninjak 0.0.1
A timeit decorator with built-in split functionality for Python
Requires Python: >=3.9

# painless-timeit
A timeit decorator for Python functions that allows for splits measurements inside of the function without the hustles of modifying too much code after performance analysis

# Usage
Apply `@painless_timeit` decorator to your function and it will be timed as usual, printing the measured time at the end of its execution.
If you want to also measure timesplits inside your function you can add the comment `#|> [split_name]` before the code block you want to time and `#|| [split_name]` after.
The wrapper function keeps a record of each split with its current measured time, meaning that multiple references to the same split will accumulate.
You can also pause time measurements for the function by commenting `#||` and resume it with `#|>`.
The wrapper function will replace the lines with these kind of comments with the needed code, so be sure to place these comments in dedicated lines, or else you may not execute important pieces of code.

Here's an example of a decorated function and its execution:
```python
from painless_timeit import painless_timeit

@painless_timeit
def my_function():
    #|> split1
    time.sleep(2) # code in this block will be measured as split1
    #|| split1
    #|> split2
    time.sleep(0.5) # code in this block will be measured as split2
    #|| split2
    #||
    time.sleep(10) # code in this block won't be measured
    #|>
    time.sleep(1) # code in this block will be measured as the main function
```
Output:
```python
>>> my_function()
[my_function->split1]: Took 2.0000 seconds up until now
[my_function->split2]: Took 0.5000 seconds up until now
[my_function]: Took 3.5000 seconds
```


### Note
The choice for the symbols used for the signal comments will be clear if you use Fira Code font with ligatures
painless-timeit 0.0.1
A timeit decorator with built-in split functionality for Python
Requires Python: >=3.9

# painless-timeit
A timeit decorator for Python functions that allows for splits measurements inside of the function without the hustles of modifying too much code after performance analysis

# Usage
Apply `@painless_timeit` decorator to your function and it will be timed as usual, printing the measured time at the end of its execution.
If you want to also measure timesplits inside your function you can add the comment `#|> [split_name]` before the code block you want to time and `#|| [split_name]` after.
The wrapper function keeps a record of each split with its current measured time, meaning that multiple references to the same split will accumulate.
You can also pause time measurements for the function by commenting `#||` and resume it with `#|>`.
The wrapper function will replace the lines with these kind of comments with the needed code, so be sure to place these comments in dedicated lines, or else you may not execute important pieces of code.

Here's an example of a decorated function and its execution:
```python
from painless_timeit import painless_timeit

@painless_timeit
def my_function():
    #|> split1
    time.sleep(2) # code in this block will be measured as split1
    #|| split1
    #|> split2
    time.sleep(0.5) # code in this block will be measured as split2
    #|| split2
    #||
    time.sleep(10) # code in this block won't be measured
    #|>
    time.sleep(1) # code in this block will be measured as the main function
```
Output:
```python
>>> my_function()
[my_function->split1]: Took 2.0000 seconds up until now
[my_function->split2]: Took 0.5000 seconds up until now
[my_function]: Took 3.5000 seconds
```


### Note
The choice for the symbols used for the signal comments will be clear if you use Fira Code font with ligatures
textminer-pro-jihoonLee 0.1.0
A simple text mining package with stopword removal, keyword extraction, summarization, and language detection.
Requires Python: >=3.7

# textminer-pro

텍스트 전처리, 키워드 추출, 요약, 언어 감지를 제공하는 Python 패키지입니다.

## 설치 (TestPyPI 기준)

```bash
pip install -i https://test.pypi.org/simple/ textminer-pro