semvec/pypi-packages huggingface dataset:
vo-models 0.5.1
Pydantic data models for IVOA protocols
Requires Python: >=3.10
Keywords: ivoa, pydantic, pydantic-xml

# vo-models

`vo-models` is an open-source project to provide Python models for [IVOA](https://www.ivoa.net/) service protocols.

The project is designed to be used by IVOA members, service implementors, and developers to help facilitate the development of IVOA-compliant services and clients.

## Features

- **Pydantic-xml Models:** The project includes Python models for IVOA protocols, using [pydantic-xml](https://github.com/dapper91/pydantic-xml). Based on [Pydantic](https://docs.pydantic.dev/latest/), these models describe transactions for an IVOA protocol, such as UWS, and feature automatic validation, parsing and serialization of XML data for use with Python clients and web frameworks.

- **Expandability:** The project is designed with future expansion in mind. Plans include extending the schema and models to cover other IVOA standards and future versions of existing standards where possible.

## Protocols

The following IVOA protocols are currently supported:

- **UWS (Universal Worker Service) version 1.1**
- **VOSI (IVOA Support Interfaces) version 1.1**
  - VOSI Availability
  - VOSI Tables
  - VOSI Capabilities
- **VODataService version 1.2 (limited)**
  - DataType
  - FKColumn
  - ForeignKey
  - Table
  - TableParam
  - TableSchema
  - TableSet
  - others
- **VOResource version 1.1**
- **TAPRegExt version 1.0**
- **VORegistry 1.1**
- **RegistryInterfaces version 1.0**

You can read more about using these models in our documentation: https://vo-models.readthedocs.io/


## Installation

The latest version of the project can be installed from PyPI:

```bash
pip install vo-models
```

### Conda

To install the project using Conda, you can use the provided environment file:

```bash
git clone https://github.com/spacetelescope/vo-models.git
cd vo-models
conda env create -f environment.yml
conda activate vo-models
pip install -r requirements.txt
pip install .
```

For active development, install the project in development mode:

```bash
pip install -e .[dev,test]
```

### Contributing

Contributions to the project are more than welcome. Collaboration and discussion with other IVOA members, service implementors, and developers is what started this project, and is what makes the IVOA great.

If you are interested in contributing, whether that be adding a new protocol, improving the schema, fixing a bug or even a typo, please feel free to open an issue or pull request.


### License

This project is licensed under the [MIT License](LICENSE).
arxiv-cli-tools 0.1.0
Command-line interface for searching and downloading arXiv papers.
Requires Python: >=3.9
Keywords: arxiv, cli, search, papers

# arxiv-cli-tools

Command-line interface for searching and downloading arXiv papers, built on top of the [arxiv](https://pypi.org/project/arxiv/) Python client.

## Installation

```bash
pip install arxiv-cli-tools
```

To work from source instead, clone the repository and install in editable mode:

```bash
pip install -e .
```

## Usage

Inspect the available commands and options:

```bash
arxiv-cli --help
arxiv-cli search --help
arxiv-cli download --help
```

Typical commands:

```bash
# Search the API and show abstracts
arxiv-cli search "prompt engineering" -n 5 --summary

# Fetch specific papers by identifier into a folder
arxiv-cli download --id 2101.01234 --id 2105.06789 --dest papers --skip-existing
```

The CLI mirrors the underlying arXiv API, adding convenience flags for authors, categories, result limits, and download preferences. See the built-in help for the full reference.
bookmark-replace 0.1.0
A tool to batch replace domains in bookmarks (HTML or Chrome JSON).
Requires Python: >=3.8

# Bookmark Domain Replace

A Python CLI tool to batch replace domains in browser bookmarks (HTML exports or Chrome JSON files).

## Features
- Replace only the **domain part** of URLs
- Supports **shorthand replacements** (like `.com`)
- Dry-run mode to preview changes
- Optional in-place modification

## Example Usage

Dry-run:
```bash
bookmark-domain-replace bookmarks.html --target amazon.de --replace .com --dry

bookmark-domain-replace bookmarks.html --target amazon.de --replace .com

bookmark-domain-replace bookmarks.html --target amazon.de --replace .com --inplace
```
leet-suite 0.1.0
LeetSuite
Requires Python: >=3.11

# LeetSuite

Leet stuff

## Example usage

In your leet solution file:

In-place solutions:

```python
...

if __name__ == "__main__":

    from leet.test_suite import Submission, Case
    cases = [
        Case(
            matrix=[[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]],
            solution=[[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]],
        ),
    ]

    sub = Submission(
        callable=Solution().rotate,
        cases=cases,
        inplace=True,
        throw=False,
        verbose=True
    )
    sub.run(inplace_arg="matrix")
```

Not in-place

```python
...

if __name__ == "__main__":

    from leet.test_suite import Submission, Case
    # from leet.test_suite.comparators import nested_list_comparator

    cases = [
        Case(x=2.00000, n=10, solution=1024.00000).disable_from_here(), # disable this case and all following ones ...
        Case(x=2.10000, n=3, solution=9.26100).enable() # enable this one,
        Case(x=2.00000, n=-2, solution=0.25).enable_from_here(), # enabled from here (including this case)
        Case(x=8.66731, n=4, solution=5643.35434, enabled=False), # and disabled using arg
    ]

    sub = Submission(
        callable=Solution().myPow,
        cases=cases,
        inplace=False,
        throw=False,
        verbose=True
    )
    sub.run(comparator=lambda x, y: round(x, 3) == round(y, 3))
```

Nested-list comparison

```python
...

if __name__ == "__main__":

    from leet.test_suite import Submission, Case
    from leet.test_suite.comparators import nested_list_comparator

    cases = [
        Case(
            strs=["eat", "tea", "tan", "ate", "nat", "bat"],
            solution=[["bat"], ["nat","tan"], ["ate","eat","tea"]],
        ).disable(), # Disable a case
        Case(
            strs=["","b"],
            solution=[["b"], [""]],
        )
    ]

    sub = Submission(
        callable=Solution().groupAnagrams,
        cases=cases,
        inplace=False,
        throw=False,
        verbose=True
    )
    sub.run(comparator=nested_list_comparator)
```
graphsh 0.1.1
Interactive Terminal Client for Graph Databases
Requires Python: >=3.9

# GraphSh

GraphSh is an interactive terminal client for graph databases, inspired by the `psql` experience but designed specifically for graph query languages.

## Features

- Interactive shell for graph database queries
- Support for multiple query languages:
  - Gremlin (TinkerPop)
  - SPARQL 1.1
  - OpenCypher
- Compatible with:
  - Amazon Neptune
  - Amazon Neptune Analytics
  - Neo4j
  - Any TinkerPop-compliant database
- Authentication support:
  - AWS IAM for Neptune
  - Username/password for Neo4j
  - No authentication option for open endpoints
- Rich terminal features:
  - Command history
  - Tab completion
  - Syntax highlighting
  - Result formatting
- Connection profiles:
  - Save and reuse connection settings
  - Manage multiple database connections
  - Store language preferences with profiles

## Installation

```bash
# Install from PyPI
pip install graphsh

# Or install from source with pip
git clone https://github.com/awslabs/graphsh.git
cd graphsh
pip install -e .

# Or install from source with UV (recommended for faster installation)
git clone https://github.com/awslabs/graphsh.git
cd graphsh
uv venv
source .venv/bin/activate
uv pip install -e .

# Install with development dependencies
uv pip install -e ".[dev]"
```

## Quick Start

```bash
# Connect to Neptune with IAM auth
graphsh --endpoint https://neptune-instance.region.amazonaws.com:8182 --auth iam --type neptune

# Connect to Neptune Analytics with IAM auth
graphsh --graph-id my-graph-id --type neptune-analytics --region us-east-1

# Connect to Neo4j
graphsh --endpoint bolt://localhost:7687 --auth basic --username neo4j --password password --type neo4j

# Connect to an endpoint with no authentication
graphsh --endpoint https://localhost:8182 --auth none --type neptune --no-verify-ssl

# Connect using a saved profile
graphsh --profile my-neptune-profile

# Execute commands from a file
graphsh --commands-file commands.txt
```

## Interactive Shell Commands

Once in the interactive shell, you can use these special commands:

```
/help                   - Show help for commands
/help <command>         - Show detailed help for a specific command
/quit                   - Exit the shell
/language <lang>        - Switch query language (gremlin, sparql, cypher)
/connect <profile>      - Connect to a database using a saved profile
/connect --endpoint <url> [options] - Connect directly with connection parameters
/clear                  - Clear the screen
/timing on|off          - Toggle query execution timing
/format <format>        - Set output format (table, raw)
/preferences            - Show current user preferences
/preferences reset      - Reset preferences to defaults
/profile list           - List all saved connection profiles
/profile save <name>    - Save current connection as a profile
/profile delete <name>  - Delete a saved profile
/profile show <name>    - Show details of a saved profile
```