DEV Community: Samuel Lubliner

SageMath Installation

Samuel Lubliner — Thu, 15 Aug 2024 18:47:25 +0000

SageMath is a free open-source mathematics software system that builds on many existing open-source packages, including NumPy, SciPy, matplotlib, Sympy, Maxima, GAP, FLINT, R, and more. Unlike proprietary software like Magma, Maple, Mathematica, and MATLAB, Sage is free to use and allows you to view and modify the source code. If you're familiar with Python, you'll feel right at home with Sage as it extends Python with a robust set of mathematical tools.

The easiest way to get started with Sage is by running code in a browser-based workbook on a platform called CoCalc. CoCalc's free tier offers several benefits, including collaboration, automatic dependency management, and the convenience of executing Sage code without installing the software locally. However, after using CoCalc for a while, I found myself wanting a faster setup, free from the limitations of a cloud environment. This led me to install Sage locally on my machine.

If you're running Windows, installing Sage requires a few extra steps.

Download Windows Subsystem for Linux. Make sure you are using WSL2.
Reading Set up a WSL development environment is also helpful.

You can find instructions for local installation in the Sage Installation Guide.

There are several ways to install Sage, each with its advantages. Installing Sage from source offers the most flexibility, but it's a lengthy process that may present some challenges. Installing the necessary dependencies can take a considerable amount of time, and the make command — used to build Sage — will also require some patience, depending on your computer's resources.

For those seeking a simpler and quicker installation process, using conda-forge is an excellent alternative. Conda-forge is a community-driven collection of packages for conda, making it easy to install and manage Sage without dealing with the complexities of a source build. Here's how to get started with installing sage on WSL Ubuntu:

curl -L -O "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
bash Miniforge3-$(uname)-$(uname -m).sh
conda create -n sage sage python=3.11

After installing Sage via conda, you'll see a message similar to the following. Pay attention to the instructions provided, as they guide you on how to activate and manage your new Sage environment:

Transaction finished

To activate this environment, use:

    micromamba activate /home/samuel-lubliner/miniforge3

Or to execute a single command in this environment, use:

    micromamba run -p /home/samuel-lubliner/miniforge3 mycommand

installation finished.
Do you wish to update your shell profile to automatically initialize conda?
This will activate conda on startup and change the command prompt when activated.
If you'd prefer that conda's base environment not be activated on startup,
   run the following command when conda is activated:

conda config --set auto_activate_base false

You can undo this by running `conda init --reverse $SHELL`? [yes|no]
[no] >>> no

This prompt asks whether you want conda to automatically initialize every time your shell starts. I prefer to keep my environment clean, so I chose no. This choice keeps the base environment inactive on startup, which helps prevent cluttering the command prompt with unnecessary environment activations. If you prefer this setup, type no when prompted.

You have chosen to not have conda modify your shell scripts at all.
To activate conda's base environment in your current shell session:

eval "$(/home/samuel-lubliner/miniforge3/bin/conda shell.YOUR_SHELL_NAME hook)"

To install conda's shell functions for easier access, first activate, then:

conda init

Thank you for installing Miniforge3!

Manually activating your environment ensures that you maintain control over when and how your conda environments are loaded. This approach is beneficial if you use multiple environments.

Since I opted not to have conda modify my shell scripts, I run Sage manually using the following commands. This method ensures a clean environment and gives me control over when to activate Sage:

samuel_lubliner@DESKTOP-QGSGOAI:~$ eval "$(/home/samuel_lubliner/miniforge3/bin/conda shell.bash hook)"
(base) samuel_lubliner@DESKTOP-QGSGOAI:~$ conda activate sage
(sage) samuel_lubliner@DESKTOP-QGSGOAI:~$ sage -n jupyter

The first command initializes conda in your current shell.
The second command activates the sage environment.
The third command starts Sage with the Jupyter notebook interface.

Notice that (base) indicates the conda base environment is activated, and (sage) shows that the sage environment is active. Running these commands each time can become repetitive, so let's automate this process by creating a bash script. We can create the file sage_nb.sh. If you are using WSL, the docs recommend:

#!/bin/bash
# Switch to desired windows directory
cd /mnt/c/path/to/desired/starting/directory
# Start the Jupyter notebook
SAGE_ROOT/sage --notebook
# Alternatively you can run JupyterLab - delete the line above, and uncomment the line below
#SAGE_ROOT/sage --notebook jupyterlab

In my case, I installed JupyterLab because I prefer its more modern interface. Here is my script:

#!/bin/bash
# Start JupyterLab
/home/samuel_lubliner/miniforge3/envs/sage/bin/sage --notebook jupyterlab

To run the script, you first need to make it executable:

chmod ug+x ~/sage_nb.sh

