DEV Community: Kentaro0919

install guile to mac

Kentaro0919 — Thu, 26 Dec 2024 23:53:14 +0000

I like to use mise for my tools.
But I was not able to install guile.

First trouble:
I had gpg error like last post. I was able to sorbe this with

gpg --receive-keys 645357D2883A0966

Second trouble:
Guile was not running.
After

mise use  guile@3.0.10

guile was installed but when I run

guile --version

Return with an error.

guile was not running. It was the same for guile@3.0.9

guile --version
dyld[3069]: Library not loaded: /usr/local/opt/bdw-gc/lib/libgc.1.dylib
  Referenced from: <3F095348-0DF5-3FA1-8D70-CD619E3FAB13> /Users/kentarom/.local/share/mise/installs/guile/3.0.9/bin/guile
  Reason: tried: '/usr/local/opt/bdw-gc/lib/libgc.1.dylib' (no such file), '/System/Volumes/Preboot/Cryptexes/OS/usr/local/opt/bdw-gc/lib/libgc.1.dylib' (no such file), '/usr/local/opt/bdw-gc/lib/libgc.1.dylib' (no such file)

I installed with homebrew

brew install guile

and followed the instruction

The formula built, but is not symlinked into /usr/local
Could not symlink bin/guild
Target /usr/local/bin/guild
already exists. You may want to remove it:
  rm '/usr/local/bin/guild'

To force the link and overwrite all conflicting files:
  brew link --overwrite guile

To list all files that would be deleted:
  brew link --overwrite guile --dry-run

guile --version
guile (GNU Guile) 3.0.10
Copyright (C) 2024 Free Software Foundation, Inc.

License LGPLv3+: GNU LGPL 3 or later <http://gnu.org/licenses/lgpl.html>.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

emacs error Failed to verify signature archive-contents.sig

Kentaro0919 — Thu, 12 Dec 2024 02:02:25 +0000

First time to install emacs.
when I try to run M-x package-refresh-contents

I had the following message.

Failed to verify signature archive-contents.sig:
No public key for 645357D2883A0966 created at 2024-12-12T07:05:06+0900 using EDDSA
Command output:
gpg: Signature made Thu Dec 12 07:05:06 2024 JST
gpg:                using EDDSA key 0327BE68D64D9A1A66859F15645357D2883A0966
gpg: Can't check signature: No public key

after some searching I try this and solved

gpg --homedir ~/.emacs.d/elpa/gnupg --receive-keys 645357D2883A0966

moving from (yabai + skhd) to AeroSpace

Kentaro0919 — Thu, 31 Oct 2024 01:34:02 +0000

Some key-binding was not working in my skhd config, so I decided to give it a try to AeroSpace.
After I installed it some key-binding I used to have with skhd was not responding. I could not find any information in the document, I did PRAM clear, and every key-binding star worked.

PyCharm with asdf

Kentaro0919 — Tue, 18 Aug 2020 00:22:33 +0000

As PyCharm does not support asdf pointing /Users/{username}/.asdf/shims/python
was not working.

I was able to make it work by running

$ asdf which python

fish tips

Kentaro0919 — Thu, 09 Jul 2020 04:07:31 +0000

After install nvm on Mac with brew adding


  export NVM_DIR="$HOME/.nvm"
  [ -s "/usr/local/opt/nvm/nvm.sh" ] && . "/usr/local/opt/nvm/nvm.sh"  # This loads nvm
  [ -s "/usr/local/opt/nvm/etc/bash_completion.d/nvm" ] && . "/usr/local/opt/nvm/etc/bash_completion.d/nvm"  # This loads nvm bash_completion

to dot file does not work.

In 2020-07-09 I did

 curl https://git.io/fisher --create-dirs -sLo ~/.config/fish/functions/fisher.fish

fisher add jorgebucaran/fish-nvm

and nvm works

