semvec/pypi-packages huggingface dataset:
grammatical-phrase-splitter 0.2.6
A package to split sentences into grammatical segments using OpenAI API

# Grammatical Phrase Splitter

A Python package that splits sentences into grammatical segments using OpenAI API.

## Installation

To install this package, run:

```bash
pip install grammatical-phrase-splitter

python -m spacy download en_core_web_sm

```

## Command-Line Usage

After installation, you can use the split-phrase command to split sentences into grammatical segments. The syntax is as follows:

```bash
split-phrase "[sentence]" "[your-openai-api-key]"
```
hubitat-maker-api-client 2.6.0
Control Hubitat Maker API
Requires Python: <4.0,>=3.11

# hubitat_maker_api_client

This library facilitates access to Hubitat's [Maker API](https://docs.hubitat.com/index.php?title=Maker_API). A key innovation is the **HubitatCachingClient**, which is capable of maintaining a cache of all your devices in a data store of your choice. This can allow you to query device state more efficiently than using the Maker API directly. HubitatCachingClient can be attached to a process that listens to Hubitat's `/eventsocket` to update the cached device states in real time.

## Quick Start

Install

```
pip install hubitat-maker-api-client
```

This sample code demonstrates how to configure a HubitatCachingClient using your `HOST`, `APP_ID`, `ACCESS_TOKEN` and `HUB_ID` along with your custom implementation of **DeviceCache**.

```
from hubitat_maker_api_client import DeviceCache, HubitatAPIClient, HubitatCachingClient


class YourDeviceCache(DeviceCache):
   # Override methods for reading and writing
   # device state to your own datastore


_api_client = HubitatAPIClient(
    host=<HOST>,
    app_id=<APP_ID>,
    access_token=<ACCESS_TOKEN>,
    hub_id=<HUB_ID>,
)

client = HubitatCachingClient(
    api_client=_api_client,
    device_cache=YourDeviceCache(),
)


for switch in client.get_on_switches():
    client.turn_off_switch(switch)
    print(f'Turned off {switch}')
```

This sample code demonstrates how to update device state on your HubitatCachingClient by listening to Hubitat's `/eventsocket`.

```
import asyncio
import websockets
from hubitat_maker_api_client import HubitatEvent

async def listen(uri: str) -> None:
    async with websockets.connect(uri) as websocket:
        while True:
            message = await websocket.recv()
            event = HubitatEvent(json.loads(message))
            client.update_from_hubitat_event(event)

asyncio.get_event_loop().run_until_complete(listen('ws://<HOST_IP>/eventsocket'))
```
umnet-cyberark 0.1.1
Python package for querying Cyberark
Requires Python: >=3.6

# umnet-cyberark
Python library for doing API calls to cyberark.

Note that this code was adapted from a class in `umnet-scripts` so that it can be imported separately from that library.
Originally authored by Jeff Hagley, I've added some error checking and convenience methods. Reference:
https://github.com/umich-its-networking/umnet-scripts/blob/master/umnet_scripts/cyberark.py

As of May 2025 this code is only intended to be used by other libraries. Install with pip:
```
pip install umnet-cyberark
```
Then in your code you can import and use it like so:
```
from umnet_cyberark import Cyberark

c = Cyberark(env_file="/usr/local/umnet/lib/cyberark/cyberark.env")
c.lookup_username_password("automaton")
```
You need a `cyberark.env` file that has paths to the keys and certs for the `UMNET` and/or `NSO` environments.
If you don't provide this as an argument it will assume it's in your current directory (eg `cyberark.env`)