Now you can run the script whenever you want to start Sage:

cd ~
./sage_nb.sh

If everything is set up correctly, running the script will start the Jupyter server in your terminal. From here, you can begin working with Sage in your browser.

If you prefer a more user-friendly approach, you can take this bash script a step further by creating a clickable shortcut on your desktop. This allows you to start Sage and JupyterLab with a double-click. You can find detailed instructions on how to create this shortcut in the SageMath docs.

Starting a new Django project with PostgresSQL and Docker

Samuel Lubliner — Wed, 03 Jul 2024 15:36:37 +0000

Initial project setup:

$ mkdir client-management
$ cd client-management
$ python3 -m venv .venv
$ source .venv/bin/activate
(.venv) $
(.venv) $ python3 -m pip install django~=5.0
(.venv) $ django-admin startproject django_project .
(.venv) $ python manage.py runserver

Visit http://127.0.0.1:8000/ to confirm the successful install and then quit the server.

(.venv) $ touch requirements.txt
(.venv) $ pip freeze > requirements.txt

Docker

Use Docker to streamline local development with PostgreSQL

Read more about security before deployment
https://docs.docker.com/engine/security/rootless/

After installing Django , deactivate the virtual environment and set up Docker. Create a Dockerfile, docker-compose.yml, and .dockerignore files.

(.venv) $ deactivate
$
$ touch Dockerfile docker-compose.yml .dockerignore
$ docker-compose up

About Docker

Docker Image: a read-only template with instructions for creating a container
Supported Python images: https://hub.docker.com/_/python/
Dockerfile: defines the custom image
Docker container: running instance of a Docker image.
docker-compose.yml: additional instructions for the container

Docker flow:

create a new virtual environment and install Django
create a new Django project within it
add Dockerfile with custom image instructions
add .dockerignore
build the image
add docker-compose.yml
Spin up containers with docker-compose up
Stop the container:
- Press Control + c
- Run docker-compose down

Detached mode

runs containers in the background. Use it for a single command line tab. Run docker-compose up -d
Error output won’t always be visible in detached mode. See the current output by running docker-compose logs

Docker vs local commands

Preface traditional commands with docker-compose exec [service]

For example:

$ docker-compose exec web python manage.py migrate
$ docker-compose exec web python manage.py createsuperuser

Psycopg

Psycopg is a database adapter. Start off with the binary version for quick installation. Update if the project needs performance boost. Learn more:

Install Psycopg

First stop running the Docker container by running docker-compose down. Docker replaces the virtual environment. The Docker host replaces the local operating system. Since I am using docker, I won’t install locally. Instead, I will just update requirements.txt with the psycopg[binary] package at the bottom of the file.

About `docker-compose.yml`

docker-compose.yml specifies two separate containers running within Docker.

web for the Django local server
db for the PostgreSQL database.

Docker containers are ephemeral. Information is lost when the container stops running. In docker-compose.yml, the postgres_data volumes mount binds to the local computer.

Configure PostgreSQL

Configure the environment to use trust authentication for the database. For a databases with many users, be more explicit with permissions.
Update the DATABASES config in django_project/settings.py file to use PostgreSQL
Now build the new image and start the two containers in detached mode by running docker-compose up -d --build.
Refresh the Django welcome page at http://127.0.0.1:8000/ to show Django has successfully connected to PostgreSQL via Docker. Remember to docker-compose down to save computer resources when you are finished.

Up next

Before migrating, I will add a custom user model.

Django: Generic List and Detail Views

Samuel Lubliner — Sat, 01 Jun 2024 17:44:04 +0000

From learn.firstdraft and MDN Django Generic Views

Overview

Use generic class-based list views for listing multiple records, and detail views for displaying individual records.
Extract information from URL patterns and pass it to the view.
These views reduce the amount of view code needed, streamlining the development process.
Implement pagination in list views to efficiently handle large datasets.
Apply these concepts to create pages to view our books and authors, passing data from URLs to the views.

Book List Page

Extend the base template base_generic.html.
Display a list of all available book records.
URL: catalog/books/.
Each book's title is a hyperlink to the associated book detail page.
Display the author for each book record.

URL Mapping

Set the path for books/ in /catalog/urls.py.

The path() function:

Defines a pattern to match the /catalog/books/ URL.
Calls the view function returned by views.BookListView.as_view() if the URL matches.
Provides a name for this particular URL mapping.

The view function:

Is implemented as a class, BookListView.
Inherits from Django's generic class-based views.
Is converted to a view function using the as_view() method.

View (class-based)

Instead of writing the book list view as a regular function-based view (similar to a Rails controller action):

Queries the database for all books.
Calls render() to pass the list to a specified template.