nvm                                                                                                                     11:20:59
nvm: version or .nvmrc file missing
usage: nvm --help           Show this help
       nvm --version        Show the current version of nvm
       nvm ls [<regex>]     List available versions matching <regex>
       nvm use <version>    Download <version> and modify PATH to use it
       nvm                  Use version in .nvmrc (or stdin if not a tty)
examples:
       nvm use 12
       nvm use lts
       nvm use latest
       nvm use dubnium
       nvm ls '^1|9$'
       nvm ls 10
       nvm <file

How to deploy a Masonite app to Heroku

Kentaro0919 — Wed, 27 Mar 2019 06:20:13 +0000

1. Add a Procfile

add a Procfile to the top of the Masonite project.

my Procfile is

web: gunicorn wsgi  --log-file -

add and commit

2. make a new app in Heroku

$ heroku create

3. add git remote

$ heroku git:remote -a {app-name}

4. Push on line

$ git push heroku master

For more information see this

Orator has many through

Kentaro0919 — Tue, 19 Mar 2019 02:19:09 +0000

Relationship has-many-through

The orator has many functions around relationships. In the current

One To One
One To Many
Many To Many
Has Many Through <- I am writing about this
Polymorphic relations
Many To Many polymorphic relations

Models are like this.

#app.Country
"""Countrie Model"""

from config.database import Model
from orator.orm import has_many_through, has_many


class Country(Model):
    """Countrie Model"""

    __table__ = "countries"
    __fillable__ = ['name']
    from app.User import User

    @has_many("country_id", "id")
    def users(self):
        from app.User import User
        return User

    @has_many_through(User, 'country_id', 'user_id')
    def posts(self):
        from app.Post import Post
        return Post

# app.User

"""User Model."""

from config.database import Model
from orator.orm import belongs_to_many, has_many

class User(Model):
    """User Model."""

    __fillable__ = ['name', 'email', 'password', 'country_id']

    __auth__ = 'email'

    @has_many
    def posts(self):
        from app.Post import Post
        return Post

# app.Post
"""Post Model"""

from config.database import Model
from orator.orm import belongs_to


class Post(Model):
    """Post Model"""
    __fillable__ = ['user_id', 'title']

    @belongs_to
    def user(self):
        from app.User import User
        return User

The controller is very simple, just all()

""" A testController Module """
from app.Country import Country
from masonite.view import View

class testController:

    def index(self, view: View):
        """Show several resource listings
        ex. Model.all()
            Get().route("/index", testController
        """

        countrys = Country.all()
        return view.render("index", {"countrys": countrys})

Now it is possible to user and post in the view.

<ul>
    {% for country in countrys %}
        <li>{{ country.id }} {{ country.name }}
            <ul>
            This comes from Country.users has_many
                {% for user in country.users %}
                    <li>{{ user.name }}
                        <ul>
                            {% for post in user.posts %}
                            <li>{{ post.title }}</li>
                                {% endfor %}
                        </ul>
                    </li>
                {% endfor %}
            </ul>
            <ul>
            This comes from Country.posts has_many_through User
                {% for post in country.posts %}

                    <li>{{ post.title }} {{ post.user.name }}</li>
                {% endfor %}
            </ul>
        </li>
    {% endfor %}
</ul>

Heroku tips

Kentaro0919 — Mon, 18 Mar 2019 07:00:22 +0000

Tips I found using Heroku with Masonite

To display the versions of application release.

$ heroku releases -a {appname}

To rollback to a version.

$ heroku rollback v53 -a {appname}

Follow Django Polls Tutorial with Masonite part 2-1/2

Kentaro0919 — Fri, 01 Mar 2019 05:14:03 +0000

Github

Database setup

Database Migrations in Masonite is very nice.
You do not have to keep your information in your config files. You store the information in ".env" file and Masonite will handle. Masonite supports MySQL, Postgres, and SQLite.

#.env

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=masonite
DB_USERNAME=root
DB_PASSWORD=root
DB_LOG=True

To follow the Django tutorial we use SQLite.

#.env

DB_CONNECTION=sqlite
DB_DATABASE=masonite.db
DB_LOG=True

