semvec/pypi-packages huggingface dataset:
dokanalyse 0.0.13
Arealanalyse av DOK-datasett
Requires Python: >=3.11

# Arealanalyse av DOK-datasett
Process-plugin til pygeoapi for arealanalyse av DOK-datasett

#### Miljøvariabler
```bash
# Filsti til mappe for cache og logging (obligatorisk)
export APP_FILES_DIR=/path/to/dokanalyse

# Filsti til mappe med YAML-konfigurasjonsfiler (obligatorisk)
export DOKANALYSE_CONFIG_DIR=/path/to/dokanalyse/config

# Filsti til mappe med AR5 filgeodatabase (valgfri)
export AR5_FGDB_PATH=/path/to/ar5.gdb

# URL til Socket IO server (valgfri)
export SOCKET_IO_SRV_URL=http://localhost:5002

# Azure Blob Storage connection string (valgfri)
export BLOB_STORAGE_CONN_STR=DefaultEndpointsProtocol=https;AccountName=.....

# Filsti til mappe med Jinja2-maler til genering av PDF-rapport (valgfri)
export PDF_TEMPLATES_DIR=/path/to/jinja2_templates
```
gen-wrapper 0.1.1
A lightweight wrapper for multiple LLM providers with optional LangChain integrations.
Requires Python: >=3.9
Keywords: anthropic, google, langchain, llm, openai, wrapper

# gen-wrapper

