semvec/pypi-packages huggingface dataset:
pymemapi 0.1.0rc0
Memrise API
Requires Python: >=3.6,<4.0

# Memrise API

<p align="center"><img src="https://github.com/josephquang97/pymemapi/actions/workflows/test.yml/badge.svg"><a href="https://codecov.io/github/josephquang97/memrise/commit/8abed823b295beb7ecda8b564df2b81905fb81ad"><img src = "https://codecov.io/gh/josephquang97/pymemapi/branch/main/graphs/badge.svg?branch=main"></a></p>

## Installation

```
python -m pip install PyMemAPI
```

## Major Features

- API Memrise with some actions such as create new level, add bulk, rename level, ...
- Automaticially generate the audio and upload to Memrise
- Automaticially translate, get the International Phonetics Alphabet from database and sync with Memrise

## Documentations

The library have 3 main classes `Memrise`, `Course` and `SQLite`.

### Memrise

Memrise object will control your connection to Memrise. It's required your username and password to take permissions. And then it'll grant the necessary permission for the further process.

```python
class Memrise:
    username: str = field(init=False)
    password: str = field(init=False)
    session: requests.Session = requests.Session()
	
	def login(self, username, password) -> bool: ...
	def courses(self) -> List[Course]: ...
	def get(self, path: str, params: Optional[Dict[str, Any]] = None): ...
	def post(
        self,
        path: str,
        payload: Dict[str, Any],
        headers: Dict[str, str],
        files: Optional[Dict[str, Tuple[str, bytes, str]]] = None,
    ) -> requests.Response: ...

    def select_course(self) -> Course: ...
```

### Course


### SQLite
txcolor 4.0
uma biblioteca para mudar cores de texto python
Requires Python: >=3.9

# TXcolor
txcolor é uma pequena biblioteca em python para facilitar a troca de cor em textos no terminal.
Para utilizar é bem simples, primeiro clone o repositório utilizando:
~~~git
git clone https://github.com/B0463/txcolor.git
~~~
apos isso execute o setup.py e pronto, a biblioteca esta instalada!
___obs: ela é feita para windows, mesmo com modo linux não é certo que funcione corretamente.___
Para utilizar use o comando:
~~~python
from txcolor import *
txcolor("init")
~~~
a sintaxe é bem simples mostrada no código abaixo:
~~~python
from txcolor import *
txinit()

txcolor("texto exemplo", "red" "green")
~~~
dessa forma ela devolve o texto colorido com texto vermelho e fundo verde.
Tem uma pequena tabela de cores:

cor      | sintaxe     | código
---------|-------------|--------
preto    | black       | 0;30
vermelho | red         | 0;31
verde    | green       | 0;32
amarelo  | yellow      | 0;33
azul     | blue        | 0;34
roxo     | purple      | 0;35
ciano    | cyan        | 0;36
branco   | white       | 0;37
---------|-------------|------
preto    | gray        | 1;30
vermelho | lightRed    | 1;31
verde    | lightGreen  | 1;32
amarelo  | lightYellow | 1;33
azul     | lightBlue   | 1;34
roxo     | lightPurple | 1;35
ciano    | lightCyan   | 1;36
branco   | lightWhite  | 1;37

utilizando:
~~~python
# txcolor(texto, cor_da_letra, cor_do_fundo)
#
# exemplo:

txcolor("exemplo", "lightRed")

# assim ele devolve "\033[1;31mexemplo\033[0m"

txcolor("exemplo", "lightCyan", "red")

#assim ele devolve "\033[41;1;32mexemplo\033[0m"
~~~
no caso da cor da letra da pra usar toda a tabela de cores mas na cor de fundo não tem os "lightColors"
na mesma linha da pra imprimir texto com varias cores
~~~python
primeiroTexto=txcolor("[OK]", "lightGreen")
segundoTexto=txcolor("[FAIL]", "lightRed")
print("o {0} é o codigo para ok e o {1} é o de erro".format(primeiroTexto, segundoTexto))
~~~
assim apenas o [OK] fica verde e o [FAIL] fica vermelho.

