semvec/pypi-packages huggingface dataset:
goosedb 0.1.0
GooseDB, a chaotic wrapper around DuckDB that randomly interrupts your database operations with goose attacks! 
Requires Python: >=3.11

# GooseDB

<img src="./assets/GooseDB.png" alt="GooseDB" width="300"/>

GooseDB, a chaotic wrapper around DuckDB that randomly interrupts your database operations with goose attacks! Here are the key features:

- Maintains all DuckDB functionality while adding unpredictable goose behavior
- Configurable honk_probability to control how aggressive the goose is
- Various goose attacks ranging from judgmental stares to keyboard pecking
- Dramatic pauses during attacks to maximize chaos
- Full passthrough to DuckDB methods when the goose isn't attacking

## Installation

You can install GooseDB via pip:

```sh
pip install goosedb
```

## Usage

Here is a quick example of how to use GooseDB:

```python
import goosedb

# Create a connection to GooseDB (which wraps DuckDB)
conn = goosedb.connect()

# Set the honk probability (0.2 means 20% chance of goose interference)
conn.honk_probability = 0.2

# Execute a query
conn.execute("SELECT * FROM my_table")
```

### Configuring Goose Behavior

GooseDB lets you control the level of chaos introduced by the goose:

- **honk_probability**: A float between 0 and 1 that represents how often the goose will attack. A higher value means a more aggressive goose.

Example:

```python
conn.honk_probability = 0.5  # 50% chance of goose interference
```

### Goose Attacks

GooseDB has several types of "goose attacks":

- **Judgmental Stares**: The goose stops your query with an unsettling stare.
- **Keyboard Pecking**: The goose pecks at your virtual keyboard, potentially causing errors.
- **Dramatic Pauses**: The goose takes over and delays execution to add chaos.

### Running Queries

GooseDB fully supports DuckDB's functionality when the goose isn't attacking:

```python
# Example of a standard query
results = conn.execute("SELECT COUNT(*) FROM users").fetchall()
print(results)
```

## Reducing the Image Size in README

To make the image smaller in your README, you can use HTML to specify the image width:

```html
<img src="./assets/GooseDB.png" alt="GooseDB" width="300" />
```

This allows you to control the size directly in Markdown.

## License

This project is licensed under the MIT License. See the [LICENSE](./LICENSE) file for details.
ecr-cleaner 0.1.11
ECR Image Cleanup Tool
Requires Python: >=3.9
Keywords: aws, cleanup, ecr, package, python

## ECR Image Cleanup Tool