Creating models

In Django.

#polls/models.py
from django.db import models


class Question(models.Model):
    question_text = models.CharField(max_length=200)
    pub_date = models.DateTimeField('date published')


class Choice(models.Model):
    question = models.ForeignKey(Question, on_delete=models.CASCADE)
    choice_text = models.CharField(max_length=200)
    votes = models.IntegerField(default=0)

Question

In Masonite models and migrations are separated.
To create a new migration you can run.

$ craft model Question -m
Model Created Successfully!
Created migration: 2019_03_20_130251_create_questions_table.py

This will create a Model named Question and call orator make:migration

app
└─── Question.py

databases/migrations
├── 2018_01_09_043202_create_users_table.py # This exist at craft install
├── 2019_03_20_130251_create_questions_table.py
└── __init__.py

#/databases/migrations/2019_03_20_130251_create_questions_table.py
from orator.migrations import Migration


class CreateQuestionsTable(Migration):

    def up(self):
        """
        Run the migrations.
        """
        with self.schema.create('questions') as table:
            table.increments('id')
            table.timestamps()

    def down(self):
        """
        Revert the migrations.
        """
        self.schema.drop('questions')

Edit this to

from orator.migrations import Migration


class CreateQuestionsTable(Migration):

    def up(self):
        """
        Run the migrations.
        """
        with self.schema.create('questions') as table:
            table.increments('id')

            table.char('question_text', 200)
            table.datetime('pub_date')

            table.timestamps()

    def down(self):
        """
        Revert the migrations.
        """
        self.schema.drop('questions')

and the model from

# app/Question.py

"""Question Model"""

from config.database import Model


class Question(Model):
    """Question Model"""
    pass

"""Question Model"""

from config.database import Model


class Question(Model):
    """Question Model"""

    __fillable__ = ['question_text', 'pub_date']

    __dates__ = ['pub_date']

Choice

and for choices.

$ craft model Choice  -m
Model Created Successfully!
Created migration: 2019_03_20_131816_create_choices_table.py

app
├── Choice.py
└─── Question.py

databases/migrations
├── 2018_01_09_043202_create_users_table.py
├── 2019_03_20_130251_create_questions_table.py
├── 2019_03_20_131816_create_choices_table.py
└── __init__.py

# /databases/migrations/2019_03_20_131816_create_choices_table.py
from orator.migrations import Migration


class CreateChoicesTable(Migration):

    def up(self):
        """
        Run the migrations.
        """
        with self.schema.create('choices') as table:
            table.increments('id')
            table.timestamps()

    def down(self):
        """
        Revert the migrations.
        """
        self.schema.drop('choices')

edit this to

# /databases/migrations/2019_03_20_131816_create_choices_table.py
from orator.migrations import Migration


class CreateChoicesTable(Migration):

    def up(self):
        """
        Run the migrations.
        """
        with self.schema.create('choices') as table:
            table.increments('id')

            table.char('choice_text', 200)
            table.integer('votes').default(0)

            table.integer('question_id').unsigned()
            table.foreign('question_id').references('id').on('questions').on_delete('cascade')

            table.timestamps()

    def down(self):
        """
        Revert the migrations.
        """
        self.schema.drop('choices')

#/app/Choice.py
"""Choice Model"""

from config.database import Model


class Choice(Model):
    """Choice Model"""
    pass

#/app/Choice.py
"""Choice Model"""

from config.database import Model


class Choice(Model):
    """Choice Model"""

    __fillable__ = ['choice_text', 'pub_date', 'question_id']

This command will make the change to the database.

$ craft migrate

