semvec/pypi-packages huggingface dataset:
MojangAPI 0.0.5
An async python wrapper for Mojangs API and Authentication API
Requires Python: >=3.7

# Mojang-API-Wrapper
## Overview
* Pythonic wrapper making use of `await` and `asnyc`
* 100% Coverage of Mojang's API and Authentication API

# Examples
### Accessing a players skin
```python
from MojangAPI import Client
import asyncio

async def main():
    user = await Client.User.createUser('Minecraft playername')
    profile = await user.getProfile()
    print(profile.skin) # Will print the skins URL

loop = asyncio.get_event_loop()
loop.run_until_complete(main())
```


### Changing a players skin
<details><summary>Note</summary>
<p>
Please note that Mojang's API may not trust your IP. To check if this is the case run the following code:

```python
from MojangAPI import Client
import asyncio

async def main():
    user = await Client.User.createUser('Minecraft playername')
    await user.authenticate('Mojang Email', 'Mojang password')
    await user.checkForSecurityQuestions() 
    # Will raise an error if untrusted
```

If your IP is untrusted you can complete security challenges to become trusted (I believe you only need to do this once). To get the security questions your Mojang account will need them active (refer to https://help.minecraft.net/hc/en-us/articles/360034686852-Resetting-Security-Questions). After which run `questions = await user.getSecurityQuestions()` to get the questions, and then `await user.sendSecurityAnswers(answers)` with the answers in the form refered to in the API's documentation (https://wiki.vg/Mojang_API#Send_back_the_answers).
</p>
</details>

```python
from MojangAPI import Client
import asyncio

async def main():
    user = await Client.User.createUser('Minecraft playername')
    await user.authenticate('Mojang Email', 'Mojang password')
    await user.changeSkin('Skin url', slim_model = True)

loop = asyncio.get_event_loop()
loop.run_until_complete(main())
```

### Getting sales data
```python
from MojangAPI import DataService
import asyncio

async def main():
    data = await DataService.Data.getStatistics(prepaid_card_redeemed_minecraft=True)
    # Valid keyword arguments can be found at https://wiki.vg/Mojang_API#Payload_4
    print(data)
    
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
```
QuantumChemPy 0.2
Paquete con algunas herramientas útiles para programar teorías de química cuántica en Python
Requires Python: >=3.6

# QuantumChemPy

Este es un paquete que contiene diversas utilidades para programar y probar ideas y teorías de química cuántica.

Este paquete está en proceso de creación y aún no se encuentra en estado de producción.

## Instalación

Puede instalar este paquete con
```
pip install quantumchempy
```

## Tutoriales

Algunas pruebas se encuentra en la carpeta tests

## Autores

M. en C. Juan Felipe Huan Lew Yee
Dr. Jorge Martín del Campo Ramírez
pyperlin 1.1.0
GPU accelerated Perlin noise
Requires Python: >=3.6

# pyperlin
[![Build Status](https://travis-ci.com/duchesneaumathieu/pyperlin.svg?branch=master)](https://travis-ci.com/duchesneaumathieu/pyperlin)
[![Coveralls github](https://img.shields.io/coveralls/github/duchesneaumathieu/pyperlin)](https://coveralls.io/github/duchesneaumathieu/pyperlin?branch=master) 

GPU accelerated Perlin Noise in python

Limitation: resolutions needs to divide shape

Using pytoch as the array backend makes the GPU acceleration trivial. Also it uses batch sampling to better use parallelization.

By playing with the parameters of Perlin noise, it is possible to create different textures. (code at the bottom)
![alt text](pyperlin/examples/clouds_and_fire.png?raw=true)

## Installation
```bash
pip install pyperlin
```

## Usage
```python
import torch
from pyperlin import FractalPerlin2D

shape = (32,256,256) #for batch size = 32 and noises' shape = (256,256)
resolutions = [(2**i,2**i) for i in range(1,7)] #for lacunarity = 2.0
factors = [.5**i for i in range(6)] #for persistence = 0.5
g_cuda = torch.Generator(device='cuda') #for GPU acceleration
fp = FractalPerlin2D(shape, resolutions, factors, generator=g_cuda)
noise = fp() #sampling
```

## Benchmarks
CPU: Intel(R) Core(TM) i7-6850K CPU @ 3.60GHz

GPU: Nvidia Titan XP
| Algorithms | (1,256,256);1octaves | (1,256,256);6octaves | (32,256,256);6octaves | (32,1024,1024);8octaves |
| --- | --- | --- | --- | --- |
| noise.pnoise2  | 73.8 ms | 86.3 ms | 2.85 s | 48 s |
| pyperlin.FractalPerlin2D (cpu)  | 1.15 ms | 11.5 ms | 377 ms | 8.49 s |
| pyperlin.FractalPerlin2D (gpu)  | 481 µs | 2.84 ms | 16.8 ms | 121 ms |


## More Examples
```python
import torch
from pyperlin import FractalPerlin2D
import matplotlib.pyplot as plt

shape = (1,1024,1024) #for batch size = 1 and noises' shape = (1024,1024)
factors = [.5**i for i in range(8)] #for persistence = 0.5
g_cuda = torch.Generator(device='cuda') #for GPU acceleration

clouds_resolutions = [(2**i,2**i) for i in range(1,7)] #for lacunarity = 2.0
clouds_factors = [.5**i for i in range(6)] #for persistence = 0.5
clouds = FractalPerlin2D(shape, clouds_resolutions, clouds_factors, generator=g_cuda)().cpu().numpy()[0]

fire_resolutions = [(2**i,4**i) for i in range(1,4)] #for lacunarity = 2.0 and 4.0
fire_factors = [.5**i for i in range(3)] #for persistence = 0.5
fire = FractalPerlin2D(shape, fire_resolutions, fire_factors, generator=g_cuda)().cpu().numpy()[0]

fig = plt.figure(figsize=(10,5))

ax1 = fig.add_subplot(121)
ax1.set_axis_off()
ax1.set_title('Clouds')
ax1.imshow(clouds, vmax=1.2, cmap=plt.get_cmap('Blues'))

ax2 = fig.add_subplot(122)
ax2.set_axis_off()
ax2.set_title('Fire')
ax2.imshow(fire, vmax=.3, cmap=plt.get_cmap('YlOrBr'))

fig.show()
```
nxp-dlagent 0.1.0
Download agent for NXP material
Requires Python: >=3.6

# nxp-dlagent

[NXP][nxp] keeps certain documentation and software behind a login wall.  
This tool allows downloading such material in an automated fashion.

[nxp]: https://www.nxp.com

### How To Use

The URL scheme is: <https://www.nxp.com/webapp/Download?colCode={col_code}&appType=license>, 
where `col_code` can be, e.g., `UM11126`, `blhost_2.6.2` or `elftosb_5.6.19`.

Command: `nxp-dl <col_code>`.

Output: the upstream file, e.g. `UM11126.pdf`, or `blhost_2.6.2.zip`.

The script prompts for username and password of an existing NXP account.  
Alternatively, the environment variables `NXP_USERNAME` and `NXP_PASSWORD` can be set.

### Install / Requirements

`pip install .` should work, if you have the requirements:

- <https://pypi.org/project/selenium/>
- <https://github.com/mozilla/geckodriver/>


#### License

<sup>The NXP material has properietary licensing, please read the actual license prompt!
<br>
`nxp-dlagent` itself is dual-licensed under both [Apache License, Version 2.0](LICENSE-APACHE) and [MIT License](LICENSE-MIT).</sup>
<br>
<sub>Any contribution you submit for inclusion in the work (as defined in the Apache-2.0 license, e.g., as GitHub pull request) shall be dual-licensed as above, without any additional terms or conditions.</sub>