semvec/pypi-packages huggingface dataset:
pyarmodel 0.0.1.dev0
AUTOSAR model management
License: MIT
Requires Python: >=3
Keywords: AUTOSAR ARXML

# pyarmodel

## What
AUTOSAR model

## How to create the distribution and upload to pypi
1. `python setup.py bdist_wheel`
2. `twine check dist/*`
3. `twine upload dist/*`

## CLI usages
da-rnn 1.0.2
A tensorflow 2.0 implementation of the Dual-Stage Attention-Based Recurrent Neural Network for Time Series Prediction
License: MIT
Requires Python: >=3.7
Keywords: da_rnn

[![](https://travis-ci.org/kaelzhang/DA-RNN-in-Tensorflow-2-and-PyTorch.svg?branch=master)](https://travis-ci.org/kaelzhang/DA-RNN-in-Tensorflow-2-and-PyTorch)
[![](https://codecov.io/gh/kaelzhang/DA-RNN-in-Tensorflow-2-and-PyTorch/branch/master/graph/badge.svg)](https://codecov.io/gh/kaelzhang/DA-RNN-in-Tensorflow-2-and-PyTorch)
[![](https://img.shields.io/pypi/v/da-rnn.svg)](https://pypi.org/project/da_rnn/)
[![](https://img.shields.io/pypi/l/da-rnn.svg)](https://github.com/kaelzhang/DA-RNN-in-Tensorflow-2-and-PyTorch)

# Tensorflow 2 DA-RNN

A Tensorflow 2 (Keras) implementation of the [Dual-Stage Attention-Based Recurrent Neural Network for Time Series Prediction](https://arxiv.org/abs/1704.02971)

Paper: [https://arxiv.org/abs/1704.02971](https://arxiv.org/abs/1704.02971)

## Install

For Tensorflow 2

```sh
pip install da-rnn[keras]
```

For PyTorch

```sh
pip install da-rnn[torch]
```

## Usage

For Tensorflow 2

```py
from da_rnn.keras import DARNN

model = DARNN(T=10, m=128)

# Train
model.fit(
    train_ds,
    validation_data=val_ds,
    epochs=100,
    verbose=1
)

# Predict
y_hat = model(inputs)
```

For PyTorch (with poutyne)

```py
import torch
from poutyne import Model
from da_rnn.torch import DARNN

darnn = DARNN(n=50, T=10, m=128)
model = Model(darnn)

# Train
model.fit(
    train_ds,
    validation_data=val_ds,
    epochs=100,
    verbose=1
)

# Predict
with torch.no_grad():
    y_hat = model(inputs)
```

### Python Docstring Notations


In docstrings of the methods of this project, we have the following notation convention:

```
variable_{subscript}__{superscript}
```

For example:

- `y_T__i` means ![y_T__i](https://render.githubusercontent.com/render/math?math=y_T^1), the `i`-th prediction value at time `T`.
- `alpha_t__k` means ![alpha_t__k](https://render.githubusercontent.com/render/math?math=\alpha_t^k), the attention weight measuring the importance of the `k`-th input feature (driving series) at time `t`.

### DARNN(T, m, p, y_dim=1)
### DARNN(n, T, m, p, y_dim=1)

> The naming of the following (hyper)parameters is consistent with the paper, except `y_dim` which is not mentioned in the paper.

- **n** (torch only) `int` input size, the number of features of a single driving series
- **T** `int` the length (time steps) of the window
- **m** `int` the number of the encoder hidden states
- **p** `int` the number of the decoder hidden states
- **y_dim** `int=1` the prediction dimention. Defaults to `1`.

Return the DA-RNN model instance.

## Data Processing

Each feature item of the dataset should be of shape `(batch_size, T, length_of_driving_series + y_dim)`

And each label item of the dataset should be of shape `(batch_size, y_dim)`

## Development

Install dependencies:

```sh
make install
```

Run notebook:

```sh
cd notebook
jupyter lab
```

## TODO
- [x] no hardcoding (`1` for now) for prediction dimentionality

## License

[MIT](LICENSE)
pyxtensor 0.3.1
pybind11 details for xtensor
License: MIT
Keywords: C++,C++11,C++14,Python bindings,pybind11,xtensor

This library provides details for pybind11 such that an interface to NumPy arrays is automatically
provided when including a function that takes any of the xtensor classes as (return) argument(s).

Note that this library is simpler but more naive than xtensor-python as arguments are always copies
of the NumPy arrays. This simplifies the Python wrapper code greatly, but comes at the prices of
having to copy.

This library also provides a small Python library that can be used to compile the wrapper code using
a 'setup.py'.
normetapi 0.1.0
A small library for interacting with the MET Norway Weather API.
License: MIT
Keywords: met api

# normetapi
A small Python library for interacting with the [MET Norway Weather API](https://api.met.no/).

## Installation

```bash
pip install normetapi
```

## Examples

### Getting a forecast for a specified location:

```python
from normetapi import location_forecast

# Get forecast for Trondheim:
forecast = location_forecast(63.4107, 10.4538)
print(forecast)
```

The forecast will be returned as a dictionary. See the description
of [locationforecast](https://api.met.no/weatherapi/locationforecast/2.0/documentation)
and the [data model](https://api.met.no/doc/locationforecast/datamodel)
in the [MET Norway Weather API description](https://api.met.no/).

### Getting the immediate forecast for a specified location:

```python
from normetapi import nowcast

# Get nowcast for Trondheim:
forecast = nowcast(63.4107, 10.4538, altitude=123)
print(forecast)
```

The forecast will be returned as a dictionary. See the description
of [nowcast](https://api.met.no/weatherapi/nowcast/2.0/documentation)
and the [data model](https://api.met.no/doc/locationforecast/datamodel)
in the [MET Norway Weather API description](https://api.met.no/).

### Getting weather icons:

```python
from normetapi import weathericon

# Get icons:
_, legend = weathericon(output_file='icons.tgz')
print(legend)
```

This will download weather icons as a gzipped tar archive
and return legends as a dictionary. See the
description of [weathericon](https://api.met.no/weatherapi/weathericon/2.0/documentation)
in the [MET Norway Weather API description](https://api.met.no/).

## Terms of service

Please read the [terms of service](https://api.met.no/doc/TermsOfService).
In particular, to quote the terms of service:

> All requests must (if possible) include an identifying User Agent-string (UA)
> in the request with the application/domain name, optionally version number.

Please modify the ``USER_AGENT`` variable in [api.py](normetapi/api.py) to fit your
intended use.
songsdownload 1.0.10
Download Sinhala Songs and Lyrics Easily
License: MIT
Keywords: python,songs,sinhala,lyrics,download,internet

![Python 3.5, 3.6, 3.7](https://img.shields.io/pypi/pyversions/vk_songs.svg)

# Songsdownload
songsdownload is written in Python that downloads sinhala songs and lyrics files.

## Features
--------
- Download Sinhala MP3 songs
- Download Lyrics Files
- Download Array of Songs
--------
## Installation
```pip install songsdownload```

## How to use it?
```python 
from songsdownload import Songsdetails

songs = Songsdetails("query","location") #default location is cwd

songs.downloadsongs()
songs.downloadlyrics()

```
<br />


``` python
from songsdownload import Songsdetails,downloadarraysongs

listofsongs = ["song1","song2"]
downloadarraysongs(listofsongs)

```
<br />

![Result](https://raw.githubusercontent.com/ashen8810/images/main/image.png)


## License

Â© 2021 Ashen Ranaweera

This repository is licensed under the MIT license. See LICENSE for details.
magic-logger 1.0.2
This very simple module does its best to help you use Python's logging correctly, by making sure you always invoke the right Logger for a module.
License: MIT
Requires Python: >=3.6

# magic_logger
| Coverage | Release |
| :------: | :-----: |
| [![Coverage Status](https://coveralls.io/repos/github/RaduG/magic_logger/badge.svg?branch=master)](https://coveralls.io/github/RaduG/magic_logger?branch=master) | ![Release](https://badge.fury.io/py/magic-logger.svg) |

This very simple module does its best to help you use Python's `logging` correctly, by making sure you always
invoke the right `Logger` for a module. No more boilerplace `logger.getLogger(__name__)`! All this
without any external dependencies - this is just a tiny wrapper for `logging`.

## Getting started
To install:
```bash
pip install magic_logger==1.0.0
```

## Overview
Import `logger` from `magic_logger` and just call any methods you'd normally call on a `logging.Logger` instance:

```python
# Let's assume we are in `mypackage.mymodule`
from magic_logger import logger

logger.info("Someting very informative")  # equivalent to logging.getLogger(__name__).info(...)
```

`magic_logger.logger` also acts like a proxy for other commonly used functions in `logging.config`:
```python
logger.dict_config(...)  # dispatches to logging.config.dictConfig
logger.file_config(...)  # dispatches to logging.config.file_config
logger.listen(...)  # dispatches to logging.config.listen
logger.stop_listening(...)  # dispatches to logging.config.stopListening
``` 

### What about the other stuff in `logging`
For anything else, just use `logging` directly. `magic_logger` just proxies calls over anyway so you can use `logging` as usual.

## How does it work?
When you ask for an attribute of `magic_logger.logger` (other than the configuration ones listed above),
it looks at the stack and determines the module from where the call originates. It then returns the attribute
of the same name of the correct logger for that module, using `logging.getLogger`. As simple as that!

### What if I call a module using `python -m` and log something from it, will that use the logger for `__main__`?
No, it will simply look at the module's `__spec__` for the name. Unless you run an interactive session and log straight from it,
you won't ever use the logger for `__main__`!