Using a class-based generic list view (ListView) is preferable:

Inherits from an existing view.
The generic view already implements most of the functionality.
Aligns with Django best practices for a more robust list view with less code, repetition, and maintenance.

In catalog/views.py, the generic view:

Queries the database.
Renders a template.

The template can access the list of books using a template variable. By default, generic views look for templates in the /application_name/templates/application_name/the_model_name_list.html path.

To modify the default behavior:

Specify a different template file if you need to use multiple views for the same model.
Use a different template variable name if needed.
Customize the queryset to filter or change the subset of results returned.

Overriding methods in class-based views

It is possible to override some of the class methods, offering more flexibility than just setting the queryset attribute.
For instance, override get_context_data() to pass additional context variables to the template.

Follow this pattern:

Get the existing context from the superclass.
Add new context information.
Return the new context.

See Built-in class-based generic views Django docs.

Creating the List View Template

The generic class-based list view for a Book model in a catalog application expects the template file to be located at /django-locallibrary-tutorial/catalog/templates/catalog/book_list.html. This template should extend the base template.

Conditional execution

Template tags check whether book_list has been defined and is not empty.

For more information about conditional operators, see: Django Docs.

For loops

The template uses template tags to loop and populate the book template variable.

Accessing variables

Access the fields using dot notation: book.field_name.

Call functions in the model from within template

Book.get_absolute_url() gets a URL to display the associated detail record.
Note: There is no way to pass arguments.
Warning: Be aware of side effects when calling functions in templates. Be sure not to accidentally do something destructive.

Update the Base Template

To enable the link on all pages, update /django-locallibrary-tutorial/catalog/templates/base_generic.html to use {% url 'books' %}. The URL mapping for the book detail pages is needed to create hyperlinks to individual books.

Book detail page

The book detail page displays information accessed using the URL catalog/book/<id>.

URL Mapping

In /catalog/urls.py, the 'book-detail' path function defines a URL pattern, associates it with a generic class-based detail view, and assigns it a name. The <int:pk> part captures the book ID, where pk stands for primary key, uniquely identifying the book in the database.

Passing additional options in your URL maps

You may pass a dictionary containing additional options to the view.

View (class-based)

In catalog/views.py:

class BookDetailView(generic.DetailView):
    model = Book

Create the template at /django-locallibrary-tutorial/catalog/templates/catalog/book_detail.html
The view will pass the Book record's information to the template.
Access the book's details in the template using the variable named object or book (the model's name).

If the record doesn't exist ...

Generic class-based detail view raises an exception
Http404
Resource not found
This behavior can be customized

Creating the Detail View Template

For a Book model in an catalog application, the generic class-based detail view expects the template file to be located at /django-locallibrary-tutorial/catalog/templates/catalog/book_detail.html.

To create this template:

The url template tag can reverse the 'author-detail' URL and pass it the author instance for the book. Using get_absolute_url() is preferred because any necessary changes need to be made only in the author model.

The template should:

Extend the base template
Override the content block.
Use conditional processing and for loops to iterate through lists of objects.
Access the context fields using dot notation.

Retrieve the set of BookInstance records associated with a particular Book, with the book.bookinstance_set.all() function.

Django constructs the function

by lower-casing the ForeignKey model
followed by _set
Use all() to get all records

You cannot use the filter() method directly in templates because you cannot specify arguments to functions.

If you don't define an order (on your class-based view or model), there will be errors:

[date-time] "GET /catalog/books/?page=1 HTTP/1.1" 200 1637
/foo/local_library/venv/lib/python3.5/site-packages/django/views/generic/list.py:99: UnorderedObjectListWarning: Pagination may yield inconsistent results with an unordered object_list: <QuerySet [<Author: Lubiner, Samuel>, <Author: Van Rossum, Guido>, <Author: Torvalds, Linus>]>
  allow_empty_first_page=allow_empty_first_page, **kwargs)

The paginator object expects an ORDER BY clause executed on your underlying database.

Pagination

Django has built-in support for pagination
Incorporated into the generic class-based list views

Templates

With paginated data, add support to the template to scroll through the results set. To paginate all list views, add this to the base template. The page_obj gets all the information about the current page, previous pages, page numbers, etc.

{{ request.path }} gets the current page URL for creating the pagination links, independent of the object that we're paginating.

Book List Page

Create the author detail and list views.

Author list: catalog/authors/
Detail view for the author with a primary key field: catalog/author/<id>

After creating the URL mapper for the author list page, update the "All authors" link in the base template.
After creating the URL mapper for the author detail page, update the book detail view template so the author link points to the new author detail page.
Call get_absolute_url() on the author model.

Django: Homepage

Samuel Lubliner — Thu, 30 May 2024 16:37:05 +0000

