semvec/pypi-packages huggingface dataset:
django-custom-email-user 0.1
Modify Django default User to use email as unique identifier

# Django Custom Email User

Replacing the username with the email as the unique identifier is so common, that I simply decided to create a package to prevent this tedium again.

Used to replace default Django User model with email, instead of the username, as the unique identifer. The username is changed to optional and will not be requested as part of createsuperuser.

The Django admin panel is customised to accommodate these changes, along with the User forms custom_email_user.forms.CustomUserCreationForm and custom_email_user.forms.CustomUserChangeForm

Simply:
* add custom_email_user to your installed apps
* subclass the abstracted class 
* configure the AUTH_USER_MODEL
* run the migrations
* register your user model with the admin site

```python
INSTALLED_APPS = [
    ...
    'custom_email_user'
]

AUTH_USER_MODEL = 'my_model_module.User'
```

```python
from django.db import models
from custom_email_user.models import User as BaseUser


class User(BaseUser):
    pass
```

```python
from django.contrib import admin
from custom_email_user.admin import CustomUserAdmin

from .models import User

admin.site.register(User, CustomUserAdmin)
```
ToyData 1.0
Data Structures in Python.

## ToyData: Learning Data Structures with toy code

![](https://github.com/shenxiangzhuang/ToyData/raw/master/toydata.png)


There are some simple implementations(in Python3.7.6) of classic data structrues.

I am trying to do this with an easy-to-read style.

And, I add some extra functions beyond the ADTs, which are used mostly for printing and testing purposes.


### Books

[*Data Structures and Algorithms in Python, Michael T. Goodrich*](https://www.amazon.com/Structures-Algorithms-Python-Michael-Goodrich/dp/1118290275/ref=sr_1_4?qid=1580122939&refinements=p_27%3AMichael+T.+Goodrich&s=books&sr=1-4&text=Michael+T.+Goodrich) 
is the **main reference** of the implementations.

Note that there is a book named [*Data Structures and Algorithms in C++, Michael T. Goodrich*](https://www.amazon.com/Data-Structures-Algorithms-Michael-Goodrich/dp/0470383275/ref=sr_1_2?qid=1580122957&refinements=p_27%3AMichael+T.+Goodrich&s=books&sr=1-2&text=Michael+T.+Goodrich) which use C++ to implement these data structures.

And [*Data Structures Using C, Reema Thareja*](https://www.amazon.in/Data-Structures-Using-Reema-Thareja/dp/0198099304/ref=sr_1_1?qid=1580122713&refinements=p_27%3AReema+Thareja&s=books&sr=1-1) is also a great book that implement these data structures using C.



### Documentation
[ToyData](http://datahonor.com/ToyData/)


### API

- [x] Stack: ArrayStack, LinkedStack
- [x] Queue: ArrayQueue, ArrayDeque
- [x] Deque: LinkedDeque
- [x] Positional List: PositionalList
- [x] Prority Queues: UnsortedPriorityQueue, SortedPriorityQueue, HeapPriorityQueue
- [x] LinkedLists: Singlellist, Doublellist
- [x] Hash Tables: ChainHashMap, ProbeHashMap, SortedTableMap
- [x] Trees: LinkedBinaryTree
- [x] Search Trees: AVLTreeMap, SplayTreeMap, RedBlackTreeMap
- [x] Graph: Adjacency Map, DFS/BFS, Floyd-Warshall 



### Courses
There some courses that use the book(*Data Structures and Algorithms in Python*) as textbook.(Tell me please, if you know other courses use it:-)

1. [数据结构与算法-Python (2019秋季)，武汉大学](http://xpzhang.me/)
    >Great lecture notes.


### References:

1. [Jenny's lectures CS/IT NET&JRF](https://www.youtube.com/channel/UCM-yUTYGmrNvKOCcAl21g3w/playlists)
    >Jenny makes everything clear！
orbita 0.3.1
Library used to control the Orbita actuator

# Orbita python module

![Actuator description](orbita.png)

To control this actuator, a vector must be used to represent the orientation of the platform.
An angle must also be identified to know the rotation of the platform on its own Z axis.

The orbita library allows the user to chose the orientation of the platform by typing a vector and an angle
and to get the angles of the disks needed to do this rotation of the platform.

It also allows the user to use a quaternion (which can be provided by another system) to represent the rotation of the platform
and get the angles of the disks.

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install the orbita library.
```bash
pip install orbita
```

## Usage

```python
from orbita import *
a = Actuator([0,0,85],[0,0,65],35) #Creates the actuator object
a.get_new_frame_from_vector(vector,angle) #returns new X,Y,Z vectors coordinates
a.get_angles_from_vector(vector,angle) #returns q11,q12 and q13 angles values
a.get_new_frame_from_quaternion(quaternion) #returns new X,Y,Z vectors coordinates
a.get_angles_from_quaternion(quaternion) #returns q11,q12 and q13 angles values
```
The last method needs the last angular position of the disks and an offset of 360°.
These values need to be reset everytime the user reset the position of the disks.
```python
a.reset_last_angles()
a.reset_offset()
```
vox-cards 0.1.8
A dependancy free deck, card, and hand manager.
Requires Python: >=3.6

# Vox Cards
This is an easy to use dependancy free deck manager, making it easy to develope the logic of
card games without worrying about creating ways to handle the decks, cards, and hands.

### Installation
Install using pip:
`py -m pip install vox_cards`

### Basic Usage
```Python
import vox_cards.deck as cards

deck = cards.Deck(2) # Pass the number of hands to construct this deck with.

deck.deal() # The default number of cards to deal is 7

player_1, player_2 = deck.hands

for card in player_1: # Print all cards in the first hand.
    print(card.full) # Prints the full name of the card (i.e. "10 of Clubs").
```
Keep in mind that hands are iterable, but only return the cards they hold.
With that in mind, there is also the ability for hands to draw and discard cards.
```Python
# This will draw the top 2 cards for each palyer, then discard 2 cards at random.
player_1.draw(2)
player_1.discard(2)

player_2.draw(2)
player_2.discard(2)


# You can also pass a card instance to hand.discard for discarding specific card(s).
player_1.discard(player_1.cards[0])
player_2.discard(player_2.cards[0])
```

##### More complex use case
Here is a more complex use case that features the main components of this module. It doesn't use any logic, but hopefully it gives you an idea of some use cases for this project.
```Python
import vox_cards.deck as cards

deck = cards.Deck(3)

for _ in range(3):
    deck.shuffle()

player_1, player_2, river = deck.hands

for _ in range(2):
    player_1.draw()
    player_2.draw()

river.draw(3)
river.draw()
river.draw()

print("\nPlayer 1's hand:")
for card in player_1:
    print(card.full)

print("\nPlayer 2's hand:")
for card in player_2:
    print(card.full)

print("\n\nAnd the river is:")
for card in river:
    print(card.full)
```

Here is the output for the code above:
```Python
>>>py example.py
Player 1's hand:
Queen of Spades
Jack of Spades

Player 2's hand:
6 of Clubs
8 of Spades


And the river is:
6 of Hearts
8 of Clubs
5 of Hearts
4 of Hearts
9 of Spades
```

Looks like player 2 wins with a 2-pair, how fitting.

### Documentation


This entire project is still a WIP and has not been officially released yet.
Full documentation will come for this project whenever it has been released
in a stable state. Until then, refer to the usage examples and the github
repo for most use cases. 


For a full list of everything you can do, view the [docs](https://vox-cards.readthedocs.io/en/latest/)
PyLathe 0.1.0
A Python Wrapper for Lathe
Requires Python: >=3.6

# PyLathe
![Lathe Logo](http://lathe.ai/logo.png)\
Lathe.lisp is a port of the machine-learning module for Julia, Python, and R (Lathe) into common lisp.\
Install it!\
**Bash**
```bash
sudo pip3 install (coming soon)
```
**Python**
```python
from Lathe import stats
stats.mean([5,7,4,5,6,7,2])
```
[Julia Documentation (Python docs coming soon)](http://lathe.ai/doc.html)