semvec/pypi-packages huggingface dataset:
Dowell-Mail 1.0.2
Dowell Mail Package
Requires Python: >=3.8
Keywords: Dowell Django Mail

# Dowell Mail App

This is a Django mail package consuming the Dowell Mail API. It validates each email then sends email once validated.

## Quick Start

1. Add `maillib` to your INSTALLED_APPS in settings.py like this:

    INSTALLED_APPS = [
        ...
        'maillib',
    ]

.. caution::
    You need to add `import os` before editing TEMPLATES to include `os.path.join(BASE_DIR, 'templates')` in DIRS like:

    "DIRS": [
        os.path.join(BASE_DIR, 'templates')
    ]

3. Include maillib URLconf in the projects url.py like this:

    path('mail', include('maillib.urls')),

4. The package doesnt have any database so no migrations are necessary.

5. Start the server and navigate to `http://127.0.0.1:8000/mail` and start sending emails.

## Features

Dowell Mail offers a reliable and user-friendly API for sending and validating emails. Our API services provide a seamless experience for sending emails from your own email ID and validating email addresses for accuracy. Whether you need to send important notifications or verify email addresses, Dowell Mail API has got you covered.

To understand the API calls and their functionality, I recommend reading the documentation. The documentation provides comprehensive information on making API requests and utilizing the available endpoints. It explains the required parameters, request methods, and response formats for each API call.

[Documentation](https://dowellmail.onrender.com/)
SFM4300-readout 0.1.2
simple wrapper class to read flow data from the SFM4300-20 flow sensor
Requires Python: >=3.7

# SFM4300_readout
Simple wrapper class to read flow data from the SFM4300-20 flow sensor.

## Usage
```python 
from SFM4300_readout import SFM4300
sensor1 = SFM4300(1)
print(sensor1.get_flow())
```
to_dto_converters 0.1.0
Django ORM to DTO package, helps automatically transform

## Django ORM Model to DataClass object
Package that helps easy convert Django ORM models to DTO(Dataclass) object.


### Installation
```shell
pip install djangomodel-dataclass
```

### Quickstart

```shell
# models.py
from django.db import models

class Product(models.Model):
    name = models.CharField(max_length=128)
    description = models.TextField(max_length=1000)
    
class Photo(models.Model):
    product = models.ForeignKey(Product, related_name="photos",
                                on_delete=models.CASCADE)
    image = models.ImageField(blank=True)
```

```shell
# dto.py
@dataclass(frozen=True)
class PhotoDataclass:
    id: int
    image: str

@dataclass(frozen=True)
class ProductDataclass:
    id: int
    name: str
    description: str
    photos: List[ProductDataclass] = field(default_factory=list)
```

```shell
# repository.py
from to_dto_converters.dj_model_to_dataclass import FromOrmToDataclass

from dto import ProductDataclass
from models import Product

converter = FromOrmToDataclass()

def get_product(product_id: int) -> ProductDataclass:
    product = Product.objects \
                    .prefetch_related('photos') \
                    .get(pk=product_id)      
    retrun converter.to_dto(product, ProductDataclass)
```

### Recursive Django model relation

```shell
# models.py
from django.db import models

class Category(models.Model):
    name = models.CharField(max_length=128)
    parent = models.ForeignKey(
        "Category", related_name="sub_categories", null=True, blank=True, on_delete=models.CASCADE
    )
```

```shell
# dto.py
@dataclass
class CategoriesDTO:
    id: int
    name: str
    sub_categories: List['CategoriesDTO'] = field(default_factory=list)
```

```shell
# repository.py
from itertools import repeat
from to_dto_converters.dj_model_to_dataclass import FromOrmToDataclass

from models import Category
from dto import ProductDataclass

converter = FromOrmToDataclass()

def get_categories(self) -> Iterable[CategoriesDTO]:
    categories = Category.objects.filter(parent__isnull=True)
    return map(converter.to_dto, categories, repeat(CategoriesDTO), repeat(is_recursive=True))
```
solarkit 1.0.1
Visualise a solar system and do cool stuff with it
Keywords: solar system,space,astrophysics,bpho


# solarkit - BPhO Computational challenge

A tool to easily visualise and perform calculation on a solar system. The solutions for all challenges are embed but also provides the tools to tinker around and build new, original simulations.
It was built as the first part of a two part subimission for the challenge. My idea is to create a website using django to allow anyone to use the simulation. Having this package will ensure clean, backend code that will do the work in just a couple of lines.

* [Repo link](https://github.com/carlos-lorenzo/solarkit) (for PyPI)

### Challenges
* Kepler's Third Law
* Visualise a solar system
* Visualise the solar system, animated
* Spinograph
* Angle vs Time
* Heliocentric model

### Personal aditions
* Tools to create, save & load a custom solar system
* Save the model output to an image
* Spinograph, animated

### How to use
1. "pip install solarkit" or [download package files](https://github.com/carlos-lorenzo/solarkit/tree/main/Package) from repository and  install locally
2. [Download](https://github.com/carlos-lorenzo/solarkit/blob/08a2d0ddc34b3abecce7789cbe7163d7d49cbd48/planet_data.csv) or create your own data
3. Create .py file
4. Start experimenting! (follow example image for guidance)

### Use example (example file available in repository)
![solarkit_example](https://github.com/carlos-lorenzo/solarkit/assets/91377173/cdab5fb1-c55e-427f-a0d9-f156be7e535c)