from: https://developer.mozilla.org/en-US/docs/Learn/Server-side/Django/Home_page

Data flow and handling HTTP requests and responses

URL mappers direct URLs and information to view functions
View functions retrieve data from models and render HTML
Templates: Define HTML for displaying data.

Creating the index page

catalog/

index page
includes counts of records in the database

URL mapping

locallibrary/urls.py

Processes URLs starting with catalog/
catalog.urls processes the substring

The import function django.urls.include() splits the URL string and sends the substring to the URLconf module.

/catalog/urls.py is a placeholder for the URLConf module

path()

Defines a URL pattern and associates it with a view function.
The name parameter is a unique identifier for URL mapping.
Use the name parameter to reverse the URL mapper and dynamically generate a URL that directs to a resource.
Reversed URL mapping is more robust than hard-coded links.
Use the name parameter to create links

View

A view function

Handles an HTTP request
Retrieves necessary data from the database
Generates an HTML page using a template to display the data

The first line in catalog/views.py imports render() to generate an HTML file.

The next line imports the model classes used to access data in views.

The view function 'index'

Fetches the number of records using objects.all() on the model classes.
Retrieves a collection of BookInstance objects where the status field is set to 'a' for available
Calls the render() function to create an HTML page a return the page as a response.

The context variable is a dictionary, containing the placeholder data.

Template

A template defines the structure a file, such as an HTML page
Use placeholders for content

In the index view from 'locallibrary/catalog/views.py', the render() function will expect to find /django-locallibrary-tutorial/catalog/templates/index.html or return an error.

Extending templates

Declare a base template and extend it to replace different parts for each specific page.

Template tags

loop through lists
conditional operations

Template syntax

Reference variables from the view
Use filters to format variables

When defining a template specify the base template using the extends template tag. Then declare sections from the template to be replaced.

Our base template is /django-locallibrary-tutorial/catalog/templates/base_generic.html

The base template references /django-locallibrary-tutorial/catalog/static/css/styles.css that provides additional styling.

The index template

/django-locallibrary-tutorial/catalog/templates/index.html starts by extending the base template and then customizes the default content block specific to the template's needs.

Template variables

Placeholders for the information from the view
Variables are enclosed with double brace handlebars

The names of the variables correspond to the keys provided in the context dictionary within the view's render() function.

Referencing static files in templates

https://docs.djangoproject.com/en/5.0/howto/static-files/

Static resources include JavaScript, CSS, and images. You can specify the location in your templates relative to the STATIC_URL global setting. The default value of STATIC_URL is set to '/static/'. You can change it and host resources on a content delivery network.

To reference static files in a template, initially load the static template tag to include the template library. After that, use the static tag to provide the relative path to the desired file.

Linking to URLs

The base template uses the url template tag.

This tag

Takes the name of a path() function called in urls.py
Accepts the values for arguments the associated view will receive
Returns a URL used to link to the resource

Configuring where to find the templates

https://docs.djangoproject.com/en/5.0/topics/templates/

Django searches for templates specified in the TEMPLATES object in the settings

In settings.py 'APP_DIRS': True instructs Django to look for templates within a "templates" subdirectory inside each app of the project. You can also specify particular directories for Django to search by setting 'DIRS': [].

View my commits here:

https://github.com/Samuel-Lubliner/local-library-django-tutorial/commit/3727b04dd95abbdf4e6d974fb0da10e17b16176c

See:

Writing your first Django app, part 3: Views and Templates
URL dispatcher
View functions
Templates
Managing static files
Django shortcut functions

Django: Admin

Samuel Lubliner — Tue, 28 May 2024 20:26:53 +0000

From: https://developer.mozilla.org/en-US/docs/Learn/Server-side/Django/Admin_site

See my locallibrary/catalog/admin.py

https://github.com/Samuel-Lubliner/local-library-django-tutorial/blob/main/locallibrary/catalog/admin.py

Django admin application

Allows creating, viewing, updating, and deleting records using models.
Simplifies testing models and data during development.
Useful for managing data in production environments.
Recommended only for internal data management.
Dependencies needed: Django Admin Documentation.
Register models to add them to the admin interface.
Configure the admin area for better display.
Create a new "superuser."

Registering models

Register models in /django-locallibrary-tutorial/catalog/admin.py. This is the simplest way of registering models with the site.

Creating a superuser

A superuser account has full access to the site and all needed permissions using manage.py.

Log into the admin site with a user account that has Staff status enabled.
View and create records with permissions to manage all objects.

In the same directory as manage.py run:

python3 manage.py createsuperuser

Restart the development server to test the login:

python3 manage.py runserver

Logging in and using the site

