Fixup | A Re-implementation of Fixed-update Initialization | Machine Learning library

Every commit has two date-and-time stamps. One is called the author date and one is called the committer date.

When you make a new commit in the usual way, using git commit and no trickery, both are set to the same value. Git retrieves the current time from your computer clock, and if that's accurate, the new commit's two date-stamps are "now".

When you make a commit using git cherry-pick or something that internally uses the cherry-pick machinery (such as git rebase), Git normally preserves the original author of the commit, and the original author-date. You become the committer, and "now" is the committer date.

To see both time stamps with git log, use any of the formatting options that prints both. The simplest to use is git log --pretty=fuller.

The --since and --until (or --after and --before) options to git log use the committer date only. (I think there should be a way to specify author dates, but there isn't.)

It seems you think that git commit --fixup changes an existing commit. It doesn't. git commit --fixup and git commit --squash are parts of history rewriting but they're only part of the solution.

git commit --fixup doesn't change the commit you point it to. It creates a new commit at the head of the current branch with the subject constructed from the given commit with the word fixup! prepended. The commit is a usual commit that contains the current changes so use git add or git commit -a --fixup to add and commit changes.

After that run git rebase --interactive --autosquash — this is the main command that does fixup/squash. The command reorders the commits and presents you with the list of commits to fixup/squash. Verify the list and exit your editor. git rebase will run fixing up or squashing commits.

See how everything can be combined in one clever alias: https://blog.filippo.io/git-fixup-amending-an-older-commit/

EDIT: added another movement example (look at cyan square)

To answer your comment about how to get "somewhere" in a fixed amount of time, you can linearize most functions and then solve the equation by fixing the time. This is easy for linear movement but rather difficult for complex cases, like moving along non-linear functions (e.G. a logarithmic spiral).

For a linear movement at constant speed (no acceleration/deceleration) from (x0, y0) to (x1, y1) in time dt you can use linear interpolation:

It seems that there is no remote branch called 'Francesco' anymore.

If the branch doesn't exist in your repository, you can create it again (with the commits of your local branch) with the command:

.start is not a property, you need to call it like a function, t = Thread(target=).start() to stop a thread, the proper way is with flags

Quoting the doc :

--autosquash
--no-autosquash

When the commit log message begins with "squash! …​" (or "fixup! …​"), and there is already a commit in the todo list that matches the same ..., automatically modify the todo list of rebase -i so that the commit marked for squashing comes right after the commit to be modified, and change the action of the moved commit from pick to squash (or fixup).

[emphasis mine : ]
A commit matches the ... if the commit subject matches, or if the ... refers to the commit’s hash.

As a fall-back, partial matches of the commit subject work, too. The recommended way to create fixup/squash commits is by using the --fixup/--squash options of git-commit[1].

note that "commit subject" means "the first line of the commit message" -- not "the complete commit mesage".

Is that possible without having to manually do a commit, run rebase --interactive, move the commit up, mark it as a fixup of the previous commit...

Yes, rebase will do this for you. See its --autosquash option.

1. Mark your commits with git commit --fixup= pointing to the commit you want to fix up. (Message-search syntax can be very handy: --fixup=@^{/somewordfromitssubject}.)
2. Create as many fixup commits as you want.
3. git rebase -i --autosquash theoldestfixedupcommit^.

Okay, I solved it. It turned out to be more simple than I thought (as it often is). I should have just listened to the error message and been aware of the place it was coming from.

What happened was that I had made some changes in my requirements file, but instead of rebuilding the containers using docker-compose up --build, I rebuilt using docker build .. So I guess the celery container was not properly updated with the required packages.

So the error was due to my lack of understanding of docker vs docker-compose, essentially.

I solved this problem

I added it to settings.py instead of celery.py. dotenv.read_dotenv ('./. env')

Hope this helps those who face the same problem