semvec/pypi-packages huggingface dataset:
icestream 0.1.6
Add your description here
Requires Python: >=3.13

# icestream
The Table-ator-inator is the easiest way to cheaply ingest data into your lakehouse in the whole Tri-State Area.

### Useful commands

```shell
docker run --name icestream-postgres -e POSTGRES_USER=icestream -e POSTGRES_PASSWORD=icestream -e POSTGRES_DB=icestream_dev -p 5432:5432 -d postgres:17
export ICESTREAM_DATABASE_URL="postgresql+asyncpg://icestream:icestream@localhost:5432/icestream_dev"
alembic upgrade head
```
greednought 0.1.3
A text adventure game created for Week 5 of Hack Club's Siege
Requires Python: >=3.12

# greednought
A text adventure game. You descend through the "Dungeon of Greed", collecting coins and items to win the Legally Distinct Schmamework 69.

## installation
You may either download the greednought.py file directly from this repository, or directly install it via `pip/pipx install greednought`.

## usage
Either run your python file with `python greednought.py` or run the command hook: `greednought`

## credits
me, with the help of a Really Cool Sword.

## why
This was done for Week 5 of Hack Club's https://siege.hackclub.com/ .

I... have no idea what else to put here. If you'd like to see a full map of the game (SPOILERS!!!!!) you may view it here:
https://docs.google.com/spreadsheets/d/1Sx7_NewRofRFaFdDXNJEN3AlVnFKw2jPY1nu6lTMaI4/
unicode-text-to-identifier 0.1.0a0
A tool that converts arbitrary text (like user input or file names) into valid Python identifiers while preserving as much of the original meaning as possible.
Requires Python: >=2

A tool that converts arbitrary text (like user input or file names) into valid Python identifiers while preserving as much of the original meaning as possible.

## Installation

```bash
pip install unicode-text-to-identifier
```

## Usage

```python
# coding=utf-8
from unicode_text_to_identifier import unicode_text_to_identifier

assert unicode_text_to_identifier(u"") == u"_"
assert unicode_text_to_identifier(u" \r\n\t") == u"_"
assert unicode_text_to_identifier(u"123abc") == u"_123abc"
assert unicode_text_to_identifier(u"&abc 123") == u"_abc_123"
assert unicode_text_to_identifier(u"  hello  world  $") == u"_hello_world__"
assert unicode_text_to_identifier(u"测试@unicode") == u"测试_unicode"
```

## How It Works

First, `get_unicode_character_type()` categorizes each Unicode character into one of four types:

- `LETTER_OR_UNDERSCORE` (Unicode category starting with 'L' or underscore `_`)
- `DECIMAL_DIGIT` (Unicode category 'Nd')
- `SPACE_OR_CONTROL` (Unicode categories starting with 'Z' or 'Cc')
- `OTHER` (all other characters)

Then, it implements the following conversion rules using a state machine:

- The first character must be a letter/underscore. If the first character is a digit, prepend `_` to make it valid.
- Subsequent valid characters (letters/underscores/digits) are kept as-is.
- Other characters are replaced with underscores, but whitespace/control character sequences are collapsed into single underscores.
- Ensures the output is non-empty (appends `_` if empty).

## Contributing

Contributions are welcome! Please submit pull requests or open issues on the GitHub repository.

## License

This project is licensed under the [MIT License](LICENSE).
giso 1.0.0
A simple command line tool to help with geocoding country/region ISO 3166-2 codes
Requires Python: >=3.10

