semvec/pypi-packages huggingface dataset:
ladybug-dotnet 1.1.1
A library for communicating between Ladybug Tools core Python libraries and .NET libraries

[![Build Status](https://travis-ci.org/ladybug-tools/ladybug-dotnet.svg?branch=master)](https://travis-ci.org/ladybug-tools/ladybug-dotnet)

[![IronPython](https://img.shields.io/badge/ironpython-2.7-red.svg)](https://github.com/IronLanguages/ironpython2/releases/tag/ipy-2.7.8/)

# ladybug-dotnet

A library for communicating between Ladybug Tools core Python libraries and .NET libraries

## Installation
```
pip install ladybug-dotnet
```

## QuickStart
```python
import ladybug_dotnet

```

## [API Documentation](http://ladybug-tools.github.io/ladybug-dotnet/docs)

## Local Development
1. Clone this repo locally
```
git clone git@github.com:ladybug-tools/ladybug-dotnet

# or

git clone https://github.com/ladybug-tools/ladybug-dotnet
```
2. Install dependencies:
```
cd ladybug-dotnet
pip install -r dev-requirements.txt
pip install -r requirements.txt
pip install pythonnet
```

3. Generate Documentation:
```
sphinx-apidoc -f -e -d 4 -o ./docs ./ladybug_dotnet
sphinx-build -b html ./docs ./docs/_build/docs
```
polysdk 0.0.8
Polymer Python SDK.
Requires Python: >=2.7

# polysdk

## Package Installation

```
pip install polysdk
```

## Usage

```python
#!/usr/bin/env python

"""
make sure to run
pip install polysdk to be able 
to import from the package polysdk below
"""
from polysdk import PolyClient

"""
visit https://v1.polymerapp.io/ where
you can generate client_token from 
"Developer API" option under user icon
"""
client_token = "<your_client_token_here>"

# initializing client using client_token
client = PolyClient(api_token=client_token)

# masking key can be less than or equal to 16 characters
masking_key = "<your_masking_key_here>"

"""
masking/unmasking text
"""
input_data = "Hey a@b.com!"
masked_data = client.mask_text(text=input_data, key=masking_key)
masked_data.get_text()

unmasked_data = client.unmask_text(text=masked_data.get_text(), key=masking_key)
unmasked_data.get_text()

"""
masking/unmasking file
"""
fmd = client.mask_text_file(file_path="<your_file_path>", key=masking_key)
fmd.get_text()

fumd = client.unmask_text_file(file_path="<your_file_path>", key=masking_key)
fumd.get_text()
```
twitch-MagicaFreak 1.0.0
A Twitch Wrapper for Python 3.6 or higher for the new Twitch API
Requires Python: >=3.6

# TwitchAPI Wrapper
A Twitch Wrapper for Python 3.6 or higher for the new Twitch API with its App Token
### Installation
```
pip install twitch-MagicaFreak
```
## Getting Started
To start a session with Twitch you just use:
```
from twitch.twitch import Twitch

async with Twitch("client_id","client_secret") as example_name:
```
Now to get something from the Twitch App you just use your name and the function you want.
As an example:
```
from twitch.twitch import Twitch

async with Twitch("client_id","client_secret") as example_name:
    await example_name.user('MagicaFreak')
```

##Functions
All the functions that exist at the moment

### Twitch User
It gets the user by his username
```
from twitch.twitch import Twitch

async with Twitch("client_id","client_secret") as example_name:
    await example_name.user('Username')
```
This can be done for multiple users too
```
from twitch.twitch import Twitch

async with Twitch("client_id","client_secret") as example_name:
    await example_name.user(['Username1', 'Username2', 'Username3'])
```
And it returns a list of users that you searched for

### Twitch Stream
It gets the stream that is live by the name of the streamer
```
from twitch.twitch import Twitch

async with Twitch("client_id","client_secret") as example_name:
    await example_name.stream('Streamername')
```
This can be done for multiple streams too
```
from twitch.twitch import Twitch

async with Twitch("client_id","client_secret") as example_name:
    await example_name.stream(['Streamername1', 'Streamername2', 'Streamername3'])
```
And it returns a list of streams that you searched for

### Twitch Tags
It gets the tag by the tag ID
```
from twitch.twitch import Twitch

async with Twitch("client_id","client_secret") as example_name:
    await example_name.tag('tag ID')
```
This can be done for multiple tags too
```
from twitch.twitch import Twitch

async with Twitch("client_id","client_secret") as example_name:
    await example_name.tag(['tagID1', 'tagID2', 'tagID3'])
```
And it returns a list of tags that you searched for

### Twitch game
It gets the game by its name
```
from twitch.twitch import Twitch

async with Twitch("client_id","client_secret") as example_name:
    await example_name.game('game name')
```
This can be done for multiple games too
```
from twitch.twitch import Twitch

async with Twitch("client_id","client_secret") as example_name:
    await example_name.game(['gamename1', 'gamename2', 'gamename3'])
```
And it returns a list of the games that you searched for

### Twitch Top Games
It gets the top games of the moment
```
from twitch.twitch import Twitch

async with Twitch("client_id","client_secret") as example_name:
    await example_name.top_games()
```
And it returns a list of the top games
one-home-sensor 0.1.6
My home tempearture sensor for my RaspberryPi
Requires Python: >=3.5

[![Build Status](https://travis-ci.org/LeadTheSalt/one_home_sensor.svg?branch=master)](https://travis-ci.org/LeadTheSalt/one_home_sensor)
# One Home Sensor

This peace of software reads temperature, pressure and humidity from a BME280 sensor. It then pushes the result to a MongoDB data-base (MongoDB Atlas form my part). 

## Usage 
My setup is as followed :
```
  +-------------+
  | RaspberryPI |    +-------------+    +-------------+ 
  |             |    |  MongoDB    |    |  Phone /    |
  |  one_home_  +--->|  Atlas      +--->|  WebBrowser |
  |     sensor  |    +-------------+    +-------------+
  +-------------+
```
I periodically run it (throught systemd) to store the values. 


## Integration / Instalation
This programe is created and only used/tested/supported in python3. These commande should solve all dificulties. 

```
sudo apt-get update
sudo apt-get install python3-setuptools python3-pip i2c-tools 
```
1. Create cluster on MongoDB Atlas
2. Create connection autorization and user 
3. Create configuration file (see next section)
4. Enable  I2C in raspi-config (5 then P5).
5. Add user to group "i2c" (sudo usermod -a -G i2c leadthesalt)

Finaly the module is installed with pip3.
```
pip3 install one-home-sensor
```

For my part I install the programe with an Ansible rôle. Sure I could create a debian package, but I only use it on my Raspbery Pi that are already managed throught Ansible. 
 
## Configuration file 
```
[MongoDBAtlasConnection]
username = # username set for MongoDB
password = # password set for MongoDB
clusterfqdn = # fqdn to MongoDB server 

[Correction]
temp=-1
```

## Documentations 
https://github.com/pimoroni/bme280-python  
https://github.com/pimoroni/skywriter-hat/issues/4  
https://learn.pimoroni.com/related-products/adafruit-mpl3115a2-i2c-barometric-pressure-altitude-temperature-sensor  
https://docs.mongodb.com/
auguste 0.1.5
Minimum-strain symmetrization of Bravais lattices
Requires Python: >=3.5.0

# auguste

A python module for minimum-strain symmetrization of Bravais lattices.  Symmetrization produces a strain tensor, which is reduced to a scalar quantity.  This quantifies the 'distance' of a lattice from each Bravais class.  The distance can be used for classification of Bravais lattices, and visualization in an abstract Bravais space.


### Installation:

To install the module with pip (recommended):
```
pip install --user auguste
```

To install directly from the git repository:
```
pip install --user git+https://github.com/pmla/auguste
```

To do a manual build and installation:
```
python3 setup.py build
python3 setup.py install --user
```

### Usage:
To import the module:
```
>>> import auguste
```

To symmetrize a lattice (with rows as unit vectors):
```
>>> cell = [[0, 1, 1], [1, 0, 1], [1, 1, 0]]
>>> distance, symmetrized = auguste.symmetrize_lattice(cell, "primitive tetragonal")
>>> distance
0.4714045207910317
>>> symmetrized
array([[-0.37037037,  0.74074074,  0.74074074],
       [ 0.74074074, -0.37037037,  0.74074074],
       [ 0.74074074,  0.74074074, -0.37037037]])
```

Supported lattice names are stored in the module variables:
```
>>> auguste.names
('primitive triclinic', 'primitive monoclinic', 'base-centred monoclinic', 'primitive orthorhombic', 'base-centred orthorhombic', 'body-centred orthorhombic', 'face-centred orthorhombic', 'primitive tetragonal', 'body-centred tetragonal', 'primitive rhombohedral', 'primitive hexagonal', 'primitive cubic', 'body-centred cubic', 'face-centred cubic')
>>> auguste.pearson
('aP', 'mP', 'mS', 'oP', 'oS', 'oF', 'oI', 'tP', 'tI', 'hP', 'hR', 'cP', 'cF', 'cI')
```
To calculate the symmetrization distances from all Bravais types:
```
>>> auguste.calculate_vector(cell)
array([0.00000000e+00, 4.28372991e-01, 5.24426159e-16, 4.71404521e-01,
       4.28372991e-01, 3.80565279e-16, 1.92296269e-16, 4.71404521e-01,
       4.07921987e-16, 1.92296269e-16, 4.60895951e-01, 4.71404521e-01,
       2.61971659e-01, 0.00000000e+00])
```

### Information
If you use auguste in a publication, please cite:

Peter M. Larsen, Edward L. Pang, Pablo A. Parrilo, and Karsten W. Jacobsen; "Minimum-strain symmetrization of Bravais lattices"; Phys. Rev. Research 2, 013077

Article available at https://doi.org/10.1103/PhysRevResearch.2.013077

Preprint available at https://arxiv.org/abs/1910.03433.