Open the /admin URL and enter the superuser credentials. The GUI allows you to view models and edit field values.

Advanced configuration

List views and detail views provide greater customization

Find a reference of the admin site in the docs: https://docs.djangoproject.com/en/5.0/ref/contrib/admin/

Register a ModelAdmin class

Comment out the original registrations. Then Define a ModelAdmin class and register it with the model. See: https://docs.djangoproject.com/en/5.0/ref/contrib/admin/#modeladmin-objects

Configure list views

Use list_display to add additional fields to the view. See more at https://docs.djangoproject.com/en/5.0/ref/contrib/admin/#django.contrib.admin.ModelAdmin.list_display

Add list filters

To filter displayed items, list fields in the list_filter attribute.

Sectioning the detail view

To add sections, refer to: https://docs.djangoproject.com/en/5.0/ref/contrib/admin/#django.contrib.admin.ModelAdmin.fieldsets

Inline editing of associated records

For inline editing of associated records, refer to: https://docs.djangoproject.com/en/5.0/ref/contrib/admin/#django.contrib.admin.ModelAdmin.inlines

Declaring inlines

TabularInline (horizontal layout) https://docs.djangoproject.com/en/5.0/ref/contrib/admin/#django.contrib.admin.TabularInline
StackedInline (vertical layout, default) https://docs.djangoproject.com/en/5.0/ref/contrib/admin/#django.contrib.admin.StackedInline

Django: Sample data

Samuel Lubliner — Tue, 28 May 2024 00:28:10 +0000

Sample Data

Is helpful when developing
Sample data scripts expose issues with data models

Querying in the shell

cd locallibrary
python3 manage.py shell

The interactive Python environment can be used to create records and query the database.

Import all necessary modules and models for the session.

from catalog.models import Book
Book.objects.all()

Outputs:

<QuerySet []>`

An empty query set was returned.

Add a book:

book = Book(title="Python Tutorial")
book.save()
Book.objects.all()

Outputs:

<QuerySet [<Book: Python Tutorial>]>

A book was successfully created. Importing everything in the beginning of the shell is painful.

Exit the the shell with exit()

Querying with shell_plus

Navigate to the same directory as requirements.txt.

shell_plus doesn’t come with Django out-of-the-box.

$ pip install django-extensions

Add the new package to the list of installed packages.

Run pip freeze from the same directory as requirements.txt to update the file. Otherwise, you will create another requirements.txt.

pip freeze > requirements.txt

Go to settings.py and register the extension in INSTALLED_APPS.

Then, navigate to the locallibrary directory where manage.py is located and run:

python3 manage.py shell_plus

Now you can query without needing to import models manually.

Sample data script

Install the Faker library and add it to requirements.txt

pip install Faker
pip freeze > requirements.txt

See create_sample_data.py at https://github.com/Samuel-Lubliner/local-library-django-tutorial/blob/main/locallibrary/create_sample_data.py
Run the sample data script:

python3 create_sample_data.py

To start querying run python3 manage.py shell_plus

Django: Using models

Samuel Lubliner — Mon, 27 May 2024 03:53:10 +0000

From: MDN Web Docs

Models

Python objects
Define the data structure
Independent from the database schema
Facilitate communication between Django and the database via Object-Relational Mapper

Designing Models

Create separate models for every object. Models can also be used to represent selection-list options.

Consider the relationships between objects. Relationships include:

one to one (OneToOneField)
one to many (ForeignKey)
many to many (ManyToManyField)

Multiplicities define the maximum and minimum number of each model that may be present in the relationship.

Model definition

Models:

Defined in models.py
Extend django.db.models.Model class
Can include fields, methods and metadata

Fields

Fields in a model represent columns in a database table.
Each record (row) in the table contains values for these fields.
Field types are designated using specific classes that define the type of data stored.
Field types can also be used for HTML form validation.

Field Arguments

https://docs.djangoproject.com/en/5.0/ref/models/fields/#field-options
help_text
verbose_name
default
null
blank
unique
primary_key

COMMON FIELD TYPES

https://docs.djangoproject.com/en/5.0/ref/models/fields/#field-types
CharField
TextField
IntegerField
other fields for different types of numbers
DateField
EmailField
FileField
ImageField
AutoField
ForeignKey specifies one-to-many relationship to another database model
ManyToManyField

Metadata

https://docs.djangoproject.com/en/5.0/ref/models/options/
Declare model-level metadata with class Meta
Useful for controlling the ordering of records returned by queries
Other metadata options control the database used for the model and how the data is stored

Methods

`str()`

Python class method
Provides a readable string representation of the object
The string represents individual records

`get_absolute_url()`

Generates a URL to view individual records of the model

Model management

Use model classes to create, update, or delete records, and to run queries.

Creating and modifying records

Create a record by instantiating the model and using the model's constructor.
Then call save() to save the object to the database.
Access fields in the record using dot notation.
Search for records using the model's objects attribute

The full list of lookups:

https://docs.djangoproject.com/en/5.0/ref/models/querysets/#field-lookups

Making queries:

https://docs.djangoproject.com/en/5.0/topics/db/queries/

Constraints

https://docs.djangoproject.com/en/5.0/ref/models/constraints/

Defining the LocalLibrary Models

At the top of /django-locallibrary-tutorial/catalog/models.py, the boilerplate imports the models module, which provides the models.Model base class that our models inherit from.

Genre model

Stores information about the book genre
A single CharField field is used to describe the genre
Limited to 200 characters
Has some help_text
Set tounique=True
One record for each genre
a __str__() method returns the name of the genre
get_absolute_url() method used to access a detail record

Book model

Represents all the general information about an available book
CharField is used for the book's title and isbn.
unique as true ensures all books have a unique ISBN
title is not set to be unique, because it is possible for different books to have the same name.
TextField for longer summary
ManyToManyField a book can have multiple genres and a genre can have many books

In both field types:

The first unnamed parameter should specify the related model class
- either directly by the model class
- or as a string with the name of the related model
If the associated class is not yet defined, use the model's name as a string in this file
Setting null=True permits the database to store Null if no author is selected
Using on_delete=models.RESTRICT prevents the deletion of the book's author if it is referenced by any book

Warning:

The default behavior is on_delete=models.CASCADE
This means that if the author is deleted, the book would also be deleted
Use RESTRICT or PROTECT to avoid the author being deleted while it is referenced by any book
Alternatively, use SET_NULL to set the book's author to Null if the author record is deleted
The __str__() method represents a Book record by its title field
The get_absolute_url() method provides a URL to access a detailed record

BookInstance model

Represents a specific copy of a book
Includes information about whether the copy is available
The date expected back
version details
unique id for the book in the library
ForeignKey identifies the associated Book
- each book can have many copies
- a copy can only have one Book
on_delete=models.RESTRICT ensures the Book cannot be deleted while referenced by a BookInstance
CharField represents the specific release
UUIDField for the id field to set it as the primary_key
This allocates a globally unique value for each instance
DateField for the due_back date
status CharField defines a choice/selection list
str() uses a combination of its unique id and title

Re-run the database migrations

After models have now been created, re-run database migrations to add them to the database.

python3 manage.py makemigrations
python3 manage.py migrate

Django: Creating a skeleton website

Samuel Lubliner — Thu, 23 May 2024 17:47:22 +0000

From: MDN Web Docs

Creating the library project

Open the terminal in a virtual or development environment
Navigate to the project folder
Run:

django-admin startproject locallibrary

cd locallibrary`