[![PyPI - Version](https://img.shields.io/pypi/v/giso)](https://pypi.org/project/giso/)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/giso)](https://pypi.org/project/giso/)
[![PyPI Downloads](https://static.pepy.tech/badge/giso/month)](https://pepy.tech/projects/giso)
[![License: MIT](https://img.shields.io/badge/License-MIT-lightgrey.svg?logo=)](https://github.com/corbel-spatial/giso/blob/main/LICENSE)
[![Pixi Badge](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/prefix-dev/pixi/main/assets/badge/v0.json)](https://pixi.sh)

# giso

A simple command line tool to help with geocoding country/region [ISO 3166-2](https://en.wikipedia.org/wiki/ISO_3166-2) codes.

Includes a public domain reference dataset from [Natural Earth Data](https://github.com/nvkelso/natural-earth-vector)
which is stored in [GeoParquet](https://geoparquet.org/) format and is accessed with [SedonaDB](https://sedona.apache.org/sedonadb/latest/).

## Installation

```shell
python -m pip install giso
```

## Basic Usage

`giso` takes one of two inputs:

- A longitude/latitude coordinate pair. (Decimal degrees in WGS 1984 separated by a comma or a space.)
Returns the corresponding ISO 3166-2 code.

```shell
giso -122.2483823, 37.8245529
# US-CA
```

- A valid ISO 3166-2 code. Returns the corresponding geometry as Well-Known Text (WKT).

```shell
giso US-CA
# MULTIPOLYGON (((-114.724285 32.712836, -114.764541 32.709839, [...]
```

Returns `None` if there are no hits.

`giso` can also be used as a Python package:

```python
>>> import giso
>>> giso.reverse_geocode(103.8455041, 1.2936855)
'SG-01'
>>> giso.geocode("SG-01")
< POLYGON((103.898 1.305, 103.888 1.301, 103.853 1.277, 103.847 1.272, 103.8 ... >
```


## References

- [Natural Earth Data homepage](https://www.naturalearthdata.com/)
currency-converter-and-calculator 0.2.0
A currency converter and calculator
Requires Python: >=3.6

# Coin-Calculator and currency converter
A calculator! How fun! Intended for people like me who don't want to use their brains. Use it to calculate how many coins ya got! Also convert currencies with the currency converter!

## Demo:
To demo the app, you can either download the source code and the required dependency, and run it yourself, or, I have made a short video demom-ing the app if you would rather not download random files onto your device:


## Features:
 - Simple calculator, able to do addition, subtraction, multiplication and division.
 - Currency converter that can convert between USD, CAD and EUR. (more may be added soon)
 - History; shows the last 5 calculations you have done, whether it was done with the calculator or the converter.
 - Extended history; a button that opens a new window showing the last 20 calculations you have done, rather than the last 5.
 - Dark and light modes.

## Dependencies:
FreeSimpleGUI, https://github.com/spyoungtech/FreeSimpleGUI

## Disclaimer!!
The converter may not be 100% accurate! The conversion rates are based off of what the data from exchange-rates.org said at the time of coding the application, (2025/10/04). Use this ONLY to get a general gist of what different currencies are like. if you need something more accurate, a web search will serve you better :)
testionary 0.2.0
A library providing dictionary types for interspecting code behavior during test or debugging.
Requires Python: >=3.10

# Testionary

[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

A library providing tools to inspect dicionaries during testing. 

## Installation

Using pip:
```
pip install testionary
```
or using uv for project management:

```
uv add testionary
```

## Usage

### Read and Modified attributes
Accessing a value using e.g. the `[]`-operator or `dict.get()` method will cause the key to be added to `TrackingDict.accessed_keys`. Setting a value e.g. using assignment together with the `[]`-operator will get tracked using `TrackingDict.modified_keys`. Here is a small example:
```python
# My library code:
>>> def set_danger(enemy):
...     if enemy["type"] == "Rabbit":
...         enemy["danger"] = 9000


# My test:
>>> from testionary.tracking_dict import TrackingDict
>>> tracked_dict = TrackingDict({"type": "Rabbit", "danger": 42})
>>> set_danger(tracked_dict)
>>> "type" in tracked_dict.accessed_keys
True
>>> "danger" in tracked_dict.modified_keys
True

```

#### Tracked Access methods
- `[]`
- `.get`


#### Tracked Modification methods
- `[] =`
- `.update()`
- `|=`

### Iteration
When iterating over dictionary, e.g. when using dictionary comprehension, you might be accessing a few or all of the items. However, in these scenarios it is common to actually interate over all the key-value pairs while filtering on some condition. Instead of attemting to track each access with `TrackingDict.accessed_keys`, a boolean attribute, `TrackingDict.has_been_iterated`, is used instead. Here is an example of this being used:
```python
# Libray code
>>> def vals_as_str(_dict):
...    return {k: str(v) for k,v in _dict.items()}

# My test:
>>> from testionary.tracking_dict import TrackingDict

>>> tracked_dict = TrackingDict({"type": "Rabbit", "danger": 42, "hp": 100, "armor": 100})
>>> vals_as_str(tracked_dict)
{'type': 'Rabbit', 'danger': '42', 'hp': '100', 'armor': '100'}
>>> tracked_dict.has_been_iterated
True

```

#### Tracked Iteration Methods
- `__iter__()` called by `iter()` and `for`
- `__contains__()`, called by `in` operator in e.g. `if "key" in my_dict`
- `.keys()`
- `.values()`
- `.items()`

For `.keys()`, `.values()`, and `.items()`, iteration is assumed following calls to these methods. The returned dict-views are not inspected.
faquilizer 0.1.2
A Jupyter Notebook template for processing lists of URLs with AI.
Requires Python: >=3.8

# Faquilizer

A simple, `pip install`-able package that provides a Jupyter Notebook template for processing lists of URLs with AI.

## Usage

1.  In a new notebook (like Google Colab):
    ```python
    !pip install faquilizer
    ```
2.  In the next cell, run:
    ```python
    import faquilizer
    ```
3.  Copy the template output and paste it into a new cell to get started.