semvec/pypi-packages huggingface dataset:
dtalarm 1.1.0
Python integration with DRIVE
Requires Python: >=3.6.8

# Dtalarm


## Installation


```shell
$ pip install dtalarm
```


## Usage

Register a new service on the DRIVE server and get the secret key.


The `DTAlarmConfig` module records the configuration information required to send alarms. Here, you need to configure a server address.

```python
from dtalarm import DTAlarmConfig

DTAlarmConfig.SERVER = ""
```

Generating alarms is very easy if the service is pre-configured, the following case will send alarms to the preset receivers. 
```python
from dtalarm import Alarm

alarm = Alarm(secret_key="")
alarm.title = "Title"
```

If the service is not pre-configured, alarms can also be sent in the following way:

Import the `TeamsChannelAlarm` class or the `TeamsPersonalAlarm` class from the package and configure the secret_key property.

After initialize, you can assign a value to the alarm object. If the alarm content is a dataframe, please use the to_json method and assign it to the table property.
```python
from dtalarm import TeamsChannelAlarm

alarm = TeamsChannelAlarm(secret_key="", channel_address="", template="message_only_v1")

alarm.title = "Title"
alarm.text = "Content"
alarm.table = df.to_json()
```


Finally call the send function to send, which can receive parameters supported by requests like timeout (how many seconds to wait for the server response). 

```python
response = alarm.send()
```


## Dependencies


Dtalarm supports CPython 3.6.8+, PyPy, and PyPy3.6.8+.

You can install all dependencies automatically with the following command:


```shell
$ pip install dtalarm['Pillow', 'requests', 'kaleido', 'plotly', 'numpy', 'pandas']
```


## Documentation

*Please install the following version dependencies when send error: ['Pillow==8.4.0', 'requests==2.27.1', 'kaleido==0.2.1', 'plotly==5.9.0', 'numpy==1.19.5', 'pandas==1.1.5']*
dis-inference 1.1.3
Inference implementation for Dichotomous Image Segmentation
Requires Python: >=3.7

# DIS-inference

