semvec/pypi-packages huggingface dataset:
ellipsis-AI 0.0.1
Package to use Ellipsis Drive for AI
Requires Python: >=3.6

This package is meant to help you run models on Ellipsis Drive content.


applyModel(model, blockId, captureId, targetBlockId, targetCaptureId, visualizationId, inputWidth, token)

model must be a function mapping a (inputWidth,inputWidth,b) numpy array to an (inputWidth,inputWidth) numpy array.

model: a function mapping a inputWidth by inputWidth by bands numpy array to a 3 dimensional numpy array. The resulting numpy array should always have the same shape.
blockId: the id of the block to classify
captureId: the id of the capture to classify
targetBlockId: the id of the block to write the classifications to
targetCaptureId: the id of the capture to write the classifications to
inputWidth: the size of the input array. Must be a number divisible by 256
visualizationId: id of the visualization to use as input. If not specified the original raster is used.
token: your token
gamesense 0.0.5
Library for interacting with SteelSeries GameSense 3.8.x

# gamesense
A Python library for use with SteelSeries GameSense 3.8.X+

## Installation

There are two different versions of this package. One supports normal synchronous function calls and the other support python's asynchronous functionality.

To install the sync version run:
```
pip install gamesense[sync]
```

To install the async version run:
```
pip install gamesense[async]
```

Or both:
```
pip install gamesense[sync,async]
```

## Usage
Relatively simple to use.

For synchronous usage:
```python
import gamesense

# Create a GameSense object instance to use
gs = gamesense.GameSense("SYNC_GAME", "Sync Game")

# Before you can register or send events, you must register your game
gs.register_game(icon_color_id=gamesense.GS_ICON_GOLD)

# Register an event (different than binding an event, see more info in the SteelSeries docs)
gs.register_event("DID_STUFF")

# Test out the event by sending the event
gs.send_event("DID_STUFF", {"value": 22})
```

For asynchronous usage:
```python
import asyncio
import gamesense

# For example purposes, need an event loop 
# Inside normal async functions, you'd just use await on the functions provided on AioGameSense
loop = asyncio.get_event_loop()

# Create a GameSense object instance to use
gs = gamesense.AioGameSense("ASYNC_GAME", "Async Game")

# Before you can register or send events, you must register your game
loop.run_until_complete(gs.register_game())

# Register an event (different than binding an event, see more info in the SteelSeries docs)
loop.run_until_complete(gs.register_event('DID_STUFF'))

# Test out the event by sending the event
loop.run_until_complete(gs.send_event("DID_STUFF", {"value": 23}))
```

The two examples do relatively the same thing. For more information about the SteelSeries GameSense API, see: https://github.com/SteelSeries/gamesense-sdk/tree/master/doc/api for more information. Things like binding handlers and such should be possible, but can be a bit complex. Commits are welcome for making such functionality easier.
count-min-sketch-rs 1.0.0
A fast CMS streaming data structure implemented in rust

# count-min-sketch
A simple CMS datstructure in rust. CMS can be created with explicit parameters, with tolerance and probability, or by copying an existing CMS to enable combinations.

Each CMS provides methods to insert and retrieve counts, combine with another CMS, and to multiply all entries by a constant.

The python interface provides access to the new_with_probs constructor which builds a CMS with the methods insert, retrieve, clear, and scale. A python CMS can store any object which implements __hash__()
```
>>> import count_min_sketch
>>> cms1 = count_min_sketch.CMS(0.1,0.001,10000)
>>> cms1.insert("test")
1
>>> cms1.insert(54)
1
>>> cms1.insert(54)
2
>>> cms1.retrieve(54)
2
```

A CMS basis hash set can be cloned allowing it to be combined with an existing CMS. This is useful to maintain multiple sets of counts and periodically combine them. This method will throw an error if they did not originate as clones.

```
>>> cms2 = count_min_sketch.clone_cms(cms1)
>>> cms2.combine(cms1)
>>> cms2.retrieve("test")
1
>>> cms2.retrieve(54)
2
>>> 
```