![Build Status](https://github.com/rahulinux/ecr-cleaner/actions/workflows/python-tests.yml/badge.svg)
[![PyPI version](https://badge.fury.io/py/ecr-cleaner.svg)](https://badge.fury.io/py/ecr-cleaner)
[![Python Versions](https://img.shields.io/pypi/pyversions/ecr-cleaner.svg)](https://pypi.org/project/ecr-cleaner/)
[![License](https://img.shields.io/github/license/rahulinux/ecr-cleaner.svg)](LICENSE)

## Table of Contents
- [Overview](#overview)
- [Features](#features)
- [Installation](#installation)
- [Usage](#usage)


## Overview

The ECR Image Cleanup Tool addresses limitations in Amazon ECR's built-in lifecycle policies, particularly for multi-architecture images. It helps prevent repositories from hitting the 10,000 image hard limit imposed by ECR by providing more flexible and architecture-aware cleanup options.

## Features

1. Supports multi-architecture image cleanup
2. Allows fine-grained control over image retention
3. Can keep a specified number of recent images for each tag
4. Manages untagged images separately
5. Provides a dry-run option to preview actions before execution


### Installation

```shell
pip install ecr-cleaner
```

### Usage

Support following CLI argument

```shell
usage: ecr_cleaner [-h] [--config-file CONFIG_FILE] [--repositories REPOSITORIES [REPOSITORIES ...]] [--region REGION] [--batch-size BATCH_SIZE] [--dry-run] [--debug]

ECR Cleaner CLI

options:
  -h, --help            show this help message and exit
  --config-file CONFIG_FILE
                        Path to configuration file in YAML format. See example in README.md
  --repositories REPOSITORIES [REPOSITORIES ...]
                        List of repository names and policies(keep-most-recent). (e.g. my-repo:latest=3,tag-prefix=2,untagged=10)
  --region REGION       ECR region
  --batch-size BATCH_SIZE
                        Max number of images that can be deleted in one call
  --dry-run             Check result without deleting images
  --debug               Enable debug logging
```

Clean-up will keep most recent number of images based on inputs and it will delete remaining matching tagPrefix

## Config example

```yaml
region: eu-central-1
repositories:
  - rahul-test:pinned=1,untagged=3
```

## Helm chart

## Prerequisites

AWS IAM role permission to manage ECR repositories

```json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "ecr-cleaner",
      "Effect": "Allow",
      "Action": [
        "ecr:BatchDeleteImage",
        "ecr:BatchGetImage",
        "ecr:DescribeImages",
        "ecr:ListImages",
        "ecr:DescribeRepositories"
      ]
    }
  ]
}
```

## Installation

[Helm Readme](./charts/ecr-cleaner/README.md)
HikSon 0.2.0
An easier method to read, edit, and save data in JSONs
Requires Python: >=3.6


# HikSon

HikSon is a simple and efficient Python package designed to make it easier to **read**, **save**, and **delete** JSON data files. This package provides a clean and intuitive API for handling basic JSON file operations in Python.

## Features

- **Read JSON**: Easily load and return data from a JSON file.
- **Save JSON**: Save or overwrite data in a JSON file with simple method calls.
- **Delete JSON**: Remove JSON files from your system.

## Installation

HikSon can be installed using pip (once published on PyPI):
```bash
pip install HikSon
```

Or you can clone the repository and install it manually:
```bash
git clone https://github.com/1cz1/HikSon.git
cd HikSon
pip install .
```

## Usage

### 1. **Reading a JSON file:**
Use the `read_json` method to load data from a JSON file.
```python
from hikson import HikSon

data = HikSon.read_json('data.json')
print(data)
```

### 2. **Saving data to a JSON file:**
Use the `save_json` method to write or update data in a JSON file.
```python
from hikson import HikSon

data = {
    "name": "Hikaro",
    "skills": ["Cybersecurity", "Programming"]
}

HikSon.save_json('data.json', data)
```

### 3. **Deleting a JSON file:**
Use the `delete_json` method to delete a JSON file from the system.
```python
from hikson import HikSon

HikSon.delete_json('data.json')
```

## API Reference

### `read_json(file_path)`
- **Description**: Reads a JSON file from the provided file path and returns its data.
- **Arguments**: 
  - `file_path` (str): The path to the JSON file.
- **Returns**: The contents of the JSON file as a Python dictionary or list.
- **Exceptions**: Raises an exception if the file is not found or contains invalid JSON.

### `save_json(file_path, data)`
- **Description**: Saves Python data (dict, list, etc.) to a JSON file at the specified path.
- **Arguments**: 
  - `file_path` (str): The path to save the JSON file.
  - `data` (dict or list): The data to be saved.
- **Returns**: "Done" when the file is successfully saved.
- **Exceptions**: Raises an exception if thereâ€™s an issue saving the file.

### `delete_json(file_path)`
- **Description**: Deletes a JSON file from the specified path.
- **Arguments**: 
  - `file_path` (str): The path to the JSON file to be deleted.
- **Returns**: "Done" when the file is successfully deleted.
- **Exceptions**: Raises an exception if the file does not exist.

## Contributing

Contributions, issues, and feature requests are welcome! Feel free to check the [issues page](https://github.com/yourusername/HikSon/issues) or open a pull request.

## Author

**Hikaro**  
Cybersecurity & Programmer  
[Instagram: @hikaro.yy](https://instagram.com/hikaro.yy)

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
barking 0.0.1
This is a template repository for Python projects that use uv for their dependency management.
Requires Python: <4.0,>=3.9
Keywords: python

# barking

[![Release](https://img.shields.io/github/v/release/bryanhann/barking)](https://img.shields.io/github/v/release/bryanhann/barking)
[![Build status](https://img.shields.io/github/actions/workflow/status/bryanhann/barking/main.yml?branch=main)](https://github.com/bryanhann/barking/actions/workflows/main.yml?query=branch%3Amain)
[![codecov](https://codecov.io/gh/bryanhann/barking/branch/main/graph/badge.svg)](https://codecov.io/gh/bryanhann/barking)
[![Commit activity](https://img.shields.io/github/commit-activity/m/bryanhann/barking)](https://img.shields.io/github/commit-activity/m/bryanhann/barking)
[![License](https://img.shields.io/github/license/bryanhann/barking)](https://img.shields.io/github/license/bryanhann/barking)

This is a template repository for Python projects that use uv for their dependency management.

- **Github repository**: <https://github.com/bryanhann/barking/>
- **Documentation** <https://bryanhann.github.io/barking/>

## Getting started with your project

### 1. Create a New Repository

First, create a repository on GitHub with the same name as this project, and then run the following commands:

```bash
git init -b main
git add .
git commit -m "init commit"
git remote add origin git@github.com:bryanhann/barking.git
git push -u origin main
```

### 2. Set Up Your Development Environment

Then, install the environment and the pre-commit hooks with

```bash
make install
```

This will also generate your `uv.lock` file

### 3. Run the pre-commit hooks

Initially, the CI/CD pipeline might be failing due to formatting issues. To resolve those run:

```bash
uv run pre-commit run -a
```

### 4. Commit the changes

Lastly, commit the changes made by the two steps above to your repository.

```bash
git add .
git commit -m 'Fix formatting issues'
git push origin main
```

You are now ready to start development on your project!
The CI/CD pipeline will be triggered when you open a pull request, merge to main, or when you create a new release.

To finalize the set-up for publishing to PyPI, see [here](https://fpgmaas.github.io/cookiecutter-uv/features/publishing/#set-up-for-pypi).
For activating the automatic documentation with MkDocs, see [here](https://fpgmaas.github.io/cookiecutter-uv/features/mkdocs/#enabling-the-documentation-on-github).
To enable the code coverage reports, see [here](https://fpgmaas.github.io/cookiecutter-uv/features/codecov/).

## Releasing a new version



---

Repository initiated with [fpgmaas/cookiecutter-uv](https://github.com/fpgmaas/cookiecutter-uv).
microtc 2.4.13
A generic minimal text classifier

microTC
==================================

.. image:: https://github.com/INGEOTEC/microtc/actions/workflows/test.yaml/badge.svg
	   :target: https://github.com/INGEOTEC/microtc/actions/workflows/test.yaml

.. image:: https://coveralls.io/repos/github/INGEOTEC/microtc/badge.svg?branch=develop
   :target: https://coveralls.io/github/INGEOTEC/microtc?branch=develop

.. image:: https://badge.fury.io/py/microtc.svg
   :target: https://badge.fury.io/py/microtc

.. image:: https://dev.azure.com/conda-forge/feedstock-builds/_apis/build/status/microtc-feedstock?branchName=main
   :target: https://dev.azure.com/conda-forge/feedstock-builds/_build/latest?definitionId=16441&branchName=main

.. image:: https://img.shields.io/conda/vn/conda-forge/microtc.svg
   :target: https://anaconda.org/conda-forge/microtc

.. image:: https://img.shields.io/conda/pn/conda-forge/microtc.svg
   :target: https://anaconda.org/conda-forge/microtc

.. image:: https://readthedocs.org/projects/microtc/badge/?version=docs 	    
   :target: https://microtc.readthedocs.io/en/docs/?badge=docs

.. image:: https://colab.research.google.com/assets/colab-badge.svg
   :target: https://colab.research.google.com/github/INGEOTEC/microtc/blob/master/docs/microTC_Quickstart.ipynb	    

microTC is a minimalist text classifier, that is, it is designed to tackle text-classification problems in an agnostic way,
being both domain and language independent. 

microTC is intentionally simple, so only a small number of features
were implemented. However, it uses a some complex tools from numpy
and scikit-lean. The number of dependencies is limited and fulfilled
by almost any Scientific Python distributions, e.g., `Anaconda <https://www.continuum.io/downloads>`_.

The documentation is on `readthedocs <https://microtc.readthedocs.io>`_.