semvec/pypi-packages huggingface dataset:
shelve-login 0.0.1
A very simple user management system
License: MIT
Keywords: login

## INSTRUCTIONS 

# Installation 
`pip install shelve_login` 

# The start function 

`start()`

The start function must be called before calling any other functions.
It sets up a database and creates anything else that is essential.
Also creates a new user `ADMIN`.

# User info
`user_info()`
Gives information about the user.

# Login

`login(name, password)`
Checks for an existing user and returns a `True` or a `False` value 
For eg -->
`sign_up('User', 'test@123')`

# Sign Up

`sign_up(name, password)`
Creates a new user.Returns `False` if a user with the same `name` exist.
For eg -->
`sign_up('Jack', 'test@123')`
internet-sabotage2 0.1.3
Disable network connection for Testing
License: MIT
Keywords: internet disable unittest

Internet Sabotage
=================

Python package to simulate internet failures for testing purposes.

This fork fix error in original repository.

Installation
------------

.. code:: shell

    $ pip install internet-sabotage2

Usage
-----

.. code:: python

    from internet_sabotage import no_connection

    with no_connection():
        response = requests.get('http://httpbin.org/ip')

or

.. code:: python

    from internet_sabotage import no_connection

    @no_connection
    def test_something():
        pass

License
-------

MIT
lmt8x 1.0.0
Transfer tables for LMT8x Temperature Sensors.
License: MIT
Requires Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*

========
Overview
========



Transfer tables for LMT8x Temperature Sensors.

LMT8x (LMT84, LMT85, LMT86, LMT87) are a series of `analog temperature sensors <https://www.ti.com/sensors/temperature-sensors/overview.html>`_ made by Texus Instrument.
These sensors can provide -50°C ~ 150°C with ±0.4°C accuracy. Although the output voltage is nearly linear to the temperature, it does have a slight umbrella parabolic shape.
Therefore transfer tables are required to convert the voltage to the temperature.

Datasheets:

- `LMT84 <https://www.ti.com/lit/ds/symlink/lmt84.pdf>`_
- `LMT85 <https://www.ti.com/lit/ds/symlink/lmt85.pdf>`_
- `LMT86 <https://www.ti.com/lit/ds/symlink/lmt86.pdf>`_
- `LMT87 <https://www.ti.com/lit/ds/symlink/lmt87.pdf>`_


This package provides tranfer functions for LMT84, LMT85, LMT86, and LMT87 based on their transfer tables.
These funcitons basically do a binary search through the transfer tables and return the match.
If no match found, linear interpolation will be used to generate an approximate value.


Installation
============

::

    pip install lmt8x

You can also install the in-development version with::

    pip install https://github.com/charlee/python-lmt8x/archive/master.zip

Usage
======

`lmt8x` package provides functions `lmt84_v2t`, `lmt85_v2t`, `lmt86_v2t`, and `lmt87_v2t` for converting voltage to temperature.

- input voltage must be in mV.
- output temperature is in celsius.

::

  from lmt8x import lmt87_v2t     # or `lmt86_v2t`, `lmt85_v2t`, `lmt84_v2t`

  # read voltage from sensors.
  # v = read_sensor()

  # convert v to temperature.
  # the pamaeter must be in mV. Return value is in celsius.
  temp = lmt87_v2t(v * 1000)

  print('Temperature is %s C.' % temp)
  

Documentation
=============


https://python-lmt8x.readthedocs.io/


Development
===========

To run all the tests run::

    tox

Note, to combine the coverage data from all the tox environments run:

.. list-table::
    :widths: 10 90
    :stub-columns: 1

    - - Windows
      - ::

            set PYTEST_ADDOPTS=--cov-append
            tox

    - - Other
      - ::

            PYTEST_ADDOPTS=--cov-append tox


Changelog
=========

1.0.0 (2021-04-02)
------------------

* First release on PyPI.
imparaai-BFHScheckers-for-BFHS-programming 1.4.2.4
Library for playing a standard game of checkers/draughts
License: MIT

A Python3 library that you can use to play a game of checkers/draughts. This is just a set of classes that you can use in your code, it's not an interactive shell checkersgame.

#Note:
This is a modified version of the [Imparaai checkers library](https://github.com/ImparaAI/checkers).
Alongside the base module (which I forked from the repository at the above link), the Colorama and PrettyTable dependencies are also in use.
The only addition I have made to this module is a graphical representation of the board.
# Assumptions

The rules used are for competitive American checkers or English draughts. This means an 8x8 board with **force captures** and regular kings.

Each position on the board is numbered 1 to 32. Each move is represented as an array with two values: starting position and ending position. So if you're starting a new game, one of the available moves is `[9, 13]` for player 1. If there's a capture move, the ending position is the position the capturing piece will land on (i.e. two rows from its original row), which might look like `[13, 22]`.

Each piece movement is completely distinct, even if the move is part of a multiple capture series. In [Portable Draughts Notation](https://en.wikipedia.org/wiki/Portable_Draughts_Notation) mutli-capture series are usually represented by a `5-32` (for a particularly long series of jumps), but in certain situations there could be multiple pathways to achieve that final position. This game requires an explicit spelling out of each distinct move in the multi-capture series.

# Usage

Create a new game:

```python
from BFHScheckers.game import Game

game = Game()
```

See whose turn it is:

```python
game.whose_turn() #1 or 2
```

Get the possible moves:

```python
game.get_possible_moves() #[[9, 13], [9, 14], [10, 14], [10, 15], [11, 15], [11, 16], [12, 16]]
```

Make a move:

```python
game.move([9, 13])
```

Check if the game is over:

```python
game.is_over() #True or False
```

Find out who won:

```python
game.get_winner() #None or 1 or 2
```

Review the move history:

```python
game.moves #[[int, int], [int, int], ...]
```

Change the consecutive noncapture move limit (default `40` according to the [rules](http://www.usacheckers.com/rulesofcheckers.php)):

```python
game.consecutive_noncapture_move_limit = 20
game.move_limit_reached() #True or False
```

Review the pieces on the board:

```python
for piece in game.board.pieces:
	piece.player #1 or 2
	piece.other_player #1 or 2
	piece.king #True or False
	piece.captured #True or False
	piece.position #1-32
	piece.get_possible_capture_moves() #[[int, int], [int, int], ...]
	piece.get_possible_positional_moves() #[[int, int], [int, int], ...]
```

Get a string representation of the pieces on the board:


```python
str(game.board)
```
Output:

![Output](img_1.png)


# Testing

Run `python3 -m unittest discover` from the root.