django-admin generates:

a project folder
the file templates
manage.py
a locallibrary sub-folder with the same name as the project folder. This is the entry point for the website.

The sub-folder entry point contains:

__init__.py: Indicates the directory is a Python package

settings.py: Website settings

urls.py: URL-to-view mappings

wsgi.py: Web Server Gateway Interface for synchronous apps

asgi.py: Asynchronous Server Gateway Interface

manage.py: Project management script that creates one or more applications.

Applications:

Separate, reusable components of a website
Register the new applications
url/path mapper for each application

Creating the catalog application

Run this command from the same folder as manage.py:

python3 manage.py startapp catalog

This creates the following folder structure:

catalog/
        admin.py
        apps.py
        models.py
        tests.py
        views.py
        __init__.py
        migrations/

The migrations folder updates the database when models are modified.

Note for codespace development:

Add * wildcard to ALLOWED_HOSTS in settings.py. This allows the host to run the live preview.

Register the catalog application

Add applications to INSTALLED_APPS in the project settings.

Specifying the database

SQLite is the default database. It is suitable if you don't a lot of concurrent access. Postgres requires additional setup and is more suitable for larger sites.

Other settings

TIME_ZONE can be configured.

SECRET_KEY can be changed to read from an environment variable in production.

DEBUG logs errors in a file instead of HTTP status code responses. Set to False in production.

Hook up the URL mapper

While urls.py can handle all the URL mappings, it's more common to route these mappings to the corresponding application.

The URL mappings are managed through the urlpatterns variable, which is a list of path() functions.

path() forwards requests to the module with the relative URL.

RedirectView redirects the root URL of the site.

Django does not serve static files by default. Serving CSS, JavaScript, and images can be useful for the development web server. Do not do this in production.

In the catalog folder, create urls.py and define the imported urlpatterns. Add patterns here as the application grows.

Before doing this, first run a database migration to update the database.

