semvec/pypi-packages huggingface dataset:
jinja-render 0.1.8
This module helps to render reports
Requires Python: >=3.9

<a href="https://www.islas.org.mx/"><img src="https://www.islas.org.mx/img/logo.svg" align="right" width="256" /></a>
# Jinja Render
[![codecov](https://codecov.io/gh/IslasGECI/jinja_render/graph/badge.svg?token=ia1J0LyJiQ)](https://codecov.io/gh/IslasGECI/jinja_render)
![licencia](https://img.shields.io/github/license/IslasGECI/jinja_render)
![languages](https://img.shields.io/github/languages/top/IslasGECI/jinja_render)
![commits](https://img.shields.io/github/commit-activity/y/IslasGECI/jinja_render)
![PyPI - Version](https://img.shields.io/pypi/v/jinja_render)

Base functinos to use Jinja2

Here we use the `jinja_render` module, as example, from `robinson_code` repo
# Example
This example is from [muestreo-aves-marinas-ipbc](https://bitbucket.org/IslasGECI/muestreo-aves-marinas-ipbc/src/43dba1b46b492393baa508fbbb73d3ff9ade42be/Makefile#lines-946)
``` sh
typer jinja_render run \
--report-name="time_series_results_section" \
--summary-path="tests/data/mergulo_punta.json"
```
scPDA 0.3.0
Single Cell Protein Counts Denoising
Requires Python: >=3.10.0

# scPDA: Denoising Protein Expression in Droplet-Based Single-Cell Data

scPDA is a VAE-based neural network for the task of denoising single-cell surface protein abundance measured by droplet-based technologies such as CITE-seq.

Unlike most currently established methods, scPDA does not require empty droplets. scPDA establishes a probabilistic model for raw count data, and shows a great computational efficiency.

For more details read our [manuscript]()
<p align="center">
  <img src="https://raw.githubusercontent.com/PancakeZoy/scPDA/refs/heads/main/img/scPDA_stru.png" width="750" title="model_pic">
</p>

## Installation
`pip install scpda`

## Main API
Below is an example that includes main APIs to train `scPDA`.

```python
from scPDA import model

# please prepare the protein counts dsb_counts_tensor (torch.tensor) and the estimated background mean dsb_mu1_tensor (torch.tensor)
scPDA = model(raw_counts=dsb_counts_tensor, bg_mean=dsb_mu1_tensor)
scPDA.train()
scPDA.inference()

# The estimated mu1, mu2, theta1, theta2, pi (background probability) are returned
mu1 = scPDA.mu1
mu2 = scPDA.mu1 * scPDA.alpha
theta1 = scPDA.theta1
theta2 = scPDA.theta2
pi = scPDA.pi
```
schemantis-cli 0.0.10
A python comand line tool that integrates with schemantis
Requires Python: >=3.7


# Schemantis CLI

## Introduction

The Schemantis CLI is a command-line interface tool that allows you to generate code from map data using the Schemantis API.

## Installation

To install the Schemantis CLI, you can use pip:

```bash
pip install schemantis-cli
```

## Usage

To use the Schemantis CLI, you need to provide the following arguments:

- `--generator` or `-g`: The generator to use (e.g., 'python').
- `--map_id_or_name` or `-m`: The map ID or name.
- `--output-directory` or `-o`: The output directory for the generated code.

Here is an example command to generate Python code from a map:

```bash
schemantis-cli --generator python --map_id_or_name 123 --output-directory ./out
```
django-query-optimizer 0.5.0
Automatic optimization of django queries
Requires Python: >=3.6

# Django query optimizer

Automatic optimization of django queries

## Features

- analyze django models and identifies direct and reverce relations
- returns a query that allows you to apply your own filters


## Installation

- Install using pip:

```sh
$ pip install django_query_optimizer
```
- ```Dont``` add package to django ```INSTALLED_APPS```
## Usage

Django query optimizer is easy to use and you can just import it and assign your model to ```optimize_query```:

    from django_query_optimizer import optimize_query
    from .models import YourModel

    def your_view(request):
        queryset = optimize_query(YourModel)
        context ={
            'objects' : queryset 
        }
            
        return render(request, "your_page.html", context)


And you can also apply your own filters:

    from django_query_optimizer import optimize_query
    from .models import YourModel

    def detail_view(request, id):
        queryset = optimize_query(YourModel).get(id = id)
        context ={
            'object' : queryset 
        }
            
        return render(request, "detail_page.html", context)

    
    from django_query_optimizer import optimize_query
    from .models import YourModel

    def filters_view(request):
        queryset = optimize_query(YourModel).filter(is_active=True)
        context ={
            'objects' : queryset 
        }
            
        return render(request, "filters_page.html", context)

Was it useful for you? Leave a star ⭐⭐⭐ - 2024 Yasin Karbasi
salinic 0.6.1
Search abstraction layer
Requires Python: <4.0,>=3.13

[![Tests](https://github.com/papermerge/salinic/actions/workflows/tests.yml/badge.svg)](https://github.com/papermerge/salinic/actions/workflows/tests.yml)

# Salinic

Salinic - provides modular search. It features a unified API that
allows you to plug in different search backends.
Currently, it supports Xapian and Solr backends.


## Usage

Declare your search schema:

    from typing import Optional
    from typing_extensions import Annotated

    from salinic.field import IdField, KeywordField, TextField
    from salinic.schema import Schema


    class MyModel(Schema):
        """Index schema"""
        id: Annotated[str, IdField(primary_key=True)]
        user_id: str
        parent_id: str
        title: Annotated[str, TextField()]
        text: Annotated[Optional[str], TextField()] = None
        tags: Annotated[Optional[list[str]], KeywordField()] = []


Index your documents:

        from salinic import IndexRW, create_engine

        engine = create_engine("xapian:////search_index")
        index = IndexRW(engine, schema=MyModel)

        for document in all_your_documents():
            model = MyModel(
                id=str(document.id),
                user_id=str(document.user_id),
                parent_id=document.parent_id,
                title=document.title,
                text=document.text,
                tags=document.tags
            )
            index.add(model)


Search your documents:

        from salinic import IndexRO, create_engine

        engine = create_engine("xapian:////search_index")
        index = IndexRO(engine, schema=MyModel)

        sq = Search(MyModel).query(" your query string ")

        for found in index.search(sq):
            print(found)  # found is instance of MyModel


The only modification of your for changing to different search
engine backend, is the first argument of the `create_engine` method e.g. from
"xapian:////search_index" to "solr://localhost:8983/my-index-name".
roman-empire-reminder 1.2.1
A simple Python script to remind the user of the Roman Empire at random intervals, all via toast notifications.
Requires Python: >=3
Keywords: Roman, Roman Empire

# RomanEmpireReminder

## Description

A simple Python script to remind the user of the Roman Empire at random intervals, all via toast notifications. The intervals range anywhere from every 5 minutes up to an hour.

> [!WARNING]
> I do not own any of the materials that are referenced or shared in this project. These images, sound effects, and other materials belong to their respective copyright holders. Please, do not sue me over some silly Python app!

## Why?

I made this project after remembering an old meme circling the internet in late 2023 where women would approach men and ask them how often they think about the Roman Empire. The meme was that if you were a man and didn't think of the Empire often enough, you would be considered feminine. Dumb, I know, but it spawned this beautiful program to remind you constantly so you don't end up too girly!

## Regarding PascalCase

This was originally written in C#, but I had such a hard time getting Microsoft's own libraries to work with Visual Studio that I decided to rewrite it in Python. Somehow, Python was much easier than using Microsoft's own tools (makes sense, right?), but I liked using C# so much that I wrote the Python script similarly to how I wrote the original script. So there you go, deal with it.

## Installation

Roman Empire Reminder is indexed in PyPi and can be installed with, for example, ```pip install roman-empire-reminder```.

Alternatively, you can run ```pip install path/to/clone``` to install from a local clone.

If for some reason that doesn't work, here is the list of requirements that the script uses:

```requirements.txt
datetime
pygame
pyttsx3

windows_toasts # Windows
dbus-python # Linux
```

The rest of the libraries required should be built into Python, but if not, please check the imports in the `__init__.py`, `__main__.py`, and `notification.py` files in `roman-empire-reminder`.

## How to Run

Run ```py -m roman-empire-reminder``` (Windows) or ```python -m roman-empire-reminder``` (Linux) in Command Prompt / a terminal emulator after installation.

Alternatively, run from the directory by executing `roman-empire-reminder/__main__.py` with python.

## Contributing

Contributions are welcome as long as you don't try to make any drastic changes. As long as you do that, then I would be happy to look at any pull request and see if I approve!