semvec/pypi-packages huggingface dataset:
html2text 2025.4.15
Turn HTML into equivalent Markdown-structured text.
Requires Python: >=3.9

# html2text

[![CI](https://github.com/Alir3z4/html2text/actions/workflows/main.yml/badge.svg?branch=master)](https://github.com/Alir3z4/html2text/actions/workflows/main.yml)
[![codecov](https://codecov.io/gh/Alir3z4/html2text/graph/badge.svg?token=OoxiyymjgU)](https://codecov.io/gh/Alir3z4/html2text)



html2text is a Python script that converts a page of HTML into clean, easy-to-read plain ASCII text. Better yet, that ASCII also happens to be valid Markdown (a text-to-HTML format).


Usage: `html2text [filename [encoding]]`

| Option                                                 | Description
|--------------------------------------------------------|---------------------------------------------------
| `--version`                                            | Show program's version number and exit
| `-h`, `--help`                                         | Show this help message and exit
| `--ignore-links`                                       | Don't include any formatting for links
|`--escape-all`                                          | Escape all special characters.  Output is less readable, but avoids corner case formatting issues.
| `--reference-links`                                    | Use reference links instead of links to create markdown
| `--mark-code`                                          | Mark preformatted and code blocks with [code]...[/code]

For a complete list of options see the [docs](https://github.com/Alir3z4/html2text/blob/master/docs/usage.md)


Or you can use it from within `Python`:

```
>>> import html2text
>>>
>>> print(html2text.html2text("<p><strong>Zed's</strong> dead baby, <em>Zed's</em> dead.</p>"))
**Zed's** dead baby, _Zed's_ dead.

```


Or with some configuration options:
```
>>> import html2text
>>>
>>> h = html2text.HTML2Text()
>>> # Ignore converting links from HTML
>>> h.ignore_links = True
>>> print h.handle("<p>Hello, <a href='https://www.google.com/earth/'>world</a>!")
Hello, world!

>>> print(h.handle("<p>Hello, <a href='https://www.google.com/earth/'>world</a>!"))

Hello, world!

>>> # Don't Ignore links anymore, I like links
>>> h.ignore_links = False
>>> print(h.handle("<p>Hello, <a href='https://www.google.com/earth/'>world</a>!"))
Hello, [world](https://www.google.com/earth/)!

```

*Originally written by Aaron Swartz. This code is distributed under the GPLv3.*


## How to install

`html2text` is available on pypi
https://pypi.org/project/html2text/

```shell
$ pip install html2text
```

##  Development

### How to run unit tests

```shell
$ tox
```

To see the coverage results:

```shell
$ coverage html
```

then open the `./htmlcov/index.html` file in your browser.


### Code Quality & Pre Commit

The CI runs several linting steps, including:

- mypy
- Flake8
- Black

To make sure the code passes the CI linting steps, run:

```shell
$ tox -e pre-commit
```

## Documentation

Documentation lives [here](https://github.com/Alir3z4/html2text/blob/master/docs/usage.md)
lurk-cli 0.1.7
A CLI tool to check product stock across multiple stores.
Requires Python: >=3.13

# Lurk
Lurk is a simple CLI tool that checks product stock across multiple stores. Search by keywords, set filters like price or category, and get real-time availability—all without leaving your terminal.

Built with Python, it leverages asynchronous requests for speed and efficiency. Data fetching is handled via custom store-specific checkers, and results are structured using Pydantic models.
RL22021UNO 1.0.0
Librería para resolver sistemas de ecuaciones lineales y no lineales
Requires Python: >=3.6

# RL22021UNO - Librería para la resolución de sistemas de ecuaciones lineales y no lineales

RL22021UNO es una librería en Python que permite resolver sistemas de ecuaciones lineales y no lineales utilizando varios métodos numéricos. Los métodos implementados son:

- Eliminación de Gauss
- Gauss-Jordan
- Cramer
- Descomposición LU
- Jacobi
- Gauss-Seidel
- Bisección

Es útil para estudiantes, ingenieros y desarrolladores que necesitan resolver sistemas de ecuaciones de manera eficiente.

## Instalación

Puedes instalar la librería directamente desde PyPI utilizando el siguiente comando:

```bash
pip install RL22021UNO


#Ejemplos de uso

# Eliminación de Gauss
Este método transforma el sistema a una forma escalonada para resolverlo por sustitución hacia atrás.
from RL22021UNO import gauss_eliminacion

A = [[4, 2, 5], [2, 5, 8], [5, 4, 3]]
B = [60.70, 92.90, 56.30]

X = gauss_eliminacion(A, B)
print(X)


# Gauss-Jordan
Método similar a Gauss, pero convierte la matriz en una forma reducida para obtener la solución directamente.
from RL22021UNO import gauss_jordan

A = [[4, 2, 5], [2, 5, 8], [5, 4, 3]]
B = [60.70, 92.90, 56.30]

X = gauss_jordan(A, B)
print(X)


# Cramer
Utiliza determinantes para resolver sistemas lineales con el mismo número de ecuaciones e incógnitas.
from RL22021UNO import cramer

A = [[4, 2, 5], [2, 5, 8], [5, 4, 3]]
B = [60.70, 92.90, 56.30]

X = cramer(A, B)
print(X)


# Descomposición LU
Descompone la matriz A en una matriz triangular inferior (L) y una superior (U).
from RL22021UNO import lu_decomposition

A = [[4, 2, 5], [2, 5, 8], [5, 4, 3]]
B = [60.70, 92.90, 56.30]

L, U = lu_decomposition(A)
print("L:", L)
print("U:", U)


# Jacobi
Método iterativo que resuelve sistemas lineales separando la matriz diagonal de las demás.
from RL22021UNO import jacobi

A = [[4, 2, 5], [2, 5, 8], [5, 4, 3]]
B = [60.70, 92.90, 56.30]

X = jacobi(A, B)
print(X)


# Gauss-Seidel
Versión mejorada del método de Jacobi, usa los valores actualizados dentro de la misma iteración.
from RL22021UNO import gauss_seidel

A = [[4, 2, 5], [2, 5, 8], [5, 4, 3]]
B = [60.70, 92.90, 56.30]

X = gauss_seidel(A, B)
print(X)


# Bisección
Método para encontrar raíces de ecuaciones no lineales, dividiendo el intervalo en mitades sucesivas.
from RL22021UNO import bisection

def f(x):
    return x**2 - 4

root = bisection(f, 0, 5)
print(f"La raíz es: {root}")

Requisitos
Python 3.6 o superior

NumPy




Este proyecto está licenciado bajo la Licencia MIT. Consulta el archivo LICENSE para más detalles.


Las contribuciones son bienvenidas. Si encuentras un error o quieres sugerir mejoras, abre un issue o un pull request en GitHub.

Puedes contactarme en mirnarivas860@gmail.com o en mi perfil de GitHub: [https://github.com/Mirna1111].
pacote-TratImagem-Junior-de-freitas 0.1.0
Funções para manipulação e visualização de imagens com scikit-image.
Requires Python: >=3.7

# package_name

Description. 
The package package_name is used to:
	Processing:
		- Histrogram matching  
		- Structural similarity
		- Resize image
	Utils:
		- Read image
		- Save image
		

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install package_name

```bash
pip install package_name
```

## Usage

```python
from package_name.module1_name import file1_name
file1_name.my_function()
```

## Author
My_name

## License
[MIT](https://choosealicense.com/licenses/mit/)
AgileMind 0.1.0
A multi-agent software development tool.
Requires Python: >=3.8

# Agile Mind

## Overview

Agile Mind is an AI-powered development platform that builds software repositories from natural language descriptions. It uses a LLM-based multi-agent architecture to automate the software development process, from requirements gathering to code generation and documentation.

## Features

- **Multi-Agent Architecture**: Specialized AI agents for different development tasks
- **Code Generation**: Automated creation of code from requirements or descriptions
- **Collaborative Development**: Agents can work together to solve complex programming challenges
- **Documentation**: AI-generated documentation that stays in sync with code
- **Checking**: Automated code review and static analysis

## Online visualization

Check out the online visualization of AgileMind!

![AgileMindOnline](assets/main_screenshot.png)

![FilesDeveloped](assets/files_screenshot.png)

> Note that the online version does not support human-agent interaction and parallel processing yet. Consider using the command line version for those features.

### Usage

```bash
git clone https://github.com/wnrock/AgileMind.git
cd AgileMind

pip install -r requirements.txt

streamlit run web.py
```

## Quick Start

### Set Up Environment Variables

#### 1. Use `.env` file

```bash
cp .env.template .env
# Then replace the placeholder values with actual credentials
```

#### 2. Set environment variables manually

```bash
export OPENAI_API_KEY="<Your_API_key>"
export OPENAI_BASE_URL="<Your_OpenAI_API_base_url>" # Optional
```

#### 3. Pass as command-line arguments

Currently only supported for Docker. Check the Docker section below.

### Get Started

#### 1. From PyPI

```bash
pip install AgileMind

agilemind "Create a 2048 game with UI" -o output
```

#### 2. Docker

```bash
docker run -it                                      \
    -e OPENAI_API_KEY="<Your_API_key>"              \
    -e OPENAI_BASE_URL="<Your_OpenAI_API_base_url>" \
    -v <Your_output_dir>:/agilemind/output          \
    ghcr.io/wnrock/agilemind:latest                 \
    "Create a 2048 game with UI"                    \
    -o output
```

#### 3. From source

```bash
git clone https://github.com/wnrock/AgileMind.git
cd AgileMind

pip install -r requirements.txt

python app.py "Create a 2048 game with UI" -o output
```
MyUVStudy 0.1.6
Add your description here
Requires Python: >=3.13

# 说明

## 安装与使用

1. 安装uv：`pip install uv`
2. 安装第三方依赖库：`uv add <package_name>`
3. 更新第三方依赖库：`uv add -U <package_name>`
4. 卸载第三方依赖库：`uv remove <package_name>`
5. 使用uv运行脚本：`uv run app.py`

## 换源

在pyproject.toml中添加以下内容：

```toml
[[tool.uv.index]]
url = "https://pypi.tuna.tsinghua.edu.cn/simple"
default = true
```

## 初始化项目

几个常用的选项如下：

- uv init --app 创建一个普通的app， 这个也是默认的选项，这种就是最基础的项目，这类型的项目不能直接打包，由于pyproject.toml
  中没有配置build system
- uv init --package 创建一个“包”， 这类型的项目可以被打包发布，pyproject.toml 中会自动配置 build
  system，并且可以发布为工具(tool)，使用 uv tool run （或者 uvx ）来直接运行(本节重点介绍此种方式创建的包)
- uv init --lib 创建一个"库"， 这种和package 的区别在于没有project.scripts, 不能当工具来使用

## 打包

1. 配置pyproject.toml：其中项目的名称name，必须跟项目中的某个文件夹的名称相同，这个文件可以是根目录下的文件夹也可以是src目录下的子文件夹。只有这个文件夹下的文件才会被打包发布，并被其他人安装识别。
2. 打包：`uv build`
3. 上传：`uv publish`
MR22142UNO 0.1.0
Librería para resolver sistemas de ecuaciones lineales y no lineales
Requires Python: >=3.6

# MR22142UNO

LIBRERIA para resolver sistemas de ecuaciones lineales y no lineales mediante:

Metodos:
- Eliminacion de Gauss
- Gauss-Jordan
- Regla de Cramer
- Descomposicion LU
- Jacobi 
- Gauss-Seidel
- Biseccion

## Instalacion

Desde PyPI:

```bash
pip install MR22142UNO
scCyclone 1.1.0
Single-Cell Cyclone Analysis Package
Requires Python: >=3.8

[![PyPI](https://img.shields.io/pypi/v/scCyclone?logo=PyPI)](https://pypi.org/project/scCyclone)
[![Documentation Status](https://readthedocs.org/projects/sccyclone/badge/?version=latest)](https://sccyclone.readthedocs.io/en/latest/?badge=latest)



# scCyclone: Single-Cell Cyclone Analysis in Python


scCyclone is a comprehensive Python package designed to analyze single-cell full-length transcriptome data.


## Features


* **Personalized Matrix Generation**: This feature allows users to create custom matrices tailored to their specific dataset requirements, providing flexibility in handling various types of single-cell sequencing data.

* **Differential Transcript Usage (DTU) Analysis**: This tool helps identify variations in transcript usage across different cell populations, enabling researchers to understand how gene expression patterns differ under different conditions.

* **Functional and Structural Analysis of Differential Transcripts**: This feature goes beyond simple identification of differential transcripts by providing a deeper analysis of their functional and structural implications. This can help researchers understand the biological significance of the observed transcript usage differences.

* **Differential Splicing Event (DSE) Analysis**: This feature is designed to detect differences in splicing patterns within single-cell data, which is crucial for identifying splice variants that may be associated with specific cellular processes or conditions.

* **Modal Analysis of Splicing Events**: This feature involves examining the distribution of splicing events to identify common patterns or central tendencies. This can provide insights into the most frequent or significant splicing patterns within the dataset.

* **RNA Binding Protein (RBP) Analysis with rMAPS Output**: This feature allows for the analysis of RNA binding protein (RBP) binding patterns and provides output files compatible with rMAPS（http://rmaps.cecsresearch.org/）, a popular tool for differential splicing analysis. This can help researchers understand the role of RBPs in regulating gene expression and splicing events.



## Getting Started

### Prerequisites

Before you begin, ensure you have met the following requirements:
- Python 3.8 or higher
- A compatible operating system (e.g., Windows, macOS, Linux)

* [scanpy](https://github.com/scverse/scanpy)
* [dotplot](https://github.com/kn-bibs/dotplot)


### Installation

To install the software, follow these steps:

```
pip install scCyclone
```

### Documentation
Read the documentation : https://sccyclone.readthedocs.io

## License
scCyclone is released under the MIT License.
public-repo-testing 0.1.9
Add your description here
Requires Python: >=3.12.4

To build, run `uv build` then upload wheels from the `dist` folder

Here is [a link to another file in the repo](https://github.com/seequentsandbox/public-repo-testing/tree/main/another_file.md), and [another link](https://github.com/seequentsandbox/public-repo-testing/tree/main/./another_file.md) and [another file](https://github.com/seequentsandbox/public-repo-testing/tree/main//another_file.md)