semvec/pypi-packages huggingface dataset:
neutralNEMO 1.1.0
A package to calculate approximate neutral surfaces with NEMO model output
Requires Python: >=3.8

# neutralNEMO (v1.0.0)

Calculate neutral surfaces for NEMO ([Madec et al., 2019](https://zenodo.org/doi/10.5281/zenodo.1464816)) model runs using neutralNEMO!

This package makes it easier to use the highly-optimized algorithms of the [neutralocean](https://github.com/geoffstanley/neutralocean/tree/main) package ([Stanley et al., 2021](https://doi.org/10.1029/2020MS002436)) with model outputs from NEMO.

The package contains routines to correctly load temperature and salinity data alongside the necessary horizontal and vertical grid information. 

A steamlined routine is also included to calculate an approximately neutral density surface which is fixed to a specific location in time and space. Additional options to calculate the Veronis density and potential density surfaces are included.

# Installation

neutralNEMO can be installed using conda:

```
conda install -c conda-forge neutralnemo
```

or alternatively, neutralNEMO can be installed through pip

```
pip install neutralNEMO
```

# The future of neutralNEMO

I am keen to here how others get on with the package when they use it on their model runs.  If it works well for you, please spread the word and let me know as it will make my day! If you do encounter any problems, please contact me or raise an issue, I will try to help in any way I can.

# Documentation
Documentation and examples can be found at [https://neutralnemo.readthedocs.io](https://neutralnemo.readthedocs.io)
nlip 0.1.0
Natural Language Interaction Protocol
Requires Python: <4.0,>=3.9

# NLIP Server  

This is a simple implementation of a NLIP Server written using fastapi in python

A sample chatbot solution is provided in soln directory



## Installation

To set up this python project, create a virtual environment for python using the following commands (You can use your own environment name instead of using the provided name of env_server: 

```
$ python -m venv env_server
$ source env_server/bin/activate
```

Next, install the required packages:
```
$ pip install -r requirements.txt
```

Now the python environment is setup and you can run the server

## Running the chatbot server 

Change to the directory soln/chat and invoke the following commands:
```
$ ./run_llama.sh 
```

or 
```
$ ./run_mistral.sh 
```

This will start the fast api server with chat on one of the two LLM models. 

Note: this solution assumes that you have an Ollama Server running at a server which needs to be configured. See the README.md in soln directory for more details. 


## Defining a new Solution 

To define a new solution, you need to provide a subclass of NLIPApplicaiton which needs to define its specialized version of NLIPSession. Both NLIPApplication and NLIPSession are defined in module nlip. 

The main routine of the solution should call the start_server routine in module server to create an instance of the solution server-side application.
labcli 0.2.0
Add your description here
Requires Python: >=3.10

[![Open the Example in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/davidban77/labcli?quickstart=1&devcontainer_path=.devcontainer%2Fexample%2Fdevcontainer.json)
# LabCLI

LabCLI is a command line interface for managing lab environments. It is designed to be used as is or imported into other scripts or CLI applications.

## Installation

To get started you can install the package from PyPI.

```bash
pip install labcli
```

## Usage

To get started you can use the `labcli` command:

```bash
labcli --help
```

It comes with builtin commands to manage [containerlab](https://containerlab.dev/) and [docker compose](https://docs.docker.com/compose/) environments.

```bash
labcli containerlab --help
labcli docker --help
```

### Example

To see it in action, this repository comes with an `example` directory that contains a `docker-compose.yml` file and a `containerlab` directory. These have been created to demonstrate how to use `labcli` to manage lab environments.

To start the `containerlab` environment:

```bash
labcli containerlab start example/containerlab/lab.clab.yml
```

To start the `docker compose` environment:

```bash
labcli docker start --compose example/docker-compose.yml
```

> Note: You can also use the `--help` flag to get more information about the commands and their options. For example, with the `--profile` argument you can spin up a docker compose environment for a specific profile of services applied to it:
>
> ```bash
> labcli docker start --compose example/docker-compose.yml --profile collector
> ```
>
> This will start the `docker-compose.yml` environment with the `collector` profile.

## Open in GitHub Codespaces

You can open this repository in GitHub Codespaces by clicking on the badge at the top of this README. This will open a new Codespace with the repository and the development environment already set up.

This will give you a feel of the `labcli` in action and how it can be used to manage lab environments.

## Development

To install the development environment you need to have [uv](https://docs.astral.sh/uv) installed.

```bash
git clone https://github.com/davidban77/labcli.git
cd labcli
uv sync
```

This will create a virtual environment and install the required dependencies.
online-fbank 0.0.4
Online Fbank

# online-fbank

Online-fbank is a wrapper of [kaldi-native-fbank](https://github.com/csukuangfj/kaldi-native-fbank). It can be used to extract streaming fbank or streaming LFR (Lower Frame Rate) fbank for FunASR-based automatic speech recognition models.

## Usage

- fbank

``` python
from online_fbank import OnlineFbank

fbank = OnlineFbank()
fbank.accept_waveform(audio_samples, is_last=True)
feats = fbank.get_frames()
```

- lower frame rate fbank

``` python
from online_fbank import OnlineFbank

fbank = OnlineFbank(window_type="hamming")
fbank.accept_waveform(audio_samples, is_last=True)
feats = fbank.get_lfr_frames(neg_mean=neg_mean, inv_stddev=inv_stddev)
```
llm-taxi 0.7.0
Call LLM as easily as calling a taxi.
Requires Python: >=3.10

# llm-taxi

## Installation

```shell
pip install llm-taxi
```

## Usage

Use as a library

```python
import asyncio

from llm_taxi.conversation import Message, Role
from llm_taxi.factory import embedding, llm


async def main():
    # Non-streaming response
    client = llm(model="openai:gpt-3.5-turbo")
    messages = [
        Message(role=Role.User, content="What is the capital of France?"),
    ]

    response = await client.response(messages)
    print(response)

    # Streaming response
    client = llm(model="mistral:mistral-small")
    messages = [
        Message(role=Role.User, content="Tell me a joke."),
    ]
    response = await client.streaming_response(messages)
    async for chunk in response:
        print(chunk, end="", flush=True)
    print()

    # Embed text
    embedder = embedding("openai:text-embedding-ada-002")
    embeddings = await embedder.embed_text("Hello, world!")
    print(embeddings[:10])

    # Embed texts
    embedder = embedding("mistral:mistral-embed")
    embeddings = await embedder.embed_texts(["Hello, world!"])
    print(embeddings[0][:10])



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

### Common parameters

- `temperature`
- `max_tokens`
- `top_k`
- `top_p`
- `stop`
- `seed`
- `presence_penalty`
- `frequency_penalty`
- `response_format`
- `tools`
- `tool_choice`

## Command line interface

```shell
llm-taxi --model openai:gpt-3.5-turbo-16k
```

See all supported arguments

```shell
llm-taxi --help
```

## Supported Providers

|  Provider  | LLM | Embedding |
| :--------: | :-: | :-------: |
| Anthropic  | ✅  |           |
| DashScope  | ✅  |           |
| DeepInfra  | ✅  |           |
|  DeepSeek  | ✅  |           |
|   Google   | ✅  |    ✅     |
|    Groq    | ✅  |           |
|  Mistral   | ✅  |    ✅     |
|   OpenAI   | ✅  |    ✅     |
| OpenRouter | ✅  |           |
| Perplexity | ✅  |           |
|  Together  | ✅  |           |
|  BigModel  | ✅  |           |