semvec/pypi-packages huggingface dataset:
FLOPS-modern-interface 0.0.2
Python pydantic classes for FLOPS input/output and web service
Requires Python: >=3.11.9

# FLOPS python

"Python pydantic classes for FLOPS input/output and web service"

Run from web service:

```python
# Path to your input file
input_file = "your-input-file.in.json"

# Parse input file and update input values if needed
flops_input = flops.input_from_json_file(input_file)
flops_input.CONFIN.DESRNG = 1800

# Execute from web API
url = "https://your-python-web-service-url.net"
flops_output = flops.run_flops_api_from_input(flops_input, url)

# Process output
print(flops_output.OBJ_VAR_CONSTR_SUMMARY.RANGE)
```

Run locally:

```python
# Path to your flops directory and input file
flops_directory = "path/to/flops/folder"
input_file = "your-input-file.in.json"

# Execute directly from file (generates test.out.json file)
flops.run_flops_from_json_file(input_file, flops_directory)

# Or parse input from  and update input values if needed Inspect output object.
flops_input = flops.input_from_json_file(input_file)
flops_input.CONFIN.DESRNG = 2200

# Execute locally
flops_output = flops.run_flops_from_input(flops_input, flops_directory)

# Process output
print(flops_output.OBJ_VAR_CONSTR_SUMMARY.RANGE)
```
agrirouter 2.1.0a1
Python SDK for the agrirouter API. This project contains the API for the communication with the agrirouter. Everything you need for the onboarding process, secure communication and much more.
Requires Python: >=3.7

<img src="https://files.my-agrirouter.com/agrirouter_logo.svg" height="100" />

# About the project

The agrirouter is a universal data exchange platform for farmers and
agricultural contractors that makes it possible to connect machinery
and agricultural software, regardless of vendor or manufacturer.
Agrirouter does not save data; it transfers data. As a universal data
exchange platform, agrirouter fills a gap on the way to Farming 4.0.
Its underlying concept unites cross-vendor and discrimination-free
data transfer. You retain full control over your data. Even data
exchange with service providers (e.g. agricultural contractors) and
other partners is uncomplicated: Data are very rapidly transferred via
the online connection, and if you wish, is intelligently connected to
other datasets.

# The current project you’re looking at

This project contains the SDK for the communication with the agrirouter.
Everything you need for the onboard process, secure communication and
much more.

# Installation

Create your virtual environment using any kind of `conda` setup you
would like to have.

``` bash
conda create -n agrirouter-sdk-python python=3.7
conda create -n agrirouter-sdk-python python=3.8
conda create -n agrirouter-sdk-python python=3.9
conda create -n agrirouter-sdk-python python=3.10
conda create -n agrirouter-sdk-python python=3.11
```

Create one of the environments and activate it:

``` bash
conda activate agrirouter-sdk-python
```

After the activation you are ready to install the requirements for the
SDK:

``` bash
pip install -r requirements.txt
```

You are able to select the virtual environment when working with the
IDE.

# Running unit tests

`$ pytest`

# External resources

Here are some external resources for the development:

