semvec/pypi-packages huggingface dataset:
shopen 0.2.2
Proper implementation of os.startfile to launch a target file/URL
Requires Python: >=3.8
Keywords: os

# shopen

shopen is a proper implementation of os.startfile to launch a target file/URL. Use it to launch the
preferred system viewer for the user to view or edit a target file or URL.

"shopen" is short for `shutil.open`, the [proposed builtin](
https://github.com/python/cpython/issues/47427) it's intended to be a reference implementation for.

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

-----

## Usage

Simply install as a dependency of your project and then use it to launch an opener for a file or
URL:

```python
import pathlib, shopen
shopen.open("https://zombo.com/")  # Opens web browser
shopen.open(pathlib.Path("~/somefile.txt").expanduser())  # Opens file viewer
shopen.open(pathlib.Path("./somefile.toml"), "edit")  # Opens editor
```

## Why?

Python's standard library provides nice cross-platform utilites for lots of different purposes, but
so far no simple file/URL opener that would work on all platforms.

On Windows there's [os.startfile], but strangely that doesn't support any other platform.

The proposal [python/cpython#47427](https://github.com/python/cpython/issues/47427) to implement it
as `shutil.open` was rejected for now. Python users keep [asking](
https://stackoverflow.com/questions/434597/open-document-with-default-os-application-in-python-both-in-windows-and-mac-os)
for a decent way to do it, but the only answer had been brittle copypasta… until now!

Ideally this can be added into stdlib after proving its usefulness and then only be needed as a
polyfill for older versions of python.

[os.startfile]: https://docs.python.org/3/library/os.html#os.startfile
dtne 0.5.1
Implementation of diffusive topology neighbor embedding
Requires Python: >=3.6

# DTNE - Diffusive Topology Neighbor Embedding

DTNE (Diffusive Topology Neighbor Embedding) is a Python tool that implements a novel manifold learning framework. By leveraging a diffusive process, DTNE constructs a manifold distance matrix, enabling key analyses such as dimensionality reduction, pseudotime ordering, and cluster identification, providing valuable insights into complex datasets.

## Features

* **Dimensionality Reduction**: By preserving manifold geodesic distances, DTNE provides accurate low-dimensional projections of high-dimensional single-cell data.
* **Pseudotime Inference**: Infer developmental trajectories by leveraging the manifold distance matrix, improving the identification of lineage progression.
* **Clustering**: DTNE enables clustering by utilizing the manifold distance matrix, which captures both local and global data structures.

## Installation

install the package DTNE by running the following command in the terminal: `pip install .`

## Quick Start

DTNE requires input data in the form of a high-dimensional matrix. Suppose you have loaded a single-cell data `X` in Python.

1. Dimensionality Reduction

    DTNE can be used for dimensionality reduction:
    ```
    from dtne import *
    dtne_operator = DTNE(k_neighbors = 10,l=2) 
    Y = dtne_operator.fit_transform(X)
    ```
2. Pseudotime Inference

    DTNE allows for pseudotime inference to analyze cell development trajectories:
    ```
    dtne_pseudotime = dtne_operator.order_cells(root_cells=[0])
    ```
3. Clustering
    DTNE supports clustering based on the computed manifold distances:
    ```
    dtne_cluster = dtne_operator.cluster_cells(n_clusters=8)
    ```

## Tutorial and Example Notebooks
Several example Jupyter notebooks are provided in the `notebooks/` directory, demonstrating DTNE’s usage on various single-cell datasets.

## Citation
If you use DTNE in your research, please cite the paper.

## License
DTNE is licensed under the MIT License.
filecrusher 0.2.5
Compresses PDFs with PNG compression.
Requires Python: <4,>=3.6
Keywords: compression pdf png GoodNotes file crusher crunch compress size limit

# File Crusher
Compresses PDFs with PNG compression.

Tired of bumping against upload size limits? This tool is perfect to compress PDFs and PNGs by combining some of the best compression tools in one.
While it can be slow, it really crushes your filesize and helps you to conquer the relentless 5MB upload limit.

It works by splitting up a PDF into PNGs and compress these with advpng, pngcrush and pngquant. Then it combines them back into a PDF and applies a round of lossless pdf compression. Optionally it can apply OCR - Optical Character Recognition to make a scanned PDF searchable.
Additionally, it exposes internal processors enabling you to use it as png compressor and file converter.

## Installation

### 1. Install the python library

```bash
pip install file-crusher
```

### 2. Install the Compression Tools

#### windows
already pre-installed in compressor_lib directory

#### Linux(ubuntu)

```bash
sudo apt install pngquant -y && sudo apt install advancecomp -y && sudo apt install pngcrush -y
```
and install wine for cpdfsqueeze
```bash
apt install wine -y
```

### 3. optionally Install pytesseract for OCR

#### For Windows via GUI
Download and Install [Tesseract](https://github.com/UB-Mannheim/tesseract/wiki)
Select Additional Languages that you want. (f.e German under Additional Language Data)

#### Linux
```bash
apt install tesseract-ocr
```

add additional language packs
```bash
apt install tesseract-ocr-<language-shortform> -y
```

example for german
```bash
apt install tesseract-ocr-deu -y
```

## Usage

### CLI Usage
```bash
# for pdfs
python3 -m file_crusher input.pdf output.pdf --pdfcompressor
# or for pngs
python3 -m file_crusher input.png output.png --pngcompressor
# for other processors see
python3 -m file_crusher --help
```

### Python Usage
```python3
from file_crusher import PNGCompressor, PDFCompressor

compressor = PNGCompressor()
compressor.process_file("input.png", "output.png")

# extreme mode
compressor = PNGCompressor(0)
compressor.process_file("input.png", "output.png")

# fast mode
compressor = PNGCompressor(5)
compressor.process_file("input.png", "output.png")

# also check the other options
compressor = PDFCompressor(default_pdf_dpi=200)
compressor.process_file("input.pdf", "output.pdf")
```

## Disclaimer

It's important to note that lossy compression results in loss of quality or data.
Therefore, it's always a good idea to test the output file to make sure it meets your requirements.

If you encounter any challenges while using the library or have suggestions for its improvement, I invite you to please create an issue. [https://github.com/pIlIp-d/FileCrusher/issues](https://github.com/pIlIp-d/FileCrusher/issues)
kshort 0.0.9
Module to manage your projects using kitty and neovim
Keywords: python, kshort

# Kshort
Kshort is a terminal script that allows you to search your projects from the terminal and open them in neovim, it currently works with kitty and gnome-terminal.

## Requirements
- `kitty` [terminal](https://sw.kovidgoyal.net/kitty/) | `gnome-terminal`
- `fzf` [repo](https://github.com/junegunn/fzf)
- `neovim`

## Installation

```shell
pip install kshort
```

## Configuration
Configure the projects in your director `~/.config/projects_manager.json`

- *File structure*
```json
{
  "directories": [
    {
      "name": "PHP",
      "directory": "~/code/php",
      "icon": " ",
      "color": "#5e79be"
    },
    {
      "name": "Javascript",
      "directory": "~/code/javascript/",
      "icon": " ",
      "color": "#ecb75d"
    }
  ],
  "projects": [
    {
      "name": "Neovim",
      "directory": "~/.config/nvim",
      "icon": " ",
      "color": "#509a3a"
    },
    {
      "name": "Awesome",
      "directory": "~/.config/awesome",
      "icon": " ",
      "color": "#535d6c"
    }
  ]
}
```

## Commands

- `kshort` list your projects in fzf and open them in kitty and using neovim
- `kshort -g` list your projects in fzf and open them in gnome-terminal and using neovim
- `kshort --list` returns a list of your configured projects
coherent.test 0.8.1
Run tests for Coherent projects.
Requires Python: >=3.8

[![](https://img.shields.io/pypi/v/coherent.test)](https://pypi.org/project/coherent.test)

![](https://img.shields.io/pypi/pyversions/coherent.test)

[![](https://github.com/coherent-oss/coherent.test/actions/workflows/main.yml/badge.svg)](https://github.com/coherent-oss/coherent.test/actions?query=workflow%3A%22tests%22)

[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)

[![Coherent Software Development System](https://img.shields.io/badge/coherent%20system-informational)](https://github.com/coherent-oss/system)

Run tests for projects under the [Coherent Software Development System](https://github.com/coherent-oss/system/blob/main/README.md).

```
py -m coherent.test
```