[![PyPI - Version](https://img.shields.io/pypi/v/dis-inference.svg)](https://pypi.org/project/dis-inference)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/dis-inference.svg)](https://pypi.org/project/dis-inference)

Inference implementation of Dichotomous Image Segmentation

## [Highly Accurate Dichotomous Image Segmentation (ECCV 2022)](https://arxiv.org/pdf/2203.03041.pdf)

#### [Xuebin Qin](https://xuebinqin.github.io/), [Hang Dai](https://scholar.google.co.uk/citations?user=6yvjpQQAAAAJ&hl=en), [Xiaobin Hu](https://scholar.google.de/citations?user=3lMuodUAAAAJ&hl=en), [Deng-Ping Fan*](https://dengpingfan.github.io/), [Ling Shao](https://scholar.google.com/citations?user=z84rLjoAAAAJ&hl=en), [Luc Van Gool](https://scholar.google.com/citations?user=TwMib_QAAAAJ&hl=en).

[**Project Page**](https://xuebinqin.github.io/dis/index.html), [**Arxiv**](https://arxiv.org/pdf/2203.03041.pdf), [**中文
**](https://github.com/xuebinqin/xuebinqin.github.io/blob/main/ECCV2022_DIS_Chinese.pdf).

<br>

| Origin                                                                                   | DIS                                                                                         |
|------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------|
| ![Before](https://github.com/dh031200/DIS-inference/blob/main/assets/Lenna.png?raw=true) | ![After](https://github.com/dh031200/DIS-inference/blob/main/assets/Lenna_dis.png?raw=true) |

<br>

**Table of Contents**

- [Installation](#installation)
- [Usage](#usage)
- [License](#license)
- [Reference](#reference)

## Installation

```console
pip install dis-inference
```

## Usage

### CLI

command:  `dis-inference`
arguments:--silent(optional) : Whether to print verbose. Source image

```console
> dis-inference Lenna.png
Output saved as `Lenna_dis.png`
> dis-inference --silent Lenna.png
```

### Python

```python
from dis_inference import inference

# 1. Inference with path
output = inference('Lenna.png')
cv2.imwrite('Lenna_dis.png', output)

# 2. Inference cv2 image
image = cv2.imread('Lenna.png')
output = inference(image)
cv2.imwrite('Lenna_dis.png', output)

# 3. Inference cv2 image with save parameter
image = cv2.imread('Lenna.png')
output = inference(image, save=True, output='Lenna_dis.png')

# 3. With save parameter
image = inference('Lenna.png', save=True)
```

## License

`dis-inference` is distributed under the terms of the [AGPL-3.0-only](https://spdx.org/licenses/AGPL-3.0-only.html)
license.

## Reference

https://github.com/xuebinqin/DIS

## Citation

```
@InProceedings{qin2022,
      author={Xuebin Qin and Hang Dai and Xiaobin Hu and Deng-Ping Fan and Ling Shao and Luc Van Gool},
      title={Highly Accurate Dichotomous Image Segmentation},
      booktitle={ECCV},
      year={2022}
}
```
spec-pilot 0.3.4
A command-line tool for generating and managing OpenAPI specifications
Requires Python: >=3.6

# Spec Pilot

Spec Pilot is a command-line tool for generating and managing OpenAPI specifications. The tool simplifies the process of creating OpenAPI specs by providing a user-friendly interface for inputting required information, and generates the final spec in YAML format.

## Features

- Project initialization with predefined directory structure
- OpenAPI Spec Wizard for user-friendly input of spec components
- Validation of OpenAPI specification YAML files

## Installation

To install Spec Pilot, clone this repository and run the `setup.py` script:

```sh
git clone https://github.com/jmfwolf/spec-pilot.git
cd spec-pilot
python setup.py install
```

from pypi:

```sh
pip install spec-pilot
```

## Usage

### Initializing a new project

To create a new project with a predefined directory structure, run the following command:

```sh
spec-pilot --init project_name
```

This will create a new directory with the given project name and subdirectories for schemas, resources, responses, and parameters.

### Running the OpenAPI Spec Wizard

To generate an OpenAPI spec using the Spec Wizard, run the following command:

```
spec-pilot --wizard
```

The Spec Wizard will prompt you for information about the API, such as endpoints, parameters, and responses. It will then generate an OpenAPI specification YAML file with the provided information.

### Validating an OpenAPI specification

To validate an OpenAPI specification YAML file, run the following command:

```
spec-pilot --validate path/to/openapi.yaml
```

The tool will check the validity of the YAML file and output any errors found during the validation process.

## Contributing

We welcome contributions to Spec Pilot! If you'd like to contribute, please follow these steps:

1. Fork the repository
2. Create a new branch for your changes
3. Make changes and commit them to your branch
4. Submit a pull request with a detailed description of your changes

Please follow the coding standards and guidelines established in the project, and make sure to include tests and documentation for any new features or changes.

We encourage users to provide feedback and contribute to the development of Spec-Pilot to make it more robust and feature-rich.

## License

Spec-Pilot is released under the [GNU General Public License v3.0](https://www.gnu.org/licenses/gpl-3.0.en.html).
geocodeus 22.0
A Python package for converting US zip codes to latitude and longitude

# geocodeus

The ```ZipCache``` module from the ```geocodeus``` package is a Python library that enables users to retrieve data for US zip codes, such as the latitude and longitude coordinates, city, state, county, and timezone information. This module leverages a caching mechanism to speed up data retrieval and optimize memory usage.

To use the ```ZipCache``` module, users must first import it using the ```from geocodeus import ZipCache statement```. Once the module is imported, they can create an instance of the ```ZipCache``` class with no arguments, which initializes the cache and makes it ready for use. To obtain data for a particular US zip code, users can then call the ```getData()``` method with a zip code string as the argument. The method returns a dictionary that contains information about the specified zip code.

The ZipCache module employs a caching mechanism that enhances performance and memory usage efficiency. When a user calls the ```getData()``` method with a zip code, the module first checks whether the data for that code is already in the cache.


Overall, the ```ZipCache``` module from the ```geocodeus``` package is a powerful and easy-to-use tool for obtaining data for US zip codes. With its efficient caching mechanism and reliable data sources, this module is a must-have for any Python developer working with US zip codes.

## Installation

You can install geocodeus using pip:


```bash
pip install geocodeus


```


## Usage

Here's an example of how to use Zip Cache:

```python
from geocodeus import ZipCache




cache = ZipCache()

# Get data for a zip code
data = cache.getData("96105")
print(data)
```

## Contributing

Pull requests are welcome. For major changes, please open an issue first
to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License

[MIT](https://choosealicense.com/licenses/mit/)