Running database migrations

Django uses an Object-Relational-Mapper. Django tracks the changes to model definitions and can create database migration scripts.

In the directory that contains manage.py, run

python3 manage.py makemigrations
python3 manage.py migrate

makemigrations creates the migrations.

migrate applies the migrations to the database.

Running the website

python3 manage.py runserver

Runs the development web server.

An error page is expected if there are no pages/urls defined in the the root of the site.

Django (Python) Introduction

Samuel Lubliner — Sun, 19 May 2024 16:51:54 +0000

From: https://developer.mozilla.org/en-US/docs/Learn/Server-side/Django/Introduction

About Django

Python
High-level web framework
Rapid development
Secure
Maintainable
Scalable
Free and open source
Batteries included
Somewhat opinionated

Model View Template

Django uses the Model View Template (MVT) architecture, similar to the Model View Controller architecture.

URL mapper

User requests go to urls.py, which maps the request to a view.

View

The request handler function in views.py processes the request and may interact with models.
Django views are similar to controllers and actions in Rails.

Models

Python objects that model data
Provides an API to interact with the database

Templates

Define the structure of any type of file
Placeholders populated with data from a model
Renders HTML and other file types
The rendered template is sent back as the response to the user.

Docker

Samuel Lubliner — Wed, 15 May 2024 05:41:56 +0000

Why Docker?

When collaborating on a repository shared by multiple people, Docker enables the team to share a consistent development environment. This ensures that everything runs the same and predictably across all machines. Additionally, Docker can help save resources on CodeSpaces and allows for offline development. VS Code Dev Containers offer a local alternative to GitHub CodeSpaces, providing a seamless development experience.

I recently acquired a Lenovo laptop with Windows. The hardware is an upgrade from my 2013 MacBook Pro, although my MacBook is more portable. With Docker and Windows Subsystem for Linux (WSL), I can work on the same code reliably across different machines, enjoying a Linux environment on Windows.

It's crucial to create your repositories within WSL rather than on the Windows file system. This improves performance and resolves some bugs. For instance, I discovered that live reloading became possible after storing files in WSL.
You know you're in Windows if the terminal looks like:

PS C:\Users\user-name>

Open the terminal and run:

wsl --distribution Ubuntu

Next, your terminal may look something like:

name@DESKTOP:/mnt/c/Users/name$

Be careful, you are still in the Windows file system. Run cd to get back to the home directory. You should see:

name@DESKTOP:~$

Now you can clone repositories and open them in a Dev Container from within the WSL file system for increased performance. The performance is improved because WSL offers better integration with Docker.
Alternatively, you can configure the WSL configuration file to open directly to the Linux home directory.

What is a Container?

Docker containers allow you to run code in a defined, isolated environment. This ensures consistency and reliability, as the environment remains the same regardless of where the container is run.

Up Next

Next time, we'll cover running a container. We'll create an image using a Dockerfile and a sample application.

Useful resources

You can download docker here:

https://www.docker.com/

Download the VS Code extensions:

https://code.visualstudio.com/docs/devcontainers/containers

Developing inside a Container:

https://code.visualstudio.com/docs/devcontainers/containers

Try out with different development environments:

https://github.com/search?q=org%3Amicrosoft+vscode-remote-try-&type=Repositories

https://github.com/Microsoft/vscode-remote-try-node

Fetching Data (Next.js)

Samuel Lubliner — Tue, 30 Apr 2024 18:36:28 +0000

You can view my commits on GitHub

Ways to fetch data

API
ORMs
SQL

API

An API layer can be used to

Interact with a 3rd party services that provide an API.
Fetching data from the client.
- API layer that runs on the server.
- avoid exposing database secrets to the client.

In Next.js, create API endpoints using Route Handlers.

Database queries

Logic to interact with a relational databases like Postgres with with SQL, or an ORM like Prisma.
Write database queries when creating API endpoints and logic to interact with your database.

Using Server Components to fetch data

Next.js uses React Server Components by default.
React server components fetch data on the server

Benefits to fetching data with Server Components:

Server Components support promises, providing a simpler solution for asynchronous tasks.
- Use async/await syntax without useEffect, useState or data fetching libraries.
Server Components execute on the server.
- You can keep expensive data fetches and logic on the server and only send the result to the client.
- If using React server components you can skip the API layer, and query your database directly without exposing database secrets to the client.

Using SQL

For this dashboard project, I'll write database queries using the Vercel Postgres SDK and SQL.

Reasons to use SQL:

SQL is the industry standard for querying relational databases.
ORMs generate SQL under the hood.
The Vercel Postgres SDK provides protection against SQL injections.

In /app/lib/data.ts, query the database by importing the sql function from @vercel/postgressql

