semvec/pypi-packages huggingface dataset:
credible 1.0.3
This library contains implementations of some scikit-learn metrics with confidence intervals
Requires Python: >=3.10

<!--
SPDX-FileCopyrightText: Copyright © 2023 Idiap Research Institute <contact@idiap.ch>

SPDX-License-Identifier: GPL-3.0-or-later
-->

[![latest-docs](https://img.shields.io/badge/docs-v1.0.3-orange.svg)](https://credible.readthedocs.io/en/v1.0.3/)
[![build](https://gitlab.idiap.ch/medai/software/credible/badges/v1.0.3/pipeline.svg)](https://gitlab.idiap.ch/medai/software/credible/commits/v1.0.3)
[![coverage](https://gitlab.idiap.ch/medai/software/credible/badges/v1.0.3/coverage.svg)](https://www.idiap.ch/software/medai/docs/medai/software/credible/v1.0.3/coverage/index.html)
[![repository](https://img.shields.io/badge/gitlab-project-0000c0.svg)](https://gitlab.idiap.ch/medai/software/credible)

# Scikit-Learn compatible metrics with credible regions and confidence intervals

This library contains implementations of some scikit-learn metrics with credible regions and confidence intervals.

For installation and usage instructions, check-out our documentation.
xlsxtools 0.2.0
xlsxtools: Utility functions for writing and manipulating Excel files
Requires Python: >=3.8

xlsxtools
=========

Utility functions for writing and manipulating Excel files:
- write_dataframe_to_excel() : write a Pandas DataFrame to an Excel file, optionally calling
    auto_size_excel_column_widths() and filter_and_freeze_excel()
- auto_size_excel_column_widths() : Reformat an Excel file, adjusting the column widths to fit their contents
- filter_and_freeze_excel() : Clean up an Excel file by setting a filter on the first row,
    splitting & freezing the panes


Releases
--------

0.1.0, 2021-10-26
* Initial release

0.2.0, 2025-01-02
* Move from pandas.ExcelWriter() to DataFrame.to_excel() (transparent to user)
* Add optional `tabname` argument to auto_size_excel_column_widths() and filter_and_freeze_excel()

License
-------

This is free and unencumbered software released into the public domain.

Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any
means.
globalog 0.1.0
A global logger with automatic configuration loading

# Globalog

A Python package providing a global logger with automatic configuration loading.

## Installation

```bash
pip install globalog
```

## Usage

```python
from globalog import LOG

# The logger will automatically load configuration from the nearest config file
LOG.info("This is an info message")
LOG.debug("This is a debug message")

# You can also explicitly initialize with a specific config file
LOG.init(config_file="path/to/config.json")
```

## Configuration

The package looks for configuration files in the following order:
1. `logging_config.json` in the current directory
2. `logging_config.yaml` in the current directory
3. Default configuration if no config file is found

Example configuration file (logging_config.json):
```json
{
    "version": 1,
    "disable_existing_loggers": false,
    "formatters": {
        "standard": {
            "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
        }
    },
    "handlers": {
        "console": {
            "class": "logging.StreamHandler",
            "level": "INFO",
            "formatter": "standard",
            "stream": "ext://sys.stdout"
        }
    },
    "loggers": {
        "": {
            "handlers": ["console"],
            "level": "INFO",
            "propagate": true
        }
    }
}
```
promptart 0.2.0
Simple frontend for accessing image and speech generation APIs.
Requires Python: >=3.9

# promptart

[![CI - Tests](https://github.com/manuelkonrad/promptart/actions/workflows/tests.yml/badge.svg)](https://github.com/manuelkonrad/promptart/actions/workflows/tests.yml)
[![CI - Bandit](https://github.com/manuelkonrad/promptart/actions/workflows/bandit.yml/badge.svg)](https://github.com/manuelkonrad/promptart/actions/workflows/bandit.yml)
[![CI - Build](https://github.com/manuelkonrad/promptart/actions/workflows/build.yml/badge.svg)](https://github.com/manuelkonrad/promptart/actions/workflows/build.yml)

[![License - MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://spdx.org/licenses/MIT.html)
[![PyPI - Version](https://img.shields.io/pypi/v/promptart.svg)](https://pypi.org/project/promptart)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/promptart.svg)](https://pypi.org/project/promptart)
[![Python Project Management - Hatch](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg)](https://github.com/pypa/hatch)
[![Linting - Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
[![Types - Mypy](https://img.shields.io/badge/types-Mypy-blue.svg)](https://github.com/python/mypy)
[![Security - Bandit](https://img.shields.io/badge/security-Bandit-yellow.svg)](https://github.com/PyCQA/bandit)

Simple frontend for accessing image and speech generation APIs. Made with Streamlit.

Currently supported:

- Black Forest Labs Flux (Text-to-Image, In/Out-Painting, Image Variation, Structural Conditioning)
- OpenAI Dall-E (Text-to-Image)
- OpenAI TTS (Text-to-Speech)

## Table of Contents

- [Getting Started](#getting_started)
- [License](#license)

## Getting Started

Install `promptart` using `pipx`:

```console
pipx install promptart
```

Alternatively, install `promptart` using `pip`:

```console
pip install --user promptart
```

Start the application:

```console
promptart
```

Additional `streamlit` arguments can be appended. For example, to change the server port:

```console
promptart --server.port 5000
```

The API keys for authentication can be provided in the following ways:

1. Setting environment variables `BFL_API_KEY` / `OPENAI_API_KEY`.
2. Creating `~/promptart/config.json` populated with parameters `bfl_api_key` / `openai_api_key`.
3. If 1. and 2. are not set, the API keys can also be provided in the frontend.

Further information about creating API keys:

- [Black Forest Labs Documentation](https://docs.bfl.ml/quick_start/create_account)
- [OpenAI Documentation](https://platform.openai.com/docs/quickstart)

To limit access to the frontend, a simple password check can be enabled by
setting the environment variable `PROMPTART_PASSWORD`.

## License

`promptart` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.
dynamicviz 1.0.1
DynamicViz provides a wrapper for generating and interpreting dynamic visualizations from traditional static dimensionality reduction visualization methods
Requires Python: >=3.8

# Dynamic visualization

Sun, E.D., Ma, R. & Zou, J. Dynamic visualization of high-dimensional data. Nat Comput Sci 3, 86–100 (2023). https://doi.org/10.1038/s43588-022-00380-4

### Eric Sun

Python package for generating bootstrap visualizations of high-dimensional data. Great for assessing stability of visualizations and increasing robustness of interpretations. Also included are methods for computing variance scores along with classical concordance scores for quantifying the quality of a visualization.

For a Quick Start guide, please refer to ``` tutorial.ipynb ```.

![plot](./pipeline.png)

## Installation and setup

### Option 1: PyPI

Install the package through PyPI with ```pip```. We recommend setting up a conda environment (or another virtual environment) first since ```dynamicviz``` currently relies on specific versions for its dependencies:

```
conda create -n myenv python=3.8
conda activate myenv

pip install dynamicviz
```



### Option 2: Github

Another way to install the package along with associated test and tutorial files is to clone the directory and then install the requirements for using the package. To do this, first clone the repository using git (you can install git following the instructions [here](https://github.com/git-guides/install-git)):

```
git clone https://github.com/sunericd/dynamicviz.git
```

We recommend setting up a conda environment to install the requirements for the package (instructions for installing conda and what conda environment can do can be found [here](https://docs.conda.io/projects/conda/en/latest/user-guide/install/index.html)). Installation of requirements can then be done with the following commands:

```
conda create -n dynamicviz python=3.8
conda activate dynamicviz

cd dynamicviz
pip install -r requirements.txt
```

To test that the installation is working correctly, you can use the Jupyter notebook ```tutorial.ipynb``` (requires installing Jupyter, instructions found [here](https://jupyter.org/install), and adding the conda environment we just created to the Jupyter notebook kernels, instructions found [here](https://medium.com/@nrk25693/how-to-add-your-conda-environment-to-your-jupyter-notebook-in-just-4-steps-abeab8b8d084)) or the test script ```test.py``` to check against expected outputs of the key methods.

For the test data in the tutorial notebook, expected run times are under 5 minutes for interactive visualization and under 10 minutes for global variance score calculation.

For Jupyter notebooks and Python scripts associated with our original publication, please refer to https://github.com/sunericd/dynamic-visualization-of-high-dimensional-data

If you find this code useful, please cite the following paper:

Sun, E.D., Ma, R. & Zou, J. Dynamic visualization of high-dimensional data. Nat Comput Sci 3, 86–100 (2023). https://doi.org/10.1038/s43588-022-00380-4
generate-gitignore 1.0.2
A CLI tool for generating .gitignore files
Requires Python: >=3.7

# Generate Gitignore

A simple Python script to generate a .gitignore file for your project using the templates from [github.com/github/gitignore](https://github.com/github/gitignore)

[![Pip install](https://img.shields.io/badge/pip_install-generate--gitignore-blue)](https://pypi.org/project/generate-gitignore/)
[![PyPI - Version](https://img.shields.io/pypi/v/generate-gitignore)](https://pypi.org/project/generate-gitignore/#history)

[![Build a Publish](https://github.com/kristiankunc/generate-gitignore/actions/workflows/build-and-publish.yml/badge.svg?event=release)](https://github.com/kristiankunc/generate-gitignore/actions/workflows/build-and-publish.yml)
[![Update Templates](https://github.com/kristiankunc/generate-gitignore/actions/workflows/update-templates.yaml/badge.svg?event=schedule)](https://github.com/kristiankunc/generate-gitignore/actions/workflows/update-templates.yaml)

## Templates

Templates are taken from the [github.com/github/gitignore](https://github.com/github/gitignore) repository and are updated every 24 hours.

The parsed list of templates can be found in the [templates.json](templates.json) file. This file is used by the script to generate the list of available templates.

I am not a maintainer of the gitignore source repository, so if you wish to have a template added, please open an issue or a pull request on the source repository as I do not maintain any custom templates.

## Usage

### Installation

Install the package using pip:

```bash
pip install generate-gitignore
```

For global installation, it is recommended to use [pipx](https://github.com/pypa/pipx) as to avoid breaking any system packages, especially on linux systems:

```bash
pipx install generate-gitignore
```

### Running

Once installed, you can run the script with the following command:

```bash
generate-gitignore
```

#### Listing all available templates

You can list all available templates with the list command:

```bash
generate-gitignore list
```

#### Searching for a template

You can search for a template with the search command, it will launch an interactive search in the terminal allowing you to search by name and apply the selected template:

```bash
generate-gitignore search
```

#### Generating a .gitignore file

If you want to use a template directly, you can use the use command followed by an array of template names:

```bash
generate-gitignore use python visualstudiocode ...
```

## Contributing

Contributions are welcome, please open an issue or a pull request if you wish to contribute. Make sure to follow the [Contribution Guidelines](CONTRIBUTING.md) before submitting a pull request.
langgraph-store-dynamodb 0.1.4
DynamoDB dtore for LangGraph
Requires Python: >=3.9

# LangGraph DynamoDB Store

A DynamoDB-based store implementation for LangGraph that allows long term memory implementation.

This implements both sync and async methods for [BaseStore](https://langchain-ai.github.io/langgraph/reference/store/#langgraph.store.base.BaseStore)

## Install package
```
pip install langgraph-store-dynamodb
```

## Usage

### Basic Initialization

```
from langgraph_store_dynamodb import DynamoDBStore

store = DynamoDBStore(
    table_name="your-dynamodb-table-name",
    max_read_request_units=10,  # Optional, default is 10
    max_write_request_units=10  # Optional, default is 10
)
```

### Alternative Initialization Using Context Manager

```
from langgraph_dynamodb_checkpoint import DynamoDBStore

with DynamoDBStore.from_conn_info(table_name="your-dynamodb-table-name") as store:
    # Use the store here
```

## Parameters

### DynamoDBStore Constructor

- `table_name` (str): Name of the DynamoDB table to use for storing checkpoints
- `max_read_request_units` (int, optional): Maximum read request units for the DynamoDB table. Defaults to 10
- `max_write_request_units` (int, optional): Maximum write request units for the DynamoDB table. Defaults to 10

## Table Structure

The store automatically creates a DynamoDB table if it doesn't exist, with the following structure:

- Partition Key (PK): String type, used for namespace
- Sort Key (SK): String type, used for memory key

## AWS Configuration

Ensure you have proper AWS credentials configured either through:
- Environment variables (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY)
- AWS credentials file (~/.aws/credentials)
- IAM role when running on AWS services

The AWS credentials should have permissions to:
- Create DynamoDB tables (if table doesn't exist)
- Read and write to DynamoDB tables

## Notes

- The store automatically creates the DynamoDB table if it doesn't exist
- Uses on-demand billing mode for DynamoDB
- Implements methods required by the LangGraph BaseStore interface
victor-smart-kill 1.1.2
A simple unofficial async Python wrapper for Victor Smart-Kill API.
Requires Python: >=3.6
Keywords: API, Victor Smart-Kill, VictorPest.com, trap

# Victor Smart-Kill

Status and history of Victor Smart-Kill WI-FI electronic mouse and rat traps from VictorPest.com can be accessed with this async Python wrapper module. The wrapper uses the same API as the Victor Pest APP.

[![License][license-shield]](LICENSE)
[![BuyMeCoffee][buymecoffeebadge]][buymecoffee]

## Getting started

This example gets a list of trap information and trap history for the first trap:

```python
from victor_smart_kill import VictorApi, VictorAsyncClient

async with VictorAsyncClient("username", "password") as client:
    api = VictorApi(client)
    traps = await api.get_traps()
    history = await api.get_trap_history(traps[0].id)
```

[buymecoffee]: https://www.buymeacoffee.com/toreamun
[buymecoffeebadge]: https://img.shields.io/badge/buy%20me%20a%20coffee-donate-yellow.svg
[license-shield]: https://img.shields.io/github/license/toreamun/victor-smart-kill

## API list methods

- get_activity_logs()
- get_mobile_apps()
- get_operators()
- get_profiles()
- get_traps()
- get_trap_history()
- get_users()

## Single item methods.

Each list method usually has corresponding metods to get a single item by id and/or url. You can find the id or url in the result from list mehods.