semvec/pypi-packages huggingface dataset:
texase 0.3.1
Textual user interface for ASE db.
Requires Python: ~=3.9


# texase

> Texase is a TUI[^1] for [ASE](https://wiki.fysik.dtu.dk/ase/) databases. It allows you to quickly get an overview, navigate and manipulate an ASE database.

[^1]: Textual User Interface (Also known as a Terminal/Text User Interface)

> Built with [Textual](https://textual.textualize.io/)

![PyPI - Version](https://img.shields.io/pypi/v/texase)
[![MPL License](https://img.shields.io/badge/License-MPL-green.svg)](https://github.com/steenlysgaard/texase/blob/main/LICENSE)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/texase)
![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/steenlysgaard/texase/python-package.yml)


![Demo](demo.gif)


## Installation

Install texase with pip

```bash
pip install texase
```

## Usage

After installation do `texase file.db` where `file.db` is your ASE database.

- Press __`?`__ to view all keybindings

- Navigation

Move the cursor with the arrow keys to select different rows and columns.

- Press `Space` to mark a row.

Marking can be used with many subsequent action, e.g. view, export, add/remove key value pairs etc.

- Filter (__`/`__) and search (__`Ctrl-s`__)

Show only rows based on a filter. Search for a certain string/regex, subsequent key presses on `Ctrl-s` moves the cursor to the next match.

- Viewing (__`v`__)

Open the current row or all marked rows with ASE GUI.

- Importing/Exporting trajectories/databases (__`i`__/__`x`__)

Import an external file to the database or save current or all marked rows to a file.

- Add/remove/edit key value pairs (__`k`__/__`d`__/__`e`__)

Manipulate the key value pairs as much as you like. Mind that some key value pairs belonging to the `Atoms` object cannot be changed.

- Press `Enter` and see and modify all the details of a row.

- Adding/removing columns (__`+`__/__`-`__)

Remove the column of the current cursor with `-` and add columns not shown with `+`. Columns can also be added by clicking the corresponding key at the bottom of the screen. Chosen columns are saved between invocations of the same database.

- Deleting rows (__`#`__)
- Suspend the app (__`Ctrl-z`__)

This keeps the texase with the database loaded in memory and returns to the command line. The app can be brought back to focus with `fg`. It is possible to suspend more invocations of texase and selectively bring them to the foreground.

## Background

I use the database in ASE a lot. The command line interface `ase db` could slow me down a bit though when I wanted to check out the results of some calculations and then view a structure or get some output in another way. I would normally go:
- `ase db file.db`
- `ase db -L 0 file.db`
- `ase db -s energy file.db`
- `ase gui file.db@id=32`

Now I can just do `texase file.db` and navigate with single key presses.



## License

[MPL](https://github.com/steenlysgaard/texase/blob/main/LICENSE)
nicescad 0.3.0
nicescad brings OpenScad to the browser (again)
Requires Python: >=3.10
Keywords: 3D-printing, nicegui, openscad, scad

# nicescad
nicescad brings OpenScad to the browser (again)

[![Join the discussion at https://github.com/WolfgangFahl/nicescad/discussions](https://img.shields.io/github/discussions/WolfgangFahl/nicescad)](https://github.com/WolfgangFahl/nicescad/discussions)
[![pypi](https://img.shields.io/pypi/pyversions/nicescad)](https://pypi.org/project/nicescad/)
[![Github Actions Build](https://github.com/WolfgangFahl/nicescad/actions/workflows/build.yml/badge.svg)](https://github.com/WolfgangFahl/nicescad/actions/workflows/build.yml)
[![PyPI Status](https://img.shields.io/pypi/v/nicescad.svg)](https://pypi.python.org/pypi/nicescad/)
[![GitHub issues](https://img.shields.io/github/issues/WolfgangFahl/nicescad.svg)](https://github.com/WolfgangFahl/nicescad/issues)
[![GitHub closed issues](https://img.shields.io/github/issues-closed/WolfgangFahl/nicescad.svg)](https://github.com/WolfgangFahl/nicescad/issues/?q=is%3Aissue+is%3Aclosed)
[![API Docs](https://img.shields.io/badge/API-Documentation-blue)](https://WolfgangFahl.github.io/nicescad/)
[![License](https://img.shields.io/github/license/WolfgangFahl/nicescad.svg)](https://www.apache.org/licenses/LICENSE-2.0)

## Demo
[Demo](http://nicescad.bitplan.com/)

## Docs and Tutorials
[Wiki](https://wiki.bitplan.com/index.php/nicescad)

## Examples
* [Basics/logo](https://raw.githubusercontent.com/openscad/openscad/master/examples/Basics/logo.scad)
* [Intersection](https://raw.githubusercontent.com/WolfgangFahl/nicescad/main/examples/intersection.scad)

## Links
* https://openscad.org/
* https://nicegui.io
### Alternative online editors
* https://ochafik.com/openscad2/
* http://www.implicitcad.org/editor
* https://www.blockscad3d.com/editor/
* https://openjscad.azurewebsites.net/
* https://openjscad.xyz/
### Jupyter notebook integration
* https://github.com/nickc92/ViewSCAD
### Python integration
* https://github.com/jeff-dh/SolidPython
llama-index-readers-hive 0.3.1
llama-index readers hive integration
Requires Python: <4.0,>=3.9
Keywords: HDFS, Hadoop, Hive

# Hive Loader

> [!NOTE] > _This package has been deprecated starting from `v0.3.1`_

```bash
pip install llama-index-readers-hive
```

The Hive Loader returns a set of texts corresponding to documents from Hive based on the customized query.
The user initializes the loader with Hive connection args and then using query to fetch data from Hive.

## Usage

Here's an example usage of the hiveReader to load 100 documents.

```python
from llama_index.readers.hive import HiveReader

reader = HiveReader(
    host="localhost",
    port=10000,
    database="PERSON_DB",
    username="hiveuser_test",
    auth="NOSASL",
)

query = "SELECT * FROM p1 LIMIT 100"
documents = reader.load_data(query=query)
print(documents)
# test with params
query = "SELECT * FROM p1 WHERE id = %s"
params = ("1",)
documents1 = reader.load_data(query=query, params=params)
```

This loader is designed to be used as a way to load data into [LlamaIndex](https://github.com/run-llama/llama_index/).
pssapi 0.6.0
A wrapper for the Pixel Starships API.
Requires Python: >=3.11
Keywords: API, PSS, Pixel Starships

# pssapi.py

<a href="https://discord.gg/kKguSec" target="_blank"><img src="https://discord.com/api/guilds/565819215731228672/embed.png" alt="Support Discord server invite"></a>
<a href="https://pypi.org/project/pssapi" target="_blank"><img src="https://img.shields.io/pypi/status/pssapi?color=%23DAB420&label=status" alt="Development status"></a>
<a href="https://pypi.org/project/pssapi" target="_blank"><img src="https://img.shields.io/pypi/v/pssapi?color=%23DAB420&label=pypi%20package" alt="Package version"></a>
<a href="https://pypi.org/project/pssapi" target="_blank"><img src="https://img.shields.io/pypi/pyversions/pssapi.svg?color=%23DAB420" alt="Supported Python versions"></a>
<img src="https://img.shields.io/codecov/c/github/pss-tools-development/pssapi.py" alt="Code coverage">

> An async client library to access the [Pixel Starships API](https://pixelstarships.com).

# ✨ Features
- **Fully typehinted** so your favorite IDE can assist you with code completion.
- **Easy access** to any instance of a **Pixel Starships API** server.
- **Fast setup** to get you started quickly.
- **Caching versioned endpoints** to cut down traffic between your app and the servers.

# 🔍 Future plans

- Use and support [pydantic](https://docs.pydantic.dev/latest/) models
- Implement aliases and properties to map values displayed in-game to the raw values returned by the API

# 🚀 Demo
To retrieve a list of all item designs:
```python
import asyncio
from pssapi import PssApiClient

async def main():
    client = PssApiClient()

    item_designs = await client.item_service.list_item_designs()
    print(f"Found {len(item_designs)} item designs.")
    print(f"First item: {item_designs[0].item_design_name}")

if __name__ == "__main__":
    asyncio.run(main())
```

## ⚙️ Installation
**Python 3.11 or higher is required**

To install the latest version of this library, run the following command:
```sh
pip install -U pssapi
```

# 🖊️ Contribute
If you ran across a bug or have a feature request, please check if there's [already an issue](https://github.com/PSS-Tools-Development/pssapi.py/issues) for that and if not, [open a new one](https://github.com/PSS-Tools-Development/pssapi.py/issues/new).

If you want to fix a bug or add a feature, please check out the [Contribution Guide](CONTRIBUTING.md).

# 🆘 Support
If you need help using the library or want to contribute, you can join the support Discord at: [discord.gg/kKguSec](https://discord.gg/kKguSec)

# 👥 Contributors

- [The worst.](https://github.com/Zukunftsmusik)
- [Solevis](https://github.com/solevis)
- [architelos](https://github.com/architelos)

# 🔗 Links
- Documentation (tbd)
- [Official Support Discord server](https://discord.gg/kKguSec)
- [Pixel Starships homepage](https://pixelstarships.com)
- [Official Pixel Starships Discord](https://discord.gg/pss) (not affiliated to this library)
mcp-web-fetch 0.3.0
Fetch data from ANY website
Requires Python: <3.13,>=3.12

# MCP-Web-Fetch
A Model Context Protocol (MCP) server for fetching webpages including html/pdf/plain text type content.

## Available Tools
- `fetch-web`: Fetch URL and return content according to its content type.
  - `url`: URL to fetch
  - `raw`: Whether to return raw content

## Installation
### Using uv(recommended)
When using `uv`, no specific installation is needed. We will use `uvx` to directly run `mcp-web-fetch`.

### Using pip
```bash
pip install mcp-web-fetch
```
After installation, you can run the server using
```bash
python -m mcp-web-fetch
```

## Configuration
Add to your local client
```json
{
    "mcpServers": {
        "mcp-web-fetch": {
            "command": "uvx",
            "args": ["mcp-web-fetch"]
        }
    }
}
```
or using docker(after publish done)
```json
{
    "mcpServers": {
        "mcp-web-fetch": {
            "command": "docker",
            "args": [
                "run",
                "-i",
                "--rm",
                "ghcr.io/mcp-servers/fetch:latest"
            ]
        }
    }
}
```

or Fetch and run from remote repository

```json
{
  "mcpServers": {
    "mcp-web-fetch": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/pathintegral-institute/mcp.science#subdirectory=servers/web-fetch",
        "mcp-web-fetch"
      ]
    }
  }
}
```

## Customization
By default, the server will use a default user-agent for fetching web content. You can customize the user-agent by setting the `user_agent` in args
```
uvx mcp-web-fetch --user-agent "Your User-Agent"
```
geochatt 0.3.1
Utility Functions for Working with Open GeoSpatial Data about Chattanooga
Keywords: data, python

# geochatt
Utility Functions for Working with Open GeoSpatial Data about Chattanooga

## features
- very fast: uses [STRTree](https://shapely.readthedocs.io/en/2.0.4/strtree.html) for super fast reverse geocoding
- get address from point
- get city council district from point
- get municipality from point
- get zip code from point

## install
```sh
pip install geochatt
```

## usage
```py
import geochatt

geochatt.get_address(longitude=-85.3076591, latitude=35.0432979)
"101 E 11TH ST"

geochatt.get_city_council_district(longitude=-85.3076591, latitude=35.0432979)
8

geochatt.get_municipality(longitude=-85.3076591, latitude=35.0432979)
"Chattanooga"

geochatt.get_zipcode(longitude=-85.3076591, latitude=35.0432979)
37402

# get_parcel returns a string representing a Well-known text-format polygon
geochatt.get_parcel(address="101 E 11TH ST")
'POLYGON ((-85.3069572 35.043897, -85.3074818 35.0440926, -85.3075952 35.0438743, -85.3078311 35.0434433, -85.3073192 35.0432494, -85.3069718 35.0438707, -85.3069572 35.043897))'

# get_parcel_centroid returns a Shapely Point object
geochatt.get_parcel_centroid(address="101 E 11TH ST")
<POINT (-85.307 35.044)>
```

## cli usage
```sh
$ pip install geochatt

$ geochatt get-address --latitude="35.0432979" --longitude="-85.3076591"
101 E 11TH ST

$ geochatt get-city-council-district --latitude="35.0432979" --longitude="-85.3076591"
8

$ geochatt get-municipality --latitude="35.0432979" --longitude="-85.3076591"
Chattanooga

$ geochatt get-parcel --address="101 east 11th street"
POLYGON ((-85.3069572 35.043897, -85.3074818 35.0440926, -85.3075952 35.0438743, -85.3078311 35.0434433, -85.3073192 35.0432494, -85.3069718 35.0438707, -85.3069572 35.043897))

$ geochatt get-parcel-centroid --address="101 east 11th street"
POINT (-85.30739570641228 35.0436712625469)

$ geochatt get-zipcode --latitude="35.0432979" --longitude="-85.3076591"
37402
```

## performance
Reverse geocoding is super fast thanks to [STRTree](https://shapely.readthedocs.io/en/2.0.4/strtree.html).
The performance test of geocoding 1 million random points takes 122.900 seconds, which is 0.000122 seconds per point.
jaraco.logging 3.4.0
Support for Python logging facility
Requires Python: >=3.9

.. image:: https://img.shields.io/pypi/v/jaraco.logging.svg
   :target: https://pypi.org/project/jaraco.logging

.. image:: https://img.shields.io/pypi/pyversions/jaraco.logging.svg

.. image:: https://github.com/jaraco/jaraco.logging/actions/workflows/main.yml/badge.svg
   :target: https://github.com/jaraco/jaraco.logging/actions?query=workflow%3A%22tests%22
   :alt: tests

.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json
    :target: https://github.com/astral-sh/ruff
    :alt: Ruff

.. image:: https://readthedocs.org/projects/jaracologging/badge/?version=latest
   :target: https://jaracologging.readthedocs.io/en/latest/?badge=latest

.. image:: https://img.shields.io/badge/skeleton-2025-informational
   :target: https://blog.jaraco.com/skeleton

Argument Parsing
================

Quickly solicit log level info from command-line parameters::

    parser = argparse.ArgumentParser()
    jaraco.logging.add_arguments(parser)
    args = parser.parse_args()
    jaraco.logging.setup(args)
pyPCG-toolbox 0.1b5
A PCG processing toolbox
Requires Python: >=3.10

# pyPCG toolbox
Common processing algorithms and segmemtation for PCG signals

## Installation
**IMPORTANT!**

pyPCG is dependent on a package `hsmmlearn` which is currently not available on PyPi.

To solve this issue, install `hsmmlearn` separately from https://github.com/jvkersch/hsmmlearn
```
pip install git+https://github.com/jvkersch/hsmmlearn@master
```
*Note:* Python 3.10 is supported but 3.11 is recommended

### From PyPi
Install `pyPCG` using pip

```
pip install pyPCG_toolbox
```

### From source
Clone the git repository
```
git clone https://github.com/mulkr/pyPCG-toolbox.git
```
Change directory to the cloned repository
```
cd pyPCG-tooblox
```
Install with pip
```
pip install .
```

## Building the documentation
Install required packages
```
pip install -r docs/requirements.txt
```
Call Sphinx build command
```
sphinx-build -M html docs/source docs/build
```
On Windows you can also run the `make.bat` file
```
.\docs\make.bat html
```

The documentation should be available in the `docs/build` directory as html files<br>
This includes the example codes as tutorials

## Correspondence
Kristóf Müller (muller.kristof@itk.ppke.hu)<br>
Márton Áron Goda (goda.marton.aron@itk.ppke.hu)
data-pokemon-vgc 0.2.3
A parser and downloader for Pokémon VGC tournament data from rk9.gg
Requires Python: >=3.8

# Data-Pokemon-VGC

A Python package to download and parse Pokémon VGC tournament data from rk9.gg, including players, pairings, and team details.

## Features

- Download tournament data by tournament code
- Extract players and their teams with detailed Pokémon info
- Save data as JSON files in a structured format
- Command-line interface for easy usage

## Installation

```bash
pip install Data-Pokemon-VGC
```

Or clone the repo and install locally:

```bash
git clone https://github.com/Rxdsilver/Data-Pokemon-VGC.git
cd Data-Pokemon-VGC
pip install .
```

## Usage

Run this script to download tournament:

```bash
python -m scripts.download_tournament 'RK9_Code'
```

Run this script to get usage:

```bash
python -m scripts.compute_usage 'RK9_Code'
```

Run this script to get player's teams:
```bash
python -m scripts.export_player_teams "Hippolyte Bernard [FR]"
```



This will download tournament info, players, pairings, and teams, and save JSON files in the data/ directory named with the tournament code.

## Project Structure

```graphql
├── scripts/
│   └── download_tournament.py   # Main entry point CLI script
├── tournament_parser/
│   ├── models.py                # Data classes for Tournament, Player, Team, etc.
│   ├── parser.py                # Parsing logic from HTML pages
│   ├── utils.py                 # Helper functions (e.g. URL builders)
│   └── save.py                  # Functions to save JSON data
├── data/                       # Output JSON files saved here
├── tests/                      # Unit tests
```

## Development & Tests

- Python 3.11+
- Use `pytest` to run tests

## Continuous Integration

This project uses GitHub Actions for automated bumping version and publishing to PyPI. On every push and pull request, the workflow check commit name to trigger action or not.

Example:

```bash
git commit -m "<some change> bump: patch" # 0.1.2 -> 0.1.3
git commit -m "<some change> bump: minor" # 0.1.2 -> 0.2.0
git commit -m "<some change> bump: major" # 0.1.2 -> 1.0.0
```