#It took 1.94ms to execute the query ("SELECT * FROM sqlite_master WHERE type = #'table' AND name = ?", ['migrations'])
#It took 3.5ms to execute the query ('CREATE TABLE "migrations" ("migration" VARCHAR #NOT NULL, "batch" INTEGER NOT NULL)', None)
#It took 0.13ms to execute the query ('SELECT "migration" FROM "migrations"', [])
#It took 0.17ms to execute the query ('SELECT MAX("batch") AS aggregate FROM #"migrations"', [])
#It took 1.81ms to execute the query ('CREATE TABLE "users" ("id" INTEGER NOT NULL #PRIMARY KEY AUTOINCREMENT, "name" VARCHAR NOT NULL, "email" VARCHAR NOT NULL, #"password" VARCHAR NOT NULL, "remember_token" VARCHAR NULL, "verified_at" DATETIME #NULL, "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL, "updated_at" #DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL)', None)
#It took 1.71ms to execute the query ('CREATE UNIQUE INDEX users_email_unique ON #"users" ("email")', None)
#It took 1.33ms to execute the query ('INSERT INTO "migrations" ("migration", #"batch") VALUES (?, ?)', ['2018_01_09_043202_create_users_table', 1])
#It took 1.93ms to execute the query ('CREATE TABLE "questions" ("id" INTEGER NOT #NULL PRIMARY KEY AUTOINCREMENT, "question_text" VARCHAR NOT NULL, "pub_date" #DATETIME NOT NULL, "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL, #"updated_at" DATETIME DEFAULT CURRENT_TIMESTAMP NOT NULL)', None)
#It took 1.49ms to execute the query ('INSERT INTO "migrations" ("migration", #"batch") VALUES (?, ?)', ['2019_03_20_130251_create_questions_table', 1])
#It took 1.77ms to execute the query ('CREATE TABLE "choices" ("id" INTEGER NOT NULL #PRIMARY KEY AUTOINCREMENT, "choice_text" VARCHAR NOT NULL, "votes" INTEGER NOT NULL #DEFAULT \'0\', "question_id" INTEGER NOT NULL, "created_at" DATETIME DEFAULT #CURRENT_TIMESTAMP NOT NULL, "updated_at" DATETIME DEFAULT CURRENT_TIMESTAMP NOT #NULL, FOREIGN KEY("question_id") REFERENCES "questions"("id") ON DELETE cascade)', #None)
#It took 1.47ms to execute the query ('INSERT INTO "migrations" ("migration", #"batch") VALUES (?, ?)', ['2019_03_20_131816_create_choices_table', 1])
#Migration table created successfully
#[OK] Migrated 2018_01_09_043202_create_users_table
#[OK] Migrated 2019_03_20_130251_create_questions_table
#[OK] Migrated 2019_03_20_131816_create_choices_table

craft can generate a model docstring based on a table definition

$ craft model:docstring questions

"""Model Definition (generated with love by Masonite)

id: integer default: None
question_text: string(255) default: None
pub_date: datetime default: None
created_at: datetime default: CURRENT_TIMESTAMP
updated_at: datetime default: CURRENT_TIMESTAMP
"""

$ craft model:docstring choices

"""Model Definition (generated with love by Masonite)

id: integer default: None
choice_text: string(255) default: None
votes: integer default: 0
question_id: integer default: None
created_at: datetime default: CURRENT_TIMESTAMP
updated_at: datetime default: CURRENT_TIMESTAMP
"""

Playing with the API

In Dango.

$ python manage.py shell

>>> from polls.models import Choice, Question  # Import the model classes we just wrote.

# No questions are in the system yet.
>>> Question.objects.all()
<QuerySet []>

# Create a new Question.
# Support for time zones is enabled in the default settings file, so
# Django expects a datetime with tzinfo for pub_date. Use timezone.now()
# instead of datetime.datetime.now() and it will do the right thing.
>>> from django.utils import timezone
>>> q = Question(question_text="What's new?", pub_date=timezone.now())

# Save the object into the database. You have to call save() explicitly.
>>> q.save()

# Now it has an ID.
>>> q.id
1

# Access model field values via Python attributes.
>>> q.question_text
"What's new?"
>>> q.pub_date
datetime.datetime(2012, 2, 26, 13, 0, 0, 775217, tzinfo=<UTC>)