- [My Agrirouter Website](https://my-agrirouter.com)

- [Integration
  Guide](https://github.com/DKE-Data/agrirouter-interface-documentation)

- [EFDI Protobuf Definition](https://www.aef-online.org)
xbox-python-api 0.2
Xbox API library

# Xbox Python API
Xbox Python API wrapper based on https://xbl.io.

## Installation
```bash
pip install xbox-python-api
```

## Usage
Create an instance of the `XPA` class with your API key.
```python
from xpa import XPA

xpa = XPA(api_key="YOUR_API_KEY")
```

## Code example
```python
from xpa import XPA

xpa = XPA(api_key="YOUR_API_KEY")

# Get account gamertag
account_info = xpa.get_account_info_xuid(xuid="xuid")
print(account_info.Gamertag)


# Get user presence
presence = xpa.get_presence(xuid="xuid")
print(presence.devices)
```

Full documentation can be found [here](https://github.com/Rarmash/Xbox-Python-API/tree/master/docs).
ADattribution 0.0.10
make it easy to use AD postback

# ADattribution

#### 介绍
广告归因

1.  依赖管理
- 生成依赖
```shell script
pip3 freeze > requirements.txt
```
- 安装依赖
```shell script
pip3 install -r requirements.txt -i https://mirrors.aliyun.com/pypi/simple
```
- 虚拟环境管理
```text
创建虚拟环境：python3 -m venv venv
激活虚拟环境：source venv/bin/activate

退出虚拟环境：deactivate
```
retrival25 0.1.2
One place stop for BM25 and it's variants
Requires Python: >=3.6

<div align="center">

[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
[![python](https://img.shields.io/badge/Python-3.9-3776AB.svg?style=flat&logo=python&logoColor=white)](https://www.python.org)
[![PyPI version fury.io](https://img.shields.io/pypi/v/retrival25.svg)](https://pypi.org/project/retrival25/0.1.0/)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black) 


<h1>retrival25 ðŸ‘‘</h1>

<i>One stop solution for all BM25 needs</i>
</div>

## Installation
You can install `retrival25` with pip:

```bash
pip install retrival25
```

## Quick Start
Here is a simple example of how to use `retrival25`:

```python
from retrival25.rank import ranker

# Add you data here
corpus = [
    "a cat is a feline and likes to purr",
    "a dog is the human's best friend and loves to play",
    "a bird is a beautiful animal that can fly",
    "a fish is a creature that lives in water and swims",
]

# pass data to be preprocessed and indexed
obj = ranker(corpus=corpus, type="robertson", k=1.2, b=0.75)

# return top n retrived documents
obj.get_top_n(query=query[0], n=10)

```

## Variants 

You can use the following variants of BM25 

* Original implementation (`type="robertson"`)
* ATIRE (`type="atire_bm25"`)
* BM25L (`type="bm25_L"`)
* BM25+ (`type="bm25_plus+"`)
* BM25-adbt (`type="bm25_adbt"`)

By default ranker uses `type="robertson"`
condat-gridconv 0.2.1
Convert data from hexagonal pixels to cartesian grid
Requires Python: >=3.8

## Hexagonal-cartesian grid conversion

This is an implementation of (part of) the algorithm described in
Condat et al. [*Reversible, fast, and high-quality grid conversions*](https://lcondat.github.io/publis/Condat-TIP-2008.pdf),
IEEE Transactions on Image Processing, vol. 17, no. 5, pp. 679-693, May 2008.
It transforms data sampled on a hexagonal grid, such as an X-ray detector with
hexagonal pixels, into a conventional cartesian lattice.

Specifically, it implements what that paper describes as a Type II fractional
delay filter, with N=2.

This package is based on code written by Andreas Scherz and Rafael Gort.
aioservicethread 0.2.0
An abstract class for asyncio services that run in their dedicated threads.
Requires Python: <4,>=3.9

# aioservicethread

An abstract class for asyncio services that run in their dedicated threads.

## Installation

```shell
pip install aioservicethread
```

## Examples

### Running multiple services

This example shows running multiple services in dedicated threads. When the server needs to shut down, each service can execute its graceful shutdown procedures.

```python
import asyncio
import logging
import time

from aioservicethread import AioServiceThread

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# ...


class MyServer(AioServiceThread):
    port: int

    def __init__(self, name: str = "server-1", port: int = 8080):
        super().__init__(name=name)
        self.port = port

    async def serve_forever(self):
        while True:
            await asyncio.sleep(3600)

    async def _arun(self):
        self.service_running.set()
        self.log(f"started on port {self.port}")

        # start serving
        task1 = asyncio.create_task(self.serve_forever())

        # wait for the stop event
        await self._astop_event.wait()

        # gracefully shut down the server
        self.log("stopping")

        task1.cancel()
        try:
            await task1
        except asyncio.CancelledError:
            pass

        self.log("done")


# ...


def main():
    server1 = MyServer("server-1", port=8080)
    server2 = MyServer("server-2", port=8181)

    logger.info("starting services ...")

    server1.start()
    server2.start()

    # serve until stopped
    print("Press Ctrl-C to exit")
    try:
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        print(" shutting down")

    logger.info("stopping services")

    server1.stop_and_join()
    server2.stop_and_join()

    logger.info("done")


if __name__ == "__main__":
    main()
```

Output:
```log
INFO:__main__:starting services ...
INFO:MyServer.server-2:started on port 8181
Press Ctrl-C to exit
INFO:MyServer.server-1:started on port 8080
^C shutting down
INFO:__main__:stopping services
INFO:MyServer.server-1:stopping
INFO:MyServer.server-1:done
INFO:MyServer.server-2:stopping
INFO:MyServer.server-2:done
INFO:__main__:done
```