semvec/pypi-packages huggingface dataset:
timeline-craft 0.1.5
A Python library for creating timeline visualizations in PowerPoint
Requires Python: >=3.12

# timeline for powerpoint
this project is about adding a timeline (with smooth transitions) in microsoft powerpoint slides.

this is the PyPI package version of the project (`timeline-craft`).

# demo
![demo](https://github.com/don-yin/powerpoint-timeline/blob/cf5610f7db48a2f3e2fb747e2f197c5dbedd45e8/public/demo.gif)

# preview compare
|      before processing       |      after processing      |
| :--------------------------: | :------------------------: |
| ![before](public/before.png) | ![after](public/after.png) |

# use

```python
from pathlib import Path
from pptx import Presentation
from timeline import set_sidebar_timeline, move_elements_to_right, set_morph_transitions, Configurations


if __name__ == "__main__":
    path_ppt = Path("~/example.pptx")
    tags = ["intro"] * 15 + ["methods"] * 10 + ["results"] * 8

    example_ppt = Presentation(path_ppt)

    config = Configurations(
        sidebar_width=0.12,
        sidebar_item_height=0.10,
        sidebar_init_font_size=18,
        transition_duration=0.3,
        apply_morph_transition=True,
    )

    move_elements_to_right(example_ppt, config=config)
    set_sidebar_timeline(ppt=example_ppt, tags=tags, config=config)
    set_morph_transitions(example_ppt, config=config)

    example_ppt.save(path_ppt.parent / "timeline.pptx")
```
anzar 0.2.17
Add your description here
Requires Python: >=3.14

# Anzar SDK Documentation

## Installation

```bash
pip install anzar
```

## Quick Start

```python
from anzar import AnzarAuth

# Initialize the SDK
auth = AnzarAuth

# Use the authenticated client
# (Add specific usage examples here)
```

## Configuration

### Environment Variables

Create a `.env` file in your project root:

```env
# Add your environment variables here
ANZAR_API_KEY=your_api_key
ANZAR_BASE_URL=https://api.anzar.com
```

## API Reference

### AnzarAuth

Authentication manager for user login, registration, and session management.

```python
from anzar import AnzarAuth
```

#### Methods

##### `login(email, password)`

Authenticate a user with credentials.

**Parameters:**
- `email` (str): User's email
- `password` (str): User's password

**Returns:**
- `User`: User object on success
- `Error`: Error object on failure

**Example:**
```python
result = AnzarAuth.login("user@example.com", "password123")
if isinstance(result, User):
    print(f"Logged in: {result.username}")
else:
    print(f"Login failed: {result.error}")
```

##### `register(username, email, password)`

Register a new user account.

**Parameters:**
- `username` (str): Desired username
- `email` (str): User's email address
- `password` (str): User's password

**Returns:**
- `User`: User object on success
- `Error`: Error object on failure

**Example:**
```python
result = AnzarAuth.register("newuser", "user@example.com", "password123")
```

##### `logout()`

Log out the current user.

**Returns:**
- `User`: Empty user object on success
- `Error`: Error object on failure

**Example:**
```python
result = AnzarAuth.logout()
```

##### `isLoggedIn()`

Check if a user is currently logged in.

**Returns:**
- `User`: Current user object if logged in
- `Error`: Error object if not logged in

**Example:**
```python
result = AnzarAuth.isLoggedIn()
if isinstance(result, User):
    print(f"Current user: {result.username}")
else:
    print("No user logged in")
```

## Error Handling

```python
from anzar.types import Error
try:
    result = AnzarAuth.login(email, password)
except Error as e:
    print(f"Error: {e}")
```

## Examples

### Basic Authentication Flow

```python
from anzar import AnzarAuth

# Register new user
result = AnzarAuth.register("johndoe", "john@example.com", "securepass123")
if isinstance(result, Error):
    print(f"Registration failed: {result.message}")
    return

# Login
result = AnzarAuth.login("john@example.com", "securepass123")
if isinstance(result, Error):
    print(f"Login failed: {result.message}")
    return

print(f"Welcome {result.username}")

# Check login status
user = AnzarAuth.isLoggedIn()
if not isinstance(user, Error):
    print(f"Current user: {user.username}")

# Logout
AnzarAuth.logout()
```

## Contributing

Instructions for contributing to the SDK.

## License

License information.
scself 0.5.0
Self Supervised Tools for Single Cell Data

# scself

[![PyPI version](https://badge.fury.io/py/scself.svg)](https://badge.fury.io/py/scself)

Self Supervised Tools for Single Cell Data

Molecular Cross-Validation for PCs [arXiv manuscript](https://www.biorxiv.org/content/10.1101/786269v1)

```
mcv(
    count_data,
    n=1,
    n_pcs=100,
    random_seed=800,
    p=0.5,
    metric='mse',
    standardization_method='log',
    metric_kwargs={},
    silent=False,
    verbose=None,
    zero_center=False
)
```

Noise2Self for kNN selection [arXiv manuscript](https://arxiv.org/abs/1901.11365)

```
noise2self(
    count_data,
    neighbors=None,
    npcs=None,
    metric='euclidean',
    loss='mse',
    loss_kwargs={},
    return_errors=False,
    connectivity=False,
    standardization_method='log',
    pc_data=None,
    chunk_size=10000,
    verbose=None
)
```

Implemented as in [DEWÄKSS](https://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1008569)

Feature module and submodule determination using pearson correlation distance, kNN embedding, and leiden clustering
```
get_correlation_modules(
    adata,
    layer='X',
    n_neighbors=10,
    leiden_kwargs={},
    output_key='gene_module',
    obs_mask=None

)

get_correlation_submodules(
    adata,
    layer='X',
    n_neighbors=10,
    leiden_kwargs={},
    input_key='gene_module',
    output_key='gene_submodule',
    obs_mask=None
)
```

Feature module and submodule scoring
```
score_all_modules(
    adata,
    modules=None,
    module_column='gene_module',
    output_key_suffix='_score',
    obs_mask=None,
    layer='X',
    scaler=TruncMinMaxScaler(),
    fit_scaler=True,
    clipping=None
)

score_all_submodules(
    adata,
    modules=None,
    submodules=None,
    module_column='gene_module',
    submodule_column='gene_submodule',
    output_key_suffix='_score',
    obs_mask=None,
    layer='X',
    scaler=TruncMinMaxScaler(),
    fit_scaler=True,
    clipping=None
)
```
xinject 1.5.0
Lazy dependency injection.
Requires Python: <4.0,>=3.12
Keywords: dependency, injection, lazy, resource

![PythonSupport](https://img.shields.io/static/v1?label=python&message=%203.8|%203.9|%203.10&color=blue?style=flat-square&logo=python)
![PyPI version](https://badge.fury.io/py/xinject.svg?)

- [Introduction](#introduction)
- [Documentation](#documentation)
- [Install](#install)
- [Quick Start](#quick-start)
- [Licensing](#licensing)

# Introduction

Main focus is an easy way to create lazy universally injectable dependencies;
in less magical way. It also leans more on the side of making it easier to get
the dependency you need anywhere in the codebase.

py-xinject allows you to easily inject lazily created universal dependencies into whatever code that needs them,
in an easy to understand and self-documenting way.

# Documentation

**[📄 Detailed Documentation](https://xyngular.github.io/py-xinject/latest/)** | **[🐍 PyPi](https://pypi.org/project/xinject/)**

# Install

```bash
# via pip
pip install xinject

# via poetry
poetry add xinject
```

# Quick Start

```python
# This is the "my_resources.py" file/module.

import boto3
from xinject import DependencyPerThread


class S3(DependencyPerThread):
    def __init__(self, **kwargs):
        # Keeping this simple; a more complex version
        # may store the `kwargs` and lazily create the s3 resource
        # only when it's asked for (via a `@property or some such).

        self.resource = boto3.resource('s3', **kwargs)
```

To use this resource in codebase, you can do this:

```python
# This is the "my_functions.py" file/module

from .my_resources import S3

def download_file(file_name, dest_path):
    # Get dependency
    s3_resource = S3.grab().resource
    s3_resource.Bucket('my-bucket').download_file(file_name, dest_path)
```

Inject a different version of the resource:

```python
from .my_resources import S3
from .my_functions import download_file

us_west_s3_resource = S3(region_name='us-west-2')

def get_s3_file_from_us_west(file, dest_path):
    # Can use Dependencies as a context-manager,
    # inject `use_west_s3_resource` inside `with`:
    with us_west_s3_resource:
        download_file(file, dest_path)

# Can also use Dependencies as a function decorator,
# inject `use_west_s3_resource` whenever this method is called.
@us_west_s3_resource
def get_s3_file_from_us_west(file, dest_path):
    download_file(file, dest_path)
```

# Licensing

This library is licensed under the MIT-0 License. See the LICENSE file.