Atenção: cuidado no uso de caracteres especiais!!!
Atenção: para ela funcionar ao iniciar "txinit()" limpa a tela
stplanpy 0.3.0
The Sustainable Transportation Planner for Python is a library focused on active transportation and transit. It was inspired by the stplanr library for R

# Welcome to stplanpy

Welcom to the Sustainable Transportation Planner for Python. This package is
inspired by [stplanr](https://docs.ropensci.org/stplanr/), a package for
sustainable transport planning with R [1] and can be used to analyze American
community survey (ACS) origin-destination (OD) data. This
[data](https://ctpp.transportation.org/2012-2016-5-year-ctpp/) is provided by
the American Association of State Highway and Transportation Officials (AASHTO)
through their Census Transportation Planning Products Program (CTPP).

Documentation for this package can be found on
[github.io](https://pctbayarea.github.io/stplanpy/source/stplanpy.html) and an
example of how to use the various functions in this package can be found in a
[Jupyter Notebook](https://pctbayarea.github.io/stplanpy-book/).

This library is also hosted on [PyPi](https://pypi.org/project/stplanpy/) and
can be installed using pip:

`pip install stplanpy`

An online interactive version of this code for the San Francisco Bay Area can be
found on [heroku](https://pctbayarea.herokuapp.com/). 

## References

[1] Robin Lovelace, Anna Goodman, Rachel Aldred, et al., "The Propensity
    to Cycle Tool: An open source online system for sustainable transport
    planning", Journal of transport and land use, vol 10, no 1, pp 505-528,
    2017, url: [https://www.jstor.org/stable/26211742](https://www.jstor.org/stable/26211742)
candl 0.0.7
A tiny, pedagogical neural network library with a pytorch-like API.
Requires Python: >=3.6

# candl

<p align="center">
    <img src="https://upload.wikimedia.org/wikipedia/commons/e/eb/Candle_flame_by_Shan_Sheehan.jpg" />
</p>

A tiny, pedagogical implementation of a neural network library with a pytorch-like API. The primary use of this library is for education. Use the [actual pytorch](https://github.com/pytorch/pytorch) for more serious deep learning business. 

The implementation is complete with tensor-valued autodiff (~100 lines) and a neural network API built off of it (~80 lines).

### Learning

This little project is actually the result of [an article I wrote](https://hackmd.io/@sripkunda/understanding-neural-networks). Using it, you can learn more about how neural networks work and implement everything in candl yourself from scratch.

### Installation 

```shell
pip install candl
```

### Usage

First, import candl.

```python
import candl
```

Candl comes with two modules: `nn` and `Tensor`. The `nn` module contains tools like modules, layers, SGD, MSE, etc. Candl tensors are extensions of numpy ndarrays that can be used to represent data and compute derivatives. 

To train a neural net (let's try to learn XOR), first we can create a model. 

```python
nn = candl.nn

model = nn.Sequential(nn.Linear(2, 64), 
                      nn.ReLU(), 
                      nn.Linear(64, 32), 
                      nn.ReLU(), 
                      nn.Linear(32, 1))
lr = 1e-3

loss_fn = nn.MSE()
optimizer = nn.SGD(model.parameters(), lr)
```

Then, we train: 

```python

data = [([0, 0], [0]), ([0, 1], [1]), ([1, 0], [1]), ([1, 1], [0])]

for epoch in range(100):
    for sample in data:
        """ 
        Note that we only allow batches of data, so the shape of the tensor must be n x m,
        where m is the dimensionality of the input for each batch.
        """
        x = candl.tensor([sample[0]]) 
        y = candl.tensor([sample[1]])
        loss = loss_fn(model.forward(x), y)
        loss.backward()
        # The `True` argument automatically zeroes the gradients after a step
        optimizer.step(True) 
```

### Features

- Tensors built upon numpy's ndarrays
- Tensor-valued autograd
- Mean Squared Error Loss Function 
- Stochastic Gradient Descent (SGD) 
- Blocks (Modules) for putting together neural networks 
- Built-in layers: Linear, ReLU, Sigmoid, Tanh