semvec/pypi-packages huggingface dataset:
spagim 1.0.2
Revealing the biological utility of gene imputation in spatial transcriptomics
Requires Python: >=3.9

# Run Gene Imputation Methods
[![PyPI version](https://img.shields.io/pypi/v/spagim)](https://pypi.org/project/spagim/)
[![Downloads](https://static.pepy.tech/badge/spagim)](https://pepy.tech/project/spagim)

**spagim** is a package for gene imputation of spatial transcriptomics data from single-cell RNA sequencing data. It provides a unified interface for various imputation methods, making it easy to apply them to your data.

## Installation
Create a conda environment

```bash
conda create -n spagim-env python=3.9
conda activate spagim-env
```
Install JAX via pip:

```bash
pip install -U "jax[cuda12]"
```

Install **spagim** via pip:

```bash
pip install spagim
```

## Usage

Here is a simple example of how to use **spagim**:

```python
import spagim.benchmark as benchmark
import scanpy as sc
import torch

# Load your spatial transcriptomics data
adata_sp = sc.read_h5ad("path/to/your/spatial_data")

# Load your single-cell RNA sequencing data
adata_sc = sc.read_h5ad("path/to/your/single_cell_data")

# Initialize the imputation model
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
models = benchmark.Imputation(device=device, seed=42)

# Run imputation
adata_impute = models.forward(
    adata_sc,
    adata_sp,
    # choose your method among ['Pearson','Spearman','Cosine','KNN','SpaGE','Harmony','Tangram','ENVI','GIMVI']
    method='Pearson',
    # n_split is the number of splits for the data for ['Tangram','Pearson','Spearman','Cosine'] only
    n_split=1,
    # batch_size is the number of samples per gradient update, for 'GIMVI' only
    batch_size=1024,
    # k is the number of nearest neighbors for ['KNN','Pearson','Spearman','Cosine','Harmony'] only
    k=100
)
```
spacebar-counter 0.1.2
A CLI tool to count spacebar presses.
Requires Python: >=3.7

# spacebar-counter

A simple Python CLI tool to count your spacebar presses per day and visualize your stats!

## Installation

Install from PyPI:
```bash
pip install spacebar-counter
```

Or install the latest version from GitHub:
```bash
pip install git+https://github.com/kalashb/spacebar-counter.git
```

## Usage

Start tracking your spacebar presses:
```bash
spacebar-counter start
```
- This will count your spacebar presses for the current day.
- The count resets automatically at midnight.
- **A file named `spacebar_stats.json` will be created in the directory where you run this command.**
- This file stores your daily spacebar stats (date, count, first and last press times).

Generate a dashboard:
```bash
spacebar-counter dashboard
```
- This creates `spacebar_dashboard.html` in the same directory.
- Open it in your browser to see your daily spacebar stats as a dot plot.

## Data Storage

- **`spacebar_stats.json`**: Stores your daily stats. Created/updated when you run `start`.
- **`spacebar_dashboard.html`**: The dashboard file. Created/updated when you run `dashboard`.
- Both files are created in the directory where you run the commands.
- Each user has their own local files; your stats are private and not shared.

## Requirements

- Python 3.7+
- `pynput`
- `plotly`
- `typer`

## License

MIT

---

**Tip:**  
- Add a "Features" section if you want to highlight more.
- Add a "Contributing" section if you want others to help improve your tool.

---

Would you like me to update your README.md for you? If so, let me know your GitHub username and repo name, or I can leave placeholders for you to fill in!
teste_lr_eagle_atualizacoes_29072025 0.0.1
Implements LangGraph based agents following the CoALA framework.
Requires Python: <3.14,>=3.10

[![Unit Tests](https://github.com/smartassistant-unicamp/eagle/actions/workflows/test.yml/badge.svg)](https://github.com/smartassistant-unicamp/eagle/actions/workflows/test.yml)
<p align="center">
    <img src="./assets/EAGLE.jpg" alt="EAGLE Logo" />
</p>

# Enhanced Agents for Generative Language Excellence

## Do que se trata este projeto?

Esse projeto implementa a visão do [framework CoALA (Cognitive Architectures for Language Agents)](https://github.com/ysymyth/awesome-language-agents) no contexto do [LangGraph](https://www.langchain.com/langgraph), com agentes, ferramentas e estratégias de integração multiagentes para servirem de exemplo para novas implementações.

## Instalação

### Pré-requisitos (considerando o uso do Conda para gerenciar o ambiente python)

- [Miniforge 3](https://conda-forge.org/download/): O Miniforge é uma distribuição mínima do conda, que é um gerenciador de pacotes e ambientes virtuais. Ele será usado para criar um ambiente virtual para instalar as dependências do projeto.

### Criando o ambiente virtual

1. Uma vez instalado o Conda, abra o terminal e digite o seguinte comando:

```bash
conda create -n eagle python=3.10
```

2. Após a criação do ambiente, ative-o com o comando:

```bash
conda activate eagle
```

3. Instale a versão mais recente do Poetry com o comando:

```bash
pip install poetry==1.8.5
```

1. Instale as dependências do projeto com o comando:

```bash
poetry install
```

## Testes
Para executar os testes, execute os seguintes passos:

1. Ative o ambiente virtual com o comando:

```bash
conda activate eagle
```

2. Copie o arquivo `sample.test.env` para `.test.env` e preencha as variáveis de ambiente com as informações necessárias para o seu amnbiente de testes.

```bash
cp sample.test.env .test.env
```

### Ponto de Atenção

Os testes e exemplos dos notebooks estão baseados nos modelos `AzureChatOpenAI` para os LLMs e `AzureOpenAIEmbeddings` para os embeddings. Caso seja necessário utilizar outros nomes de modelos, tipos ou ajustar as relações com as variáveis de ambiente, essas alterações podem ser feitas na pasta [`tests/models`](tests/models).

## Exemplos de uso das funcionalidades

A pasta `notebooks` contém exemplos de uso das ferramentas. Para executar os exemplos:

1. Ative o ambiente virtual com o comando:

```bash
conda activate eagle
```

2. Ative a extensão de widgets do jupyter com o comando:

```bash
jupyter nbextension enable --py widgetsnbextension
```

3. Ative o jupyter lab com o comando:

```bash
jupyter lab
```

4. Abra o browser e execute os notebooks da pasta `notebooks`.
convert-time-to-text 0.3.0
A simple package to convert time to text.
Requires Python: >=3.6

# Time to text

## Installation

```
pip install convert_time_to_text
```

## Usage
```
from convert_time_to_text import convert_time_to_text

print(convert_time_to_text(5,00))
print(convert_time_to_text(5,0))
print(convert_time_to_text(5,1))
print(convert_time_to_text(5,9))
print(convert_time_to_text(5,10))
print(convert_time_to_text(5,15))
print(convert_time_to_text(5,30))
print(convert_time_to_text(5,37))
print(convert_time_to_text(5,40))
print(convert_time_to_text(5,45))
print(convert_time_to_text(5,47))
print(convert_time_to_text(12,24))
print(convert_time_to_text(11,50))
print(convert_time_to_text(12,50))
print(convert_time_to_text(12,20))
```
### Given the time in numerals we may convert it into words, as shown below:
The above should result in the following output:
```
five o' clock
five o' clock
one minute past five
nine minutes past five
ten minutes past five
quarter past five
half past five
twenty three minutes to six
twenty minutes to six
quarter to six
thirteen minutes to six
twenty four minutes past twelve
ten minutes to twelve
ten minutes to one
twenty minutes past twelve
```
pydll_injector 0.1.2
Python DLL injector for Windows.
Requires Python: >=3.9

# PyDll-Injector

Python DLL injector for Windows. Supports various injection methods.

## Features

PyDll-Injector comes with the following features:
- **DLL Injection on app start**: Injects DLL(s) into a process when it starts;
- **Env variables support**: Enables you to pass environmental variables to the injected DLL;
- **Multiple injection methods**: Supports various injection methods;
- **Check if process is running**: Checks if a process is running after injection;
- **Graceful process termination**: Allows you to terminate the spawned process;
- **Ready to use CLI**: Comes with a command line interface for easy usage.

## Injection methods

The following injection methods are supported:
- **standard**: Classic CreateRemoteThread + LoadLibraryA;
- **apc**: QueueUserAPC + LoadLibraryA. Target thread must enter an alertable state;
- **nt**: NtCreateThreadEx + LoadLibraryA (stealthier than CreateRemoteThread);
- **hook**: SetWindowsHookExA(WH_CBT) injection. DLL must export `HookProc`.

## Usage

You can use PyDll-Injector via the command line interface or as a library in your Python code.

### CLI

Install the package on your system:
```bash
pip install pydll-injector[cli]
```

You can now use PyDll-Injector from the command line like this:
```bash
pydll-injector --executable-file "A:\Path\To\App.exe" --dll-list "B:\Path\To\Your.dll"
```

For the list of all available CLI options, run:
```bash
pydll-injector --help
```

This injector also allows you to pass configuration via a toml file. Here is a sample configuration file:
```toml
[launcher]
executable_file = "A:\\Path\\To\\App.exe"
cmd_line_args = "-arg1 -arg2"
dll_list = [
    "B:\\Path\\To\\Your.dll",
]
injection_method = "nt"

[environment]
vars = ["FOO=bar", "BAZ=qux"]
use_system_env = true
environment_append = false
```

### Library

First, install the package. For example, using uv:
```bash
uv add pydll-injector
```

You can now import the library and use it in your Python code:
```python
from pydll_injector.process import spawn_process, is_process_running
from pydll_injector.models import Launcher, Environment

def main() -> None:
    launcher = Launcher(
        executable_file= r"A:\Path\To\App.exe",
        cmd_line_args="",
        dll_list=[r"B:\\Path\\To\\Your.dll"],
        injection_method='apc',
    )
    env = Environment(
        vars=["FOO=bar"],
        use_system_env=True,
        environment_append=False
    )

    ctx = spawn_process(launcher, env)
    while is_process_running(ctx):
        pass

    print("Process has exited.")

if __name__ == "__main__":
    main()
```

## License

The project is distributed under the MIT License. See the [LICENSE](LICENSE) file for details.