semvec/pypi-packages huggingface dataset:
osu-apy-v2 0.1.7
small osu api v2 helper
Requires Python: >=3.8,<4.0

handles refreshing the access_token and stores a mapping of known osu player names and ids in a sqlite database.\
read the [osu!api v2 Docs](https://osu.ppy.sh/docs/index.html)

```console
pip install osu-apy-v2
```

```py
from osu_apy_v2 import OsuApiV2

api = OsuApiV2(application_id, application_secret)
user_id = api.get_user_id("whitecat")
res = api.get(f"/users/{user_id}/scores/best?mode=osu&limit=1")
print(res.json())
```
timestamp2vec 1.0.0
Vectorizing Timestamps by means of a Variational Autoencoder
Keywords: python,vector,time,timestamps

# Timestamp2Vec
The Timestamp2Vec model consists of 2 parts: a feature extractor and an encoder, which is originally part of a variational autoencoder (VAE). The input of Timestamp2Vec is a timestamp, or multiple timestamps, in the shape YYYY-MM-DD HH:MM:SS and is of type String. The String(s) should be placed inside a list. The output of the model is a numpy array of shape (1, 8). To make use of Timestamp2Vec, install the package first. Afterward, import the model using "from timestamp2vec.Timestamp2Vec import Timestamp2Vec". Next, instanciate an instance of the model, for example: "timestamp2vec = Timestamp2Vec()". Finally, feed the model a list of timestamp(s) to obtain the vector(s). <br>
Please see the GitHub page (Homepage) to see an example.
slightly-better-types 1.2.1
Improved abstraction for dealing with union and named types.
Requires Python: >=3.9

# slightly-better-types

... arguably

Improved abstraction for dealing with union and named types.

## Installation

```bash
pip install slightly-better-types==1.2.1
```

## Usage

Using the `Parameter` class directly

```python
from inspect import signature
from typing import get_type_hints
from slightly_better_types.parameter import Parameter


class Foo:
    pass


def accepts_string(a: Foo):
    pass


signature = signature(accepts_string)
type_hints = get_type_hints(get_type_hints(accepts_string))

parameter = list((signature.parameters.values()))[0]
parameter = Parameter(parameter=parameter, type_hint=type_hints.get(parameter.name))

parameter.accepts(1)  # False
parameter.accepts(Foo())  # True


```

Using the `Function` class:

```python
from slightly_better_types.function import Function


def accepts_string(a: str, b: int):
    pass


sb_function = Function(accepts_string)

sb_function.accepts('string', 1)  # True
sb_function.accepts(1, 'string')  # False
sb_function.accepts('string')  # False
```

Using `Handlers` to determine which methods accept a given set of input:

```python
from slightly_better_types.handlers import Handlers


class Bar:
    def accepts_string(self, a: str):
        pass

    def accepts_string_too(self, a: str):
        pass

    def accepts_int(self, a: int):
        pass


handlers = Handlers(Bar)
list(handlers.accepts('a string').all().keys())  # ['accepts_string', 'accepts_string_too']
list(handlers.accepts(1).first().get_name())  # 'accepts_int'
```

## Tests

```bash
python3 -m unittest
```

## License

The MIT License (MIT). Please see [License File](LICENSE.md) for more information.