[![PyPI](https://img.shields.io/pypi/v/gen-wrapper.svg)](https://pypi.org/project/gen-wrapper/)
[![Python](https://img.shields.io/pypi/pyversions/gen-wrapper.svg)](https://pypi.org/project/gen-wrapper/)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)

A unified interface for multiple LLM providers (OpenAI, Anthropic, Groq, DeepSeek, Fireworks, Gemini, local).

## Installation

```bash
pip install gen-wrapper
# or with extras
pip install "gen-wrapper[llm-providers,langchain,async]"
```

## Environment

Set needed API keys, e.g. (PowerShell):

```powershell
$env:OPENAI_API_KEY="your_openai_key"
$env:ANTHROPIC_API_KEY="your_anthropic_key"
$env:GROQ_API_KEY="your_groq_key"
$env:DEEPSEEK_API_KEY="your_deepseek_key"
$env:FIREWORKS_API_KEY="your_fireworks_key"
$env:GOOGLE_API_KEY="your_google_key"

# Azure OpenAI (optional)
$env:AZURE_OPENAI_API_KEY="..."
$env:AZURE_OPENAI_ENDPOINT="..."
$env:AZURE_OPENAI_DEPLOYMENT="..."
$env:AZURE_OPENAI_API_VERSION="..."
```

## Quickstart (Python)

```python
from gen_wrapper import LLMWrapper

wrapper = LLMWrapper(provider="openai", model="gpt-4o")
print(wrapper.simple_chat("Hello!"))
```

## CLI

```bash
llm-cli --list-providers
llm-cli --list-models openai
llm-cli --provider openai --prompt "Hello world"
```

## Extras

- llm-providers: OpenAI, Anthropic, Google Generative AI SDKs
- langchain: LangChain core + provider adapters
- async: aiohttp, httpx
- monitoring: prometheus-client

## Links

- Source, docs, and issues: https://github.com/lakshya811/gen_wrapper
- PyPI: https://pypi.org/project/gen-wrapper/

## License

MIT
appendzip 0.1.1
Append a single file to zip, overwriting the existing file if necessary
Requires Python: >=3.6

# append-zip

Appends a file to a zip file, overwriting the existing file there if necessary

## Performance
Not efficient; extracts all the files in the zip, copies over the new file, and compresses a brand new zip replacing the original one. You will need enough disk space to duplicate the zip file.

## Caveats
for some reason, windows has a different file length after unzipping (by 10-20 bytes). So beware how this works on windows

## Getting started

install
`$ python3 -m pip install appendzip`

```py
from appendzip.appendzip import appendzip
# before appendzip calendar.txt in the zip archive test.zip contains 2021-01-02
# before appendzip calendar.txt outside the zip contains 2022-02-03
appendzip(
            pathlib.Path('test.zip'),
            pathlib.Path('calendar.txt'),
            'calendar.txt'
)
# after appendzip calendar.txt inside the zip contains 2022-02-03
# after, there is still only one file in the zip archive test.zip
```
jmenu 1.10.1
Tool for fetching University of Oulu restaurant menus from Jamix.
Requires Python: >=3.10

# jmenu

Command line tool for fetching University of Oulu restaurant menus from the [Jamix API.](https://fi.jamix.cloud/apps/menuservice/rest)

Doubles as a general library for fetching menu info from Jamix.

## Installing

### Python Package Index

jmenu is available for install on the [python package index.](https://pypi.org/project/jmenu/)

```shell
pip install jmenu
```

### Building from source

For testing purposes, the package can be built from the repository source code.

```shell
pip install build
python3 -m build
pip install dist/<package_name>.whl
```

## Usage

### Command line tool

jmenu can be invoked from the command line as is:

```shell
jmenu [-h] [-v] [-e] [-t] [-l {fi,en}] [-a markers [G, VEG ...]]
```

All flags and parameters described below

| Argument        | Example | Description                             |
| :-------------- | :------ | :-------------------------------------- |
| -a, --allergens | g veg   | Highlights appropriately marked results |

| Flag           | Description                         |
| :------------- | :---------------------------------- |
| -h, --help     | Display usage information           |
| -v, --version  | Display version information         |
| -e, --explain  | Display allergen marker information |
| -t, --tomorrow | Fetch menu results for tomorrow     |
| -l, --language | Result language, opts: {fi, en}     |

### Python library

jmenu can also be imported as a library:

```python
from jmenu import main

main.run()
```

Documentation for the library can be found in the [project pages.](https://jkerola.github.io/jmenu)

## Contributing

Pull requests are welcome. We use [pre-commit hooks](https://pre-commit.com/) and GitHub actions to ensure code quality.

### Development environment setup

**Requirements**

- Python 3.10+
- Virtualenv

Setup the development environment with

```shell
python3 -m virtualenv env
source env/bin/activate
pip install -r requirements.txt
```

### Testing

Run the tool

```shell
python3 -m src.jmenu.main
```

Execute unit tests

```shell
pytest
```

# Documentation

Documentation for the project is available in the [project pages.](https://jkerola.github.io/jmenu)

## Build documentation from source

The documentation for the modules is built with [Mkdocs.](https://mkdocs.org) and the mkdocstrings extension, using google style docstrings.

You can build it from source by installing mkdocs

```shell
pip install mkdocs mkdocs-material
mkdocs serve
```

and navigating to [localhost:8000](http://localhost:8000) in your browser.
seismic-forward 4.5.0
Seismic Forward Modeling Tool
Requires Python: >=3.11

**Seismic Forward** is a tool for generating synthetic seismic from elastic parameters Vp, Vs and density.

## Documentation

User manuals are located in the 'doc' directory.

## Prerequisites

- Boost
- FFTW3
- Intel MKL

## GitHub

To have Git remember the credentials for you, do this

```
git config --global credential.helper cache                  # (activate memory cache)
git config --global credential.helper 'cache --timeout=3600' # (timeout in seconds)```
```

## Fork and checkout a branch

If you intend to modify the repository, you should checkout a fork of this
project rather than checking out the repository directly. When you have made
a fork, you can set this repository as your origin using:

```
git checkout --track origin/release-4.3
```
(At the time being, it is adviced that you use branch release-4.3)


## To make an executable using CLion or another IDE

Go to the directory containing the seismic-forward git repository

```
clion CMakeLists.txt
```


## To make an executable using cmake

Go to the directory above the directory containing the seismic-forward git repository

```
cd dir-above-seismic-forward
```
Make directory where you want the project and executable to be build

```
mkdir my-proj-dir
```

Go to this directory and run run_cmake.sh to set up compiler and library dependencies

```
cd my-proj-dir
../seismic-forward/run_cmake.sh
```

Generate the executable

```
make
```


## Run seismic-forward

The executable can be run directly once an XML model file/job file has been created. The only input data needed is an Eclipse-grid with Vp, Vs and Rho.

```
cd directory-with-Eclipse-grid
path-to-executable/seismic_forward my_job_file.xml
```


## Run the tests

To run all tests do

```
../seismic-forward/TestScript.pl
```

To run a single test do

```
../seismic-forward/TestScript.pl case=1
```

NBNB! If more than one angle is involved, I think that results for the first angle only is checked. This is the way NRLib currently works.
data-pipeline-helper-vi 2.1.0
A helper library for building and managing data pipelines
Requires Python: >=3.6

# Data Pipeline Helper

A lightweight Python package for cleaning and processing data in Pandas DataFrames.  
It includes handy functions for removing null values, duplicates, and other common data-cleaning operations.

---

## ðŸš€ Features
- Remove null values from specific columns
- Remove duplicate rows
- Easy-to-use helper functions
- Built with Pandas

---
Check out the [example script](examples/example_usage.py) for more details

---
## ðŸ“¦ Installation
```bash
pip install data-pipeline-helper
ndc-sdk-python 0.42.0
A Python SDK for creating Hasura Native Data Connectors as per the NDC spec
Requires Python: >=3.12

# ndc-sdk-python 

A Python SDK for creating Hasura Native Data Connectors as per the [NDC spec](https://github.com/hasura/ndc-spec/), using the Python programming language.

To install the library you can use:

`pip3 install ndc-sdk-python`

Included in this SDK is an implementation of a Lambda connector, called a FunctionConnector. If you wanted to simply write Python code you'd likely be more interested in the Python Lambda connector which makes use of this, and you can find that repo here: [hasura/ndc-python-lambda](https://github.com/hasura/ndc-python-lambda)

Developer notes:

This repository uses `uv` to control dependencies. To install dependencies, run `uv sync`.