semvec/pypi-packages huggingface dataset:
gazze 0.1.21
Fastest python web framework
Requires Python: >=3.9,<4.0

# gazze

A Python Web Framework for High-Performance APIs

### Summary

Gazze is an exciting Python web framework, developed on top of the powerful Starlette and the amazing FastAPI. The primary goal of Gazze is to provide an exceptional experience in developing highly performant APIs in Python.

### Important Notices:

Please be aware that Gazze is an ongoing development and research project. Currently, it is not recommended for use in production environments. We are working diligently to improve and mature the framework, but it is still in its early development stage.

### Installation

```
$ pip install gazze
```

You will also need a ASGI Server like Uvicorn or Hypercorn

```
$ pip install "uvicorn[standard]"
```

### Example

```python
from gazze.responses import JSONResponse
from gazze.applications import Gazze

app = Gazze(
    debug=True,
)

@app.get("/items/{item_id}")
async def read_item(request):
    item_id = request.path_params.get('item_id')
    return JSONResponse({"item_id": item_id})
```

### Run

```
$ uvicorn main:app

INFO:     Started server process [51753]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
```

### Key Features:

- Built on top of Starlette and FastAPI.
- Focused on creating high-performance APIs.
- Modern and developer-friendly design.
- Open-source licensing for flexibility and collaboration.

#### Contributions:

We look forward to collaborations and contributions from the community to help Gazze evolve and grow. Your input is highly appreciated in shaping the future of this project.
economic-agents 0.1
A Python package for the paper "Large Language Models as Simulated Economic Agents: What Can We Learn from Homo Silicus?"

# EconomicAgents