# Change values by changing the attributes, then calling save().
>>> q.question_text = "What's up?"
>>> q.save()

# objects.all() displays all the questions in the database.
>>> Question.objects.all()
<QuerySet [<Question: Question object (1)>]>

In Masonite, we can load our application with the craft tinker command.

$craft tinker
#Masonite Python 3.7.2 Console
#This interactive console has the following things imported:
#    container as 'app'

#Type `exit()` to exit.

>>> from app.Question import Question

>>> Question.all()
It took 1.37ms to execute the query ('SELECT * FROM "questions"', [])
#<orator.orm.collection.Collection object at 0x106967e80>

>>> import datetime

>>> q = Question.create(question_text="What's new?", pub_date=datetime.datetime.now())
#It took 350.62ms to execute the query ('INSERT INTO "questions" ("pub_date", #"question_text") VALUES (?, ?)', [datetime.datetime(2019, 3, 21, 6, 36, 20, #45979), "What's new?"])

>>> q.save()
#True
>>> q.id
#1

>>> q.pub_date
#datetime.datetime(2019, 3, 21, 6, 36, 20, 45979)

>>> q.question_text = "What's up?"
>>> q.save()
#It took 3.67ms to execute the query ('UPDATE "questions" SET "question_text" = ?, #"updated_at" = ? WHERE "id" = ?', ["What's up?", '2019-03-20 21:38:01.456334', 1])
#True

>>> Question.all()
#It took 0.15ms to execute the query ('SELECT * FROM "questions"', [])
#<orator.orm.collection.Collection object at 0x10c88c9e8>

In Dango.

#polls/models.py

from django.db import models

class Question(models.Model):
    # ...
    def __str__(self):
        return self.question_text

class Choice(models.Model):
    # ...
    def __str__(self):
        return self.choice_text

In Masonite

#
"""Question Model"""
import datetime

from config.database import Model


class Question(Model):
    """Question Model"""
    __fillable__ = ['question_text', 'pub_date']

    def __repr__(self):
        return self.question_text

"""Choice Model"""

from config.database import Model


class Choice(Model):
    """Choice Model"""
    __fillable__ = ['question_id', 'choice_text', 'votes']

    def __repr__(self):
        return self.choice_text

In Django

#
import datetime

from django.db import models
from django.utils import timezone


class Question(models.Model):
    # ...
    def was_published_recently(self):
        return self.pub_date >= timezone.now() - datetime.timedelta(days=1)

In Masonite

#
"""Question Model"""
import datetime

from config.database import Model


class Question(Model):
    """Question Model"""
    __fillable__ = ['question_text', 'pub_date']
    __dates__ = ['pub_date']

    def __repr__(self):
        return self.question_text

    def was_published_recently(self):
        return self.pub_date >= datetime.datetime.now() - datetime.timedelta(days=1)

In Dango.

>>> from polls.models import Choice, Question