Fetching data for the dashboard overview page

In /app/dashboard/page.tsx, Page is an async component. This allows you to use await to fetch data. There are 3 components which receive data: <Card>, <RevenueChart>, and <LatestInvoices>. We fetch data by importing functions from data.ts and calling them inside the components.

Fetching with JS vs SQL

Fetching and sorting the invoices using JavaScript can be inefficient. Instead of sorting through the latest invoices in-memory, you can use an SQL query to fetch only the last 5 invoices.

Prerendering

By default, Next.js utilizes Static Rendering to enhance performance. However, prerendering does not automatically update to reflect real-time changes in data.

Request waterfall

Network requests depending on the completion of previous requests.
This can result in blocking data requests.
Useful to satisfy a condition before making the next request.
If the waterfall is unintentional, it can negatively impact performance.

Parallel data fetching

Initiate all data requests at the same time to avoid waterfalls.
The Promise.all() and Promise.allSettled() initiate all promises at the same time.
Executing all data fetches at the same time can lead to performance gains.
Disadvantage: if one data request is slower than all the others.

Setting Up Your Database (Next.js)

Samuel Lubliner — Thu, 04 Apr 2024 19:07:48 +0000

Here, I am setting up a PostgreSQL database using @vercel/postgres.

Vercel

In Vercel, select and import a GitHub repository. Name your project and click Deploy. Connecting your GitHub repository will automatically redeploy your application, whenever you push changes to your main branch.

Create a Postgres database

Click Continue to Dashboard and select the Storage tab from your project dashboard. Select Connect → Store → Create New → Postgres → Continue.

Assign a name to your database and set the region. Place your database in a nearby region to reduce latency for data requests. Learn more about latency here.

Tip: You cannot change the database region once it has been initialized. To use a different region, set it before creating a database.

Once connected, navigate to the .env.local tab, click Show secret and Copy Snippet. Paste the contents into your code editor.

Database Secrets

Important: Don't expose database secrets when you push to GitHub. In .gitignore, make sure .env is in the ignored files. Finally, run npm i @vercel/postgres to install the Vercel Postgres SDK

Seed the database

Seeding the database allows you to have some data to work with as you build the dashboard.

/scripts/seed.js uses SQL to create the tables. The data from placeholder-data.js file populates them.

In package.json


"scripts": {
  "build": "next build",
  "dev": "next dev",
  "start": "next start",
  "seed": "node -r dotenv/config ./scripts/seed.js"
},

This is the command that will execute seed.js.

Troubleshooting:

Make sure to reveal your database secrets before copying it into your .env file.
The script uses bcrypt to hash the user's password, if bcrypt isn't compatible with your environment, you can update the script to use bcryptjs instead.

If you want to run the script again, you can drop any existing tables by running DROP TABLE tablename in your database query interface.

Warning

Be careful, this command will delete the tables and all their data. Do not run this command in a production app.

Exploring your database

In Vercel click Data on the sidenav. By selecting each table, you can view its records and ensure the entries align with the data from placeholder-data.js file.

Executing queries

Switch to the query tab to interact with your database. This section supports SQL commands.

DEV Community: Samuel Lubliner

SageMath Installation

Starting a new Django project with PostgresSQL and Docker

Initial project setup:

Docker

About Docker

Docker flow:

Detached mode

Docker vs local commands

Psycopg

Install Psycopg

About docker-compose.yml

Configure PostgreSQL

Up next

Django: Generic List and Detail Views

Overview

Book List Page

URL Mapping

View (class-based)

Overriding methods in class-based views

Creating the List View Template

Conditional execution

For loops

Accessing variables

Call functions in the model from within template

Update the Base Template

Book detail page

URL Mapping

Passing additional options in your URL maps

View (class-based)

If the record doesn't exist ...

Creating the Detail View Template

Pagination

Templates

Book List Page

See also

Django: Homepage

Data flow and handling HTTP requests and responses

Creating the index page

URL mapping

View

Template

Extending templates

The index template

Referencing static files in templates

Linking to URLs

Configuring where to find the templates

View my commits here:

Django: Admin

Django admin application

Registering models

Creating a superuser

Logging in and using the site

Advanced configuration

Register a ModelAdmin class

Configure list views

Add list filters

Sectioning the detail view

Inline editing of associated records

Django: Sample data

Sample Data

Querying in the shell

Querying with shell_plus

Sample data script

Django: Using models

Models

Designing Models

Model definition

Fields

Field Arguments

COMMON FIELD TYPES

Metadata

Methods

__str__()

get_absolute_url()

Model management

Creating and modifying records

The full list of lookups:

Making queries:

Constraints

About `docker-compose.yml`

`str()`

`get_absolute_url()`