semvec/pypi-packages huggingface dataset:
rozetka-api 1.7.0
Rozetka Python API
Requires Python: ==3.13.*
Keywords: rozetka

[![Stand With Ukraine](https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/banner-direct-single.svg)](https://stand-with-ukraine.pp.ua)
[![Made in Ukraine](https://img.shields.io/badge/made_in-Ukraine-ffd700.svg?labelColor=0057b7)](https://stand-with-ukraine.pp.ua)
[![Stand With Ukraine](https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/badges/StandWithUkraine.svg)](https://stand-with-ukraine.pp.ua)
[![Russian Warship Go Fuck Yourself](https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/badges/RussianWarship.svg)](https://stand-with-ukraine.pp.ua)

Rozetka.ua Python API
---------------------

[![Docker Image Latest](https://github.com/ALERTua/rozetka_api/actions/workflows/docker-image.yml/badge.svg)](https://github.com/ALERTua/rozetka_api/actions/workflows/docker-image.yml)

Hey-hey, Rozetka employee, I mean no harm. I just wanna know whether your discounts are real. Luvz.

Do not forget to run with `--init` for SIGTERM to correctly forward to child processes.

### Github
https://github.com/ALERTua/rozetka_api

### PyPi
https://pypi.org/project/rozetka-api

### Examples

[examples/example_item.py](rozetka/examples/example_item.py)

[examples/example_category.py](rozetka/examples/example_category.py)

[tests/test_suite.py](tests/test_suite.py)
crosper-fonseka-package 0.1.0
A Python package with a submodule
Requires Python: >=3.6

# My Package
A Python package with a submodule for demonstration purposes.

## Installation
```sh
pip install crosper_fonseka_package
```

## Usage
```python
from crosper_fonseka_package.my_submodule import hello_world
print(hello_world())
```

## License
This project is licensed under the MIT License.
hieralog1 0.1.0
Hierarchical logging library with enhanced printing functions.
Requires Python: >=3.6

# Hieralog

**Hieralog** is a hierarchical logging library for Python that provides enhanced logging and printing functions. It supports multiple levels, color coding, framed and plain output, and integrates seamlessly with progress bars.

## Features

- **Hierarchical Logging:** Auto-detect log levels with a "[x]" prefix.
- **Color-Coded Output:** Different colors for each log level.
- **Enhanced Print Functions:** 
  - **hprint()**: Hierarchical (framed) logging output.
  - **pprint()**: Plain print with hierarchical indentation.
  - **fprint()**: Framed print with hierarchical indentation.
  - **progress_write()**: Writes progress messages with the proper indent.
- **Automatic Completion Message:** A final completion log is printed automatically when the program ends.

## Installation

Install via pip:

```bash
pip install hieralog1
hieralog 0.1.0
Hierarchical logging library with enhanced printing functions.
Requires Python: >=3.6

# Hieralog

**Hieralog** is a hierarchical logging library for Python that provides enhanced logging and printing functions. It supports multiple levels, color coding, framed and plain output, and integrates seamlessly with progress bars.

## Features

- **Hierarchical Logging:** Auto-detect log levels with a "[x]" prefix.
- **Color-Coded Output:** Different colors for each log level.
- **Enhanced Print Functions:** 
  - **hprint()**: Hierarchical (framed) logging output.
  - **pprint()**: Plain print with hierarchical indentation.
  - **fprint()**: Framed print with hierarchical indentation.
  - **progress_write()**: Writes progress messages with the proper indent.
- **Automatic Completion Message:** A final completion log is printed automatically when the program ends.

## Installation

Install via pip:

```bash
pip install hieralog1
schema-alchemist 0.0.6
turn your DB tables to python code
Requires Python: >=3.8

# Schema Alchemist

Schema Alchemist is a Python library designed to facilitate the generation of SQLAlchemy and SQLModel schemas from existing database schemas. It provides tools to generate table definitions, column definitions, relationships, and more, making it easier to work with complex database schemas in Python.

## Features

- Generate SQLAlchemy and SQLModel table definitions from existing database schemas.
- Support for various SQLAlchemy column types, including computed columns, identity columns, and more.
- Generate relationships between tables, including one-to-many, many-to-one, and many-to-many relationships.
- Support for generating enums and other constraints.
- Customizable options for naming conventions, including camel case and snake case.
- Ability to exclude specific tables from relationship generation.

## Installation

You can install Schema Alchemist using pip:

```bash
pip install schema-alchemist
```

## Usage
### Basic Usage
To generate SQLAlchemy schemas from an existing database schema, you can use the `CoreSchemaGenerator` class:

```python
from schema_alchemist.generators.schema_generators import CoreSchemaGenerator
from sqlalchemy import create_engine
from sqlalchemy.engine.reflection import Inspector

engine = create_engine('sqlite:///example.db')

inspector = Inspector.from_engine(engine)
reflected_data = inspector.reflect()
sorted_tables_and_fks = inspector.get_sorted_table_and_fkc_names()

generator = CoreSchemaGenerator(reflected_data, sorted_tables_and_fks)
schema = generator.generate()

print(schema)
```

### Generating SQLModel Schemas
To generate SQLModel schemas, you can use the `SQLModelSchemaGenerator` class:

```python
from schema_alchemist.generators.schema_generators import SQLModelSchemaGenerator

generator = SQLModelSchemaGenerator(reflected_data, sorted_tables_and_fks)
schema = generator.generate()
print(schema)
```

## Contributing
Contributions are welcome! If you have any ideas, suggestions, or bug reports, please open an issue or submit a pull request on GitHub.

## License
Schema Alchemist is licensed under the MIT License. See the LICENSE file for more information.
scpca 0.3.3
Single-cell PCA.
Requires Python: <3.12,>=3.8.1


# scPCA - A probabilistic factor model for single-cell data

![pypi](https://img.shields.io/pypi/v/scpca.svg)
![release workflow](https://github.com/sagar87/scPCA/actions/workflows/release.yaml/badge.svg)
![push workflow](https://github.com/sagar87/scPCA/actions/workflows/branch.yaml/badge.svg)

scPCA is a versatile matrix factorisation framework designed to analyze single-cell data across diverse experimental designs.

![scPCA schematic](https://github.com/sagar87/scPCA/blob/main/docs/scpca_schematic.png?raw=true)

*scPCA is a young project and breaking changes are to be expected.*

## scPCA in a nutshell

scPCA enables the analysis of single-cell RNA-seq data across condtions. In simple words, it enables the incorporation of a design (model) matrix that encodes the experimental design of the dataset and infers how the gene loading weight vectors change from a specified reference condition to the treated condtion. 

https://github.com/user-attachments/assets/182af56e-14e0-4357-ab31-1b392dd45d18

## Quick install

scPCA makes use `torch`, `pyro` and `anndata`. We highly recommend to run scPCA on a GPU device.

### Via Pypi

The easiest option to install `scpca` is via Pypi. Simply type

```
$ pip install scpca
```


into your shell and hit enter.

* Free software: MIT license
* Documentation: https://sagar87.github.io/scPCA/index.html

## Credits

* Harald Vöhringer
hello_quinx 0.2.0
Learn how to publish a PyPI package
Requires Python: <4.0,>=3.9

Learn PyPI package

## About

I want to create a PyPI package. Therefore, I need to answer some questions:

- How is a PyPI package structured?
- How is it tested (Unit)? What about static analysis and code style?
- How is it built and published to [PyPI](https://pypi.org)?
- How is it integrated with GitHub Actions?

## Structure
- `src` directory contains source files.
- `tests` directory contains test files
- `pyproject.toml` is a configuration file, to define build system requirements, project metadata, and other settings.

## Code style

- `flake8` package for code linting.
    ```bash
    flake8 src/**/*.py --exclude __init__.py
    ```

- `black` package for code formatting.
    ```bash
    black src/
    black --check src/ 
    ```

- `isort` package for sorting imports.
    ```bash
    isort src/
    isort --check-only src/
    ```

> I consider they are in the category with ESLint and Prettier, but for Python only.


## Testing
- `pytest` package for unit testing.
    ```bash
    poetry run pytest
    ```

## Commands

Test, Build and Publish.
```bash
pip install poetry

poetry install

poetry run pytest

poetry build

poetry config pypi-token.pypi pypi-api-token-here

peotry publish
```
c-fonseka-package 0.1.0
A Python package with a submodule
Requires Python: >=3.6

# My Package
A Python package with a submodule for demonstration purposes.

## Installation
```sh
pip install c_fonseka_package
```

## Usage
```python
from c_fonseka_package.my_submodule import hello_world
print(hello_world())
```

## License
This project is licensed under the MIT License.
crospers-test-package 0.1.0
A Python package with a submodule
Requires Python: >=3.6

# My Package
A Python package with a submodule for demonstration purposes.

## Installation
```sh
pip install my_package
```

## Usage
```python
from my_package.my_submodule import hello_world
print(hello_world())
```

## License
This project is licensed under the MIT License.
signalling 1.0.1
Pure python library for utilising a Signalling event pattern
Requires Python: >3.5.2
Keywords: signal

# Overview

This library exposes a mechanism for signalling in Python. Through this 
mechanism you can create a Signal class and then connect that signal to 
any number of callable end points. Upon that signal being emitted the 
Signal class will then trigger a call to all the connected callables.

This pattern allows for events to be propagated to different classes/functions
when they occur.

## Install

```python
pip install signalling
```

## Example
 
This example shows how to use a basic signal:
```python
import signalling

# -- Declare some functions. This can be functions, methods
# -- or classsmethods
def do_something():
    print("doing something")

def do_something_else():
    print("doing something else")

# -- Create a singal
signal = signalling.Signal()

# -- Connect the signal to various end points
signal.connect(do_something)
signal.connect(do_something_else)

# -- Now we can emit the signal and all the end
# -- points will be called (in order they were
# -- connected)
signal.emit()
```

## WeakSignal

The standard `Signal` class will hold a direct reference to the callable its connected
to. This means the endpoint will never be garbage collected whilst the signal is alive.

However, there are times that we want to use the signalling mechanism but we dont want
to hold a direct reference. For this we can use `signalling.WeakSignal`. This version
of the signalling class will only hold a weak reference to the callable end point, so 
it allows for the garbage collecting of end points if nothing else is holding a 
reference to it outside of the Signal class. 

The approach to using the `WeakSignal` is exactly the same, and all the weakref 
management is carried out by the signal class itself.

```python
import signalling

# -- Declare some functions. This can be functions, methods
# -- or classsmethods
def do_something():
    print("doing something")

def do_something_else():
    print("doing something else")

# -- Create a singal
signal = signalling.WeakSignal()

# -- Connect the signal to various end points
signal.connect(do_something)
signal.connect(do_something_else)

# -- Now we can emit the signal and all the end
# -- points will be called (in order they were
# -- connected)
signal.emit()
```