# Make sure our __str__() addition worked.
>>> Question.objects.all()
<QuerySet [<Question: What's up?>]>

# Django provides a rich database lookup API that's entirely driven by
# keyword arguments.
>>> Question.objects.filter(id=1)
<QuerySet [<Question: What's up?>]>
>>> Question.objects.filter(question_text__startswith='What')
<QuerySet [<Question: What's up?>]>

# Get the question that was published this year.
>>> from django.utils import timezone
>>> current_year = timezone.now().year
>>> Question.objects.get(pub_date__year=current_year)
<Question: What's up?>

# Request an ID that doesn't exist, this will raise an exception.
>>> Question.objects.get(id=2)
Traceback (most recent call last):
    ...
DoesNotExist: Question matching query does not exist.

# Lookup by a primary key is the most common case, so Django provides a
# shortcut for primary-key exact lookups.
# The following is identical to Question.objects.get(id=1).
>>> Question.objects.get(pk=1)
<Question: What's up?>

# Make sure our custom method worked.
>>> q = Question.objects.get(pk=1)
>>> q.was_published_recently()
True

# Give the Question a couple of Choices. The create call constructs a new
# Choice object, does the INSERT statement, adds the choice to the set
# of available choices and returns the new Choice object. Django creates
# a set to hold the "other side" of a ForeignKey relation
# (e.g. a question's choice) which can be accessed via the API.
>>> q = Question.objects.get(pk=1)

# Display any choices from the related object set -- none so far.
>>> q.choice_set.all()
<QuerySet []>

# Create three choices.
>>> q.choice_set.create(choice_text='Not much', votes=0)
<Choice: Not much>
>>> q.choice_set.create(choice_text='The sky', votes=0)
#<Choice: The sky>

>>> c = q.choice_set.create(choice_text='Just hacking again', votes=0)

# Choice objects have API access to their related Question objects.
>>> c.question
#<Question: What's up?>

# And vice versa: Question objects get access to Choice objects.

>>> q.choice_set.all()
#<QuerySet [<Choice: Not much>, <Choice: The sky>, <Choice: Just hacking again>]>

>>> q.choice_set.count()
#3

# The API automatically follows relationships as far as you need.
# Use double underscores to separate relationships.
# This works as many levels deep as you want; there's no limit.
# Find all Choices for any question whose pub_date is in this year
# (reusing the 'current_year' variable we created above).

>>> Choice.objects.filter(question__pub_date__year=current_year)
#<QuerySet [<Choice: Not much>, <Choice: The sky>, <Choice: Just hacking again>]>

# Let's delete one of the choices. Use delete() for that.

>>> c = q.choice_set.filter(choice_text__startswith='Just hacking')
>>> c.delete()

In Masonite

>>> from app.Question import Question
>>> from app.Choice import Choice

>>> Question.all()
#It took 0.14ms to execute the query ('SELECT * FROM "questions"', [])
#<orator.orm.collection.Collection object at 0x10c990d30>

>>> Question.find(1) #Question.find(id=1) works the same
#It took 0.26ms to execute the query ('SELECT * FROM "questions" WHERE #"questions"."id" = ? LIMIT 1', [1])
#What's up?


Question.where_raw('question_text LIKE ?', ["What%"]).get()
#It took 2.68ms to execute the query ('SELECT * FROM "questions" WHERE question_text LIKE ?', ['What%'])
#<orator.orm.collection.Collection object at 0x10c9aa9e8>

>>> import datetime
>>> current_year = datetime.datetime.now().year



>>> Question.find(id=2).get()
#It took 0.09ms to execute the query ('SELECT * FROM "questions" WHERE #"questions"."id" = ? LIMIT 1', [2])
#Traceback (most recent call last):
#  File "<console>", line 1, in <module>
#AttributeError: 'NoneType' object has no attribute 'get'

To handle the relationships
We have to edit our model like

"""Question Model"""
import datetime
from config.database import Model
from orator.orm import has_many


class Question(Model):
    """Question Model"""

    __fillable__ = ['question_text', 'pub_date']

    __dates__ = ['pub_date']

    def __repr__(self):
        return self.question_text

    def was_published_recently(self):
        return self.pub_date >= datetime.datetime.now() - datetime.timedelta(days=1)

    @has_many
    def choice(self):
        from app.Choice import Choice
        return Choice

Then we can handle the relationship.

>>> q = Question.find(id=1)
#It took 0.1ms to execute the query ('SELECT * FROM "questions" WHERE "questions"."id" = ? LIMIT 1', [1])

>>> q
#What's up?

>>> q.was_published_recently()
#True

>>> q.choice().get()
#It took 47.28ms to execute the query ('SELECT * FROM "choices" WHERE #"choices"."question_id" = ?', [1])
#<orator.orm.collection.Collection object at 0x10da62908>


>>> q.choice().create(choice_text='Not much', votes=0)
#It took 44.38ms to execute the query ('INSERT INTO "choices" ("choice_text", #"created_at", "question_id", "updated_at") VALUES (?, ?, ?, ?)', ['Not much', #'2019-03-20 22:16:52.997981', 1, '2019-03-20 22:16:52.997981'])
#Not much

>>> q.choice().create(choice_text='The sky', votes=0)
#It took 3.53ms to execute the query ('INSERT INTO "choices" ("choice_text", #"created_at", "question_id", "updated_at") VALUES (?, ?, ?, ?)', ['The sky', #'2019-03-20 22:17:11.626357', 1, '2019-03-20 22:17:11.626357'])
#The sky

>>> q.choice().create(choice_text='Just hacking again', votes=0)
#It took 295.54ms to execute the query ('INSERT INTO "choices" ("choice_text", #"created_at", "question_id", "updated_at") VALUES (?, ?, ?, ?)', ['Just #hacking again', '2019-03-20 22:17:47.761326', 1, '2019-03-20 #22:17:47.761326'])
#Just hacking again


>>> q.choice().count()
#It took 0.17ms to execute the query ('SELECT COUNT(*) AS aggregate FROM #"choices" WHERE "choices"."question_id" = ?', [1])
#3

>>> import datetime
>>> current_year = datetime.datetime.now().year

TODO

find some way to do

# The API automatically follows relationships as far as you need.
# Use double underscores to separate relationships.
# This works as many levels deep as you want; there's no limit.
# Find all Choices for any question whose pub_date is in this year
# (reusing the 'current_year' variable we created above).
>>> Choice.objects.filter(question__pub_date__year=current_year)
<QuerySet [<Choice: Not much>, <Choice: The sky>, <Choice: Just hacking again>]>

# Let's delete one of the choices. Use delete() for that.
>>> c = q.choice_set.filter(choice_text__startswith='Just hacking')
>>> c.delete()

Follow Django Polls Tutorial with Masonite part 1

Kentaro0919 — Thu, 28 Feb 2019 05:59:56 +0000

Writing your first Django Masonite app, part 1

Following tutorial01

Github

check your installation.

In Django, you run the following command to check your Django version.

$ python -m django --version

In Masonite, you run

$ craft -v

Creating a project

In Django.

$ django-admin startproject mysite

In Masonite

$ craft new mysite

The development server

In Django.

$ python manage.py runserver

In Masonite, We need to install before running the server.
Running the WSGI Server
Host and Port

$ craft install
# then now we can run the server.
$ craft serve

Creating the Polls app

Until this point, Django and Masonite were not so different, just running some commands against your code. From this point, the difference will be clear.
running

In Django.

$ python manage.py startapp polls

In Masonite, we do not need this.

Write your first view

In Django.

# polls/views.py
from django.http import HttpResponse


def index(request):
    return HttpResponse("Hello, world. You're at the polls index.")

In Masonite. The Controllers works like "view" in Django.
First We have to add new Controllers.

$ craft controller Polls

This command generates "app/http/controllers/PollsController.py"

""" A PollsController Module """


class PollsController:
    """PollsController
    """

    def show(self):
        pass

Let's edit this as follow

""" A PollsController Module """


class PollsController:
    """PollsController
    """

    def index(self):
        return "Hello, world. You're at the polls index."

In Django urls.py handle the request from the user.

# mysite/urls.py
from django.contrib import admin
from django.urls import include, path

urlpatterns = [
    path('polls/', include('polls.urls')),
    path('admin/', admin.site.urls),
]

#polls/urls.py
from django.urls import path

from  . import views

urlpatterns = [
    path('', views.index, name='index'),
]

In Masonite, the route handles the request. By default, you have routes
/web.py in your project.
Routing

"""Web Routes."""

from masonite.routes import Get, Post

ROUTES = [
    Get().route('/', 'WelcomeController@show').name('welcome'),
]

The request is "http://localhost:8000/polls/" so we have to handle /polls/
in our route. Masonite handle the HTTP Verbs and match with a controller.

"""Web Routes."""

from masonite.routes import Get, Post

ROUTES = [
    Get().route('/', 'WelcomeController@show').name('welcome'),
    Get().route('/polls/', 'PollsController@index'),
]

make sure you are running the server

$ craft serve -r

Then you can access your page.

We finished successfully the tutorial01 of Django tutorial with Masonite.

Working with PostgreSQL in Docker with Masonite

Kentaro0919 — Thu, 31 Jan 2019 08:20:01 +0000

The doc in docker
uses 9.3 but I wanted to try a newer one. So I Changed to

Dockerfile

FROM ubuntu

RUN apt update
RUN apt install -y postgresql postgresql-contrib gnupg2
RUN apt-key adv --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys B97B0AFCAA1A47F044F244A07FCC7D46ACCC4CF8

RUN echo "deb http://apt.postgresql.org/pub/repos/apt/ precise-pgdg main" > /etc/apt/sources.list.d/pgdg.list
RUN apt-get update && apt-get install -y software-properties-common postgresql postgresql-client postgresql-contrib

USER postgres
RUN    /etc/init.d/postgresql start &&\
    psql --command "CREATE USER docker WITH SUPERUSER PASSWORD 'docker';" &&\
    createdb -O docker docker

RUN echo "host all  all    0.0.0.0/0  md5" >> /etc/postgresql/10/main/pg_hba.conf

RUN echo "listen_addresses='*'" >> /etc/postgresql/10/main/postgresql.conf

EXPOSE 5432

VOLUME  ["/etc/postgresql", "/var/log/postgresql", "/var/lib/postgresql"]

CMD ["/usr/lib/postgresql/10/bin/postgres", "-D", "/var/lib/postgresql/10/main", "-c", "config_file=/etc/postgresql/10/main/postgresql.conf"]

build

$ docker build -t eg_postgresql .

run

$ docker run --rm -P --name pg_test eg_postgresql

running PostgreSQL as

$ docker ps
CONTAINER ID        IMAGE                  COMMAND                CREATED             STATUS              PORTS                                      NAMES
5e24362f27f6        eg_postgresql:latest   /usr/lib/postgresql/   About an hour ago   Up About an hour    0.0.0.0:49153->5432/tcp                    pg_test
$ psql -h localhost -p 49153 -d docker -U docker --password

change the env file in Masonite to

DB_CONNECTION=postgres #NOT PostgreSQL nor postgresql !
DB_HOST=127.0.0.1
DB_PORT=49153
DB_DATABASE=docker
DB_USERNAME=docker
DB_PASSWORD=docker
DB_LOG=True

Then Try the connection to the database.

$craft migrate


It took 4.88ms to execute the query SELECT * FROM information_schema.tables WHERE table_name = 'migrations'
It took 13.64ms to execute the query CREATE TABLE "migrations" ("migration" VARCHAR(255) NOT NULL, "batch" INTEGER NOT NULL)
It took 1.2ms to execute the query SELECT "migration" FROM "migrations"
It took 1.24ms to execute the query SELECT MAX("batch") AS aggregate FROM "migrations"
It took 16.29ms to execute the query CREATE TABLE "users" ("id" SERIAL PRIMARY KEY NOT NULL, "name" VARCHAR(255) NOT NULL, "email" VARCHAR(255) NOT NULL, "password" VARCHAR(255) NOT NULL, "remember_token" VARCHAR(255) NULL, "verified_at" TIMESTAMP(6) WITHOUT TIME ZONE NULL, "created_at" TIMESTAMP(6) WITHOUT TIME ZONE DEFAULT CURRENT_TIMESTAMP(6) NOT NULL, "updated_at" TIMESTAMP(6) WITHOUT TIME ZONE DEFAULT CURRENT_TIMESTAMP(6) NOT NULL)
It took 4.47ms to execute the query ALTER TABLE "users" ADD CONSTRAINT users_email_unique UNIQUE ("email")
It took 1.7ms to execute the query INSERT INTO "migrations" ("migration", "batch") VALUES ('2018_01_09_043202_create_users_table', 1)
Migration table created successfully
[OK] Migrated 2018_01_09_043202_create_users_table

Worked!!