This is an implementation and Python package for the paper [Large Language Models as Simulated Economic Agents: What Can We Learn from Homo Silicus?](https://arxiv.org/abs/2301.07543). This Python package enables you to run all four simulations from the paper. 

If you like this work, consider joining our [![Discord](https://img.shields.io/badge/Discord-7289DA?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/Qy69gzmpt4).

## Installation

```sh
pip install economic_agents
```

## Usage 

### Charness Rabin

```python
from economic_agents import CharnessRabin

charness_rabin = CharnessRabin(api_key="openai_key", model="gpt-3.5-turbo", personality=1, image_path="folder/charness_rabin", logging=True)
results = charness_rabin.play()
charness_rabin.create_plot(results)
```

The personality argument determines an option from the following personalities from the original paper:

```txt
"You only care about fairness between players",
"You only care about your own pay-off",
"You only care about the total pay-off of both players",
" "
```

**Result:**

![Rabin Results](./results/charness_rabin.png)

### Horton

```python
from economic_agents import Horton

horton = Horton(api_key="openai_key", model="gpt-3.5-turbo", image_path="folder/horton", logging=True)
results = horton.play()
horton.create_plot(results)
```

**Result:**

![Horton Results](./results/horton.png)

### Kahneman

```python
from economic_agents import Kahneman

kahneman = Kahneman(api_key="openai_key", model="gpt-3.5-turbo", image_path="results/kahneman", logging=True)
results = kahneman.play()
kahneman.create_plot(results)
```

**Result:**

![Kahneman Results](./results/kahneman.png)

### Zeckhauser

```python
from economic_agents import Zeckhauser

zeckhauser = Zeckhauser(api_key="openai_key", model="gpt-3.5-turbo", image_path="results/zeckhauser", logging=True)
results = zeckhauser.play()
zeckhauser.create_plot(results)
```

**Result:**

![Zeckhauser Results](./results/zeckhauser.png)

## Todo 

- [ ] Create a Gradio demo
- [ ] Make experiments possible with dynamic inputs
- [ ] Improve error handling / code refactoring
- [ ] Add support for other models
 

## Citation 

```bibtex
@article{horton2023large,
  title={Large Language Models as Simulated Economic Agents: What Can We Learn from Homo Silicus?},
  author={Horton, John J},
  journal={arXiv preprint arXiv:2301.07543},
  year={2023}
}
```
elma-verifier 0.0.6
A package for validating Norwegian organization numbers and checking whether the organization number is registered in the ELMA-registry.
Requires Python: >=3.7

# ELMA-verifier

This Python module allows users to verify whether an organization number is valid and is set up to receive invoices through the EHF format.

## Installation
To install the `elma-verifier` package, simply use `pip`:

```bash
pip install elma-verifier
```

## Usage
Here's how you can use the elma-verifier:

```python
from elma_verifier import verifier
result = verify.verify_org_number("YOUR_ORG_NUMBER_HERE")
print(result)  # Returns True if organization number is registered to receive EHF invoices, otherwise False
```

## Issues & Contributions
If you come across any issues or would like to contribute to the improvement of this package, please open an issue or submit a pull request.

## Acknowledgements and Dependencies

- **Selenium**: This package uses [Selenium](https://www.selenium.dev/) which is licensed under the [Apache 2.0 license](https://www.apache.org/licenses/LICENSE-2.0).

## License
This package is distributed under the MIT License.

Copyright 2023 Mathias S. Mjømen

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
apm4py 0.1.14
apm4py is a Python API for Appian Process Mining (APM)
Requires Python: >=3.10,<4.0

# apm4py
[![Python 3.7](https://img.shields.io/badge/python-3.7-blue.svg
)](https://www.python.org/downloads/release/python-374/)
[![apm4py](https://img.shields.io/badge/apm4py-v0.2.1-blue)](https://pypi.org/project/apm4py/)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://github.com/lanalabs/apm4py/graphs/commit-activity)

apm4py is Python API for [Appian Process Mining](https://appian.com/). It focuses on resource management, but provides methods that can be used to access the processed data as well.

This package is still in initial development state. Anything may change at any time. The public API should not be considered stable.

## Installation

You can install apm4py directly from PyPi with e.g. 

```bash
$ pip install apm4py
```

# How to get started

To connect with an api at e.g. 'https://cloud-backend.lanalabs.com', first create an API with

```python
from apm4py import create_api

api = create_api('https', 'cloud-backend.lanalabs.com', API_KEY)
```

# Using the Command Line

Command line currently only supports uploading event logs. Four files for the event log have to be in one folder and follow the convention:
* event log CSV has "event" in the file name
* case attribute CSV has "case" in the file name
* event log semantics json have "event" in the file name
* case attribute log semantics json have "case" in the file name

See ./tests/data/incident_management as an example.

To install the CLI globally, use [pipx](https://pypa.github.io/pipx/installation/):
```bash
pipx install apm4py
apm upload --name "Incident Management" tests/data/incident_management
apm list-logs
```

It will prompt you for host settings on the first run and also supports having multiple profiles with different hosts. Similar as the aws-cli. Profiles are saved in `~/.apm/`.

If you want to run the command line client from source, you have to prepend `poetry run` before any `apm` command. For example `poetry run apm list-logs`.

## Growing event logs

apm4py comes with a utility called `log grower` that allows to grow existing event logs by copying there content as many times as wanted. While copying the events and cases it makes sure to alter the CaseIDs so that new cases are created. Thereby, the structure of the event log is preserved. That is, the number of activities and the number of variants stay the same. 

It expects an existing event log with four files in one folder as described above. In order to generate a 10 times larger event log from the incident management data set provided in the test data of this repository, you can run

```bash
apm grow-log ./tests/data/incident_management \
    --csv-separator ";" \
    --output-csv \
    --growth-factor 10
```


# Building and installing from source
```bash
poetry install
poetry build
pip install /dist/apm4py-0.X.Y-py3-none-any.whl
```


# How to contribute

See the details in [CONTRIBUTING.md](CONTRIBUTING.md).

# License

[Apache License 2.0](http://www.apache.org/licenses/)