Forem: Blikoor

The print function

Blikoor — Thu, 17 Mar 2022 16:15:43 +0000

A statement is an instruction that the Python interpreter can execute. A function is a block of code that perform a specific action, and typically contain several statements. There are two types of Functions in Python: Built-in functions — pre-defined functions like print(), and User-defined functions — functions created by programmers or developers.

The print function was an addition to Python 3 and replaced the print statement of Python 2. (PEP 3105). We can print values to the screen (stdout) by default or an open file. It is, for example, commonly used in debugging. The function can accept any number of positional arguments and defines four optional keyword arguments that already have default values.

Syntax

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

Parameter	Description
object(s)	Objects, will be converted to string before printed.
sep='separator'	Optional — specify how to separate the objects, if there is more than one. The default is ' '.
end='end'	Optional — specify what to print at the end. The default is '\n' character (newline).
file	Optional — an object with a write method. The default is sys.stdout.
flush	Optional — a Boolean, specifying if the output is flushed (True) or the default buffered (False).

Escape sequences

First, let's briefly discuss these special characters since they often appear in string literals with a preceding backslash \. They allow the representation of invisible control characters and sometimes the escaping of otherwise illegal characters.

Code	Description
`\'`	single quote
`\"`	double quote
`\\`	backslash
`\n`, `\r`, `\r\n`	newline or line feed (LF)
`\r`	carriage return (CR)
`\t`	tab
`\b`	backspace

Note that a newline can be a single control character or a sequence of control characters depending on the operating system (OS).

Windows & Dos represent an EOL as \r\n.
Unix, Linux and macOS represent an EOL as \n.
Mac OS X represent an EOL as \r.

Printing to terminal

1. You can print a blank line (\n), passing no arguments with empty parentheses.

print()

2. You can print literals. A literal is a notation for representing a value in source code. There are various value types (int, float, tuple, string, etc.).

print(17)
print(3.14159)
print((58, 128, 168))
print("Press \"Enter\" to continue.")

[run code]

3. You can print variables. A variable is a symbolic name that references or points to the computer memory location used to store a value.

pi = 3.14159
message = "Press 'Enter' to continue."
print(message)
print(pi)

[run code]

4. You can print expressions directly. An expression is combination of operators and operands that is interpreted to produce some other value.

print(19 + 23)
print("Python was first released " + str(31) + " years aggo.")

[run code]

5. You can print multiple literals, separating them with a comma (,).

series = "Monty Python's Flying Circus"
print("Python was named after the BBC comedy series:", series)
print(29, 31, 37)

[run code]

6. You can print values with another separator (see sep).

print('Hello', 'World!', sep="")
print("", "C", "Users", "Guido", "Documents", sep="/")
print("name", "email", "phone number", "address", sep="," )

[run code]

7. You can print literals without line breaks or trailing newline character (see end).

print("Proceed with Format (Y/N)? ", end="")
print("Y")

[run code]

String formatting

Since Python 3.6, you can format string literals with f-strings (PEP 498). Although this is now the recommended way to format string literals, it is not intended completely replace the str.format() and printf-style formatting mechanisms.

A formatted string literal or f-string is a string literal that is prefixed with f or F. These strings may contain replacement fields, which are expressions delimited by curly braces ({}). The format specification mini-language is the same as that used by the str.format() method.

Syntax

"{" [field_name] ["!" conversion] [":" format_spec] "}"

Arguments	Description
`field_name`	Specifies the object whose value is to be formatted and inserted.
`conversion`	Optional — type coercion, to force a type conversion (prefixed with `!`).
`format_spec`	Optional — specification of how the value should be presented (prefixed with `:`).

field_name

arg_name ("." attribute_name | "[" element_index "]")*

Arguments	Description
`arg_name`	[identifier digit+]
`attribute_name`	identifier
`element_index`	digit+ index_string

conversion

"r" | "s" | "a"

Arguments	Description
`r`	Calls repr() on the argument before `format_spec` implement __format()__.
`s`	Calls str() on the argument before `format_spec` implement __format()__.
`a`	Calls ascii() on the argument before `format_spec` implement __format()__.

format_spec

[[fill]align] [sign] [#] [0] [width] [grouping_option] [.precision] [type]

Arguments	Description
`fill`	<any character>
`align`	`<` `>` `=` `^`
`sign`	`+` `-` `" "`
`width`	digit+
`grouping_option`	`_` `,`
`precision`	digit+
`type`	`b` `c` `d` `e` `E` `f` `F` `g` `G` `n` `o` `s` `x` `X` `%`

8. You can print expressions in f-strings.

print(f"{43 * 47}")

[run code]

9. You can print variables in f-strings (see field name).

nation = ("Mayan")
logo = [2, (52, 121, 175), (255, 222, 77)]

print(f"The Python logo depicts {logo[0]} colored snakes based on ancient \
{nation} drawings.")

[run code]

10. You can call methods in f-strings (see field name).

group = "Monty Python"
print(f"Eric Idle is an actor of the comedy group {group.upper()}.")

[run code]

11. You can call functions in f-strings (see field name).

def to_upper(string):
    return string.upper()

group = "Monty Python"  
print(f"Eric Idle is an actor of the comedy group {to_upper(group)}.")

[run code]

12. You can print objects in f-strings (see field name). By default, it will print whatever the __str__ method returns, or you can use explicit conversion flags (see conversion).

class Color:
    def __init__(self, r = 255, g = 255, b = 255):
        self.r = r
        self.g = g
        self.b = b

    def __str__(self):
        return "This is a RGB color object."

    def __repr__(self):
        return f"Color({self.r}, {self.g}, {self.b})"

flat_blue = Color(r = 52, g = 121, b = 175)
light_gold = Color(r = 255, g = 222, b = 77)

print(f"{flat_blue}")
print(f"{flat_blue!s}")
print(f"{light_gold!r}")

[run code]

13. You can format the alignment and padding of values in f-strings (see align and fill).

prime_number = 997
language = "Python"

print(f"{prime_number}")
print(f"{97:>3}")
print(f"{prime_number:0>10}")
print(f"{language:^10}")
print(f"{language:-^10}")

[run code]

14. You can format the sign, grouping and rounding of numbers in f-strings (see sign, grouping_option, and precision).

number = 9576890767
amount = 25169.15683

print(f"{number:,}")
print(f"{amount:=+11,.2f}")
print(f"$ {amount:,.2f}")
print(f"R {amount:,.2f}".replace(',', ' '))

[run code]

15. You can format values as different types in f-strings (see type).

decimal_number = 29
binary_number = 0b11101
index = 0.2827
big_number = 176846309399143769411680

print(f"{decimal_number:5b}")
print(f"{decimal_number:5o}")
print(f"{decimal_number:5x}")
print(f"{decimal_number:5X}")
print(f"{binary_number:5d}")
print(f"{big_number:e}")
print(f"Python has a PYPL-index of {index:.2%}")

[run code]

Printing to a file

The print function doesn't just send text to the screen but more accurately converts objects to strings and writes them to a stream (file-like object). A stream can be any file on your drive, a network socket, or a location in memory (buffer). In addition to this, the operating system provides three standard streams:

Stream	File Handle	Desciption
stdin (standard input)	0	keyboard input
stdout (standard output)	1	screen output
stderr (standard error)	2	screen output

As mentioned earlier, the print function use stdout by default. However, using a redirection operator (>), we can instruct the operating system to use a file stream instead. The redirection operator can either redirect input to a shell command or output from a shell command. To redirect stderr, you need to use a file handle. File handles are constant numbers associated with the standard streams. These handles allow you to redirect one or more streams at a time.

Syntax	Descrption
`program > file`	Redirect stdout to a file.
`program 2> file`	Redirect stderr to a file.
`program > file 2> file`	Redirect stdout and stderr to separate files.
`program >> file`	Append stdout to a file.
`program < file`	Type a text file and pass the text to program.

For example, you might execute systeminfo.exe to save the information provided by the systeminfo command to a file.

PS systeminfo > system_info.txt

16. You can use stream redirection for various command-line programs including your own Python scripts.

# message.py
print("This message will be written to stdout")

PS python message.py > message.txt

17. You can use stream redirection in Python. This is done by first obtaining a reference to the standard output using the stdout file object of the sys module. Its a good practice to store the original value of the standard output in a variable before changing it. This way you can reset it back to its original value afterwards. The with statement creates a runtime context that allows you to run a group of statements under the control of a context manager. The open function tries to open a file in writing mode and if successful returns a file object also called a handle. The following modes are commonly used with the print function:

Mode	Description
`'r'`	Open for reading (default).
`'w'`	Open for writing, truncating the file first.
`'x'`	Open for exclusive creation, fails if the file already exists.
`'a'`	Open for writing, appending to the end of file if it exists.
`'+'`	Open for updating (reading and writing).

import sys


default_stdout = sys.stdout # save the original value of stdout

print("This message will be written to stdout.")

with open('message.txt', 'w') as file_object:
    sys.stdout = file_object # redirect stdout to the file
    print("This message will be written to file.")
    sys.stdout = default_stdout # reset stdout to its original value

print("This message will be written to stdout.")

18. You can print to a file directly without using stream redirection (see file).

import sys


print("This message will be written to stdout.")

with open('message.txt', 'w') as file_object:
    print("This message will be written to file.", file=file_object)

19. You can disable buffering of the standard output. The operating system buffers expensive I/O operations to enhance performance, but sometimes buffering can have undesired effects. There are three kinds of streams concerning buffering — unbuffered, line-buffered, and block-buffered. A line-buffered stream waits until there is a EOL in the buffer, whereas a block-buffered stream waits for the buffer to fill up. The standard output is both line-buffered and block-buffered, depending on which event comes first. (see flush)

from time import sleep


for number in reversed(range(10 + 1)):
    print(number, end=" ", flush=True)
    sleep(1)
print("Launch!")

20. To round off our look at the print function, here is a real-world example of a text-based progress bar that can be used for command line programs.

from time import sleep


width = 10

for progress in range (101):
    fill = width * progress // 100
    track = width - fill
    value = f"{progress / 100:.0%}"
    print("\r[", "#" * fill, " " * track, "]", value, sep="", end="", flush=True)
    sleep(0.1)

Learning Python

Blikoor — Wed, 16 Feb 2022 13:36:34 +0000

Python is a beginner-friendly programming language that prioritizes readability, this is why its syntax has many similarities with the English language. In fact, ease of use was one of Python’s founding principles when it was created by Guido van Rossum.

The joy of coding Python should be in seeing short, concise, readable classes that express a lot of action in a small amount of clear code. Not in reams of trivial code that bores the reader to death. — Guido van Rossum

You can start learning Python on your own for free. The best thing about learning Python, is that there is a plethora of documentation, websites, books, tutorials, and courses available. Start by following these steps:

Find out more about Python.
Learn the basics.
Practice as you learn.
Solve coding challenges.
Learn domain-specific concepts and libraries.

Software

Documentation

The latest Python 3.x documentation online.
Download the latest Python 3.x documentation.
The Beginner's Guide to Python.
Python community list of Python editors.
Python community list of Integrated Development Environments (IDEs).
The Hitchhiker's Guide to Python.
A curated list of Awesome Python frameworks, libraries, software and resources.

PEPs

[ PEP 8 ] Style Guide for Python Code
[ PEP 20 ] The Zen of Python
[ PEP 257 ] Docstring Conventions
[ PEP 287 ] reStructuredText Docstring Format
[ PEP 405 ] Python Virtual Environments
[ PEP 435 ] Adding an Enum type to the Python standard library
[ PEP 484 ] Type Hints
[ PEP 526 ] Syntax for variable Annotations
[ PEP 634 ] Structural Pattern Matching
[ PEP 3101 ] Advanced String Formatting
[ PEP 3107 ] Function Annotations
[ PEP 3129 ] Class Decorators

Podcasts

What is Python?

Blikoor — Wed, 16 Feb 2022 13:36:13 +0000

In a nutshell — Python is an interpreted, interactive, object-oriented, general-purpose programming language.

Design philosophy & Features

The Python language's core philosophy is summarized in PEP 20, titled "The Zen of Python".
Python is a multi-paradigm programming language where Object-oriented programming, procedural programming and functional programming are fully supported. Many of Python's features support aspect-oriented programming, including metaprogramming and metaobjects (also called magic methods). Many other paradigms like design by contract and logic programming are also supported via extensions.
Python's extensive standard library is commonly cited as one of its greatest strengths and provides tools suited to many tasks. Rather than having all of this functionality built into its core, Python was designed to be highly extensible with modules.
Python features dynamic name resolution during runtime.
Python is a strongly-typed language, meaning you can't perform operations inappropriate to the type of the object (e.g. adding numbers to strings). Python is also a dynamically-typed language, meaning a variable is simply a value bound to a name with no associated data type.
Python uses duck typing, a concept related to dynamic typing — Python don't check types, it checks for the presence of a given method or attribute.
Since Python 3.5, type annotations can be used for possible static analysis, refactoring, runtime type checking and code generation. An optional static type checker named mypy supports compile-time type checking.
Python allows you to assign a value to a variable without first declaring it, but it will not let you reference a variable that has never been assigned a value.
Python doesn't support tail call optimization and first-class continuations. However, Python has better support for coroutine-like functionality by extending Python's generator functions.
Python developers should strive to avoid premature optimization since it can reduce readability and add code that only exists to improve performance. This may complicate programs, making them harder to maintain and debug. When speed is important, you can move time-critical functions to extension modules written in languages such as C/C++. You can also use PyPy or Cython.

We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil. Yet we should not pass up our opportunities in that critical 3%. — Donald Knuth

Statements & Control flow

Python uses a carriage return to separate statements.
Code blocks are defined by their indentation. Python use whitespace indentation, there are no explicit braces, brackets, or keywords. This means that whitespace is significant, and must be consistent. Four spaces are the preferred indentation method, avoid using tabs.
Python uses if along with else and elif (a contraction of else-if) statements for conditional execution of a code block.
Since Python 3.10, the match and case statements can be used for pattern matching. The match statement is similar to the switch statement of other languages.
Python uses the for statement to iterate over an iterable object and the while statement to execute a code block as long as its condition is true.
Python uses the break statement to exit the loop containing it, after which the program flow continues immediately after the loop body.
The continue statement, skips this iteration and continues with the next statement.
A function or method can be defined with the def statement.
Python defines a class with the class statement.
A colon : is used to start a code block in the case of if, elif, while, for, def, and class statements. It is also used to fetch data and index ranges, slicing, and to identify keys in dictionaries.
All names in Python are case-sensitive: i.e. names of variables, functions, classes, modules, and exceptions.
The del statement is used to delete variables and objects from existence.
In Python, the pass statement serves as a NULL statement. The interpreter parses it to a NOP instruction, meaning no operation in machine language. It is syntactically needed to create an empty code block.
Python uses try... except code blocks to handle exceptions, and raise statements to generate them.
In Python, the assert statement can be used during debugging to check conditions that should always be true. If the condition is not satisfied, the program stop and gives an AssertionError along with an optional message.
The return statement is used to return a value from functions.
The yield statement returns a value from generator functions.
Python uses these =, +=, -=, *=, /=, %=, //=, **= assignment operators. In Python assignment is a statement and not an expression. Consequently, Python does not support in-line assignment.
Python features sequence unpacking which means to assign elements of an iterable object into multiple variables, it's written as as many variables as elements in sequence = sequence.
The import statement is used to import modules. Importing a python module, runs all of its contents. Use an if __name__ == "__main__": code block to allow or prevent parts of code from being run when modules are imported.

Built-in types

Python's native types are numbers, sequences, classes, instances and exceptions.

Type	Mutability	Description	Example
`bool`	immutable	boolean value	`True` or `False`
`int`	immutable	integer value	`2`
`float`	immutable	double-precision floating-point value	`3.14159`
`complex`	immutable	complex number with real and imaginary parts	`1+2j`
`str`	immutable	sequence of Unicode characters	`'Python'`
`bytes`	immutable	sequence of bytes	`b'Python'`
`bytearray`	mutable	sequence of bytes	`bytearray(b'Python')`
`list`	mutable	ordered sequence of values	`[3, True, 'Python']`
`tuple`	immutable	ordered sequence of values	`('Python', 5, False)`
`dict`	mutable	associative array of key and value pairs	`{'name': 'Adam', 7: 'apple'}`
`set`	mutable	unordered sequence of values with no duplicates	`{True, 11, 'Python'}`

The table list the most commonly used types, but there are more types.

Expressions

Python follows mathematical rules of precedence for mathematical operations: parentheses, exponentiation, multiplication & division, addition & subtraction, and operators with the same precedence are evaluated from left to right.
Python uses the +, -, *, %, ** arithmetic operators. There are two types of division in Python called floor division (or integer division) // and floating-point division /.
Python uses the ==, >, <, !=, >=,<= comparison operators. Comparisons may even be chained (e.g. a <= b <= c).
Since Python 3.8, the walrus operator := can be used to assign values to variables as part of an expression.
Python uses the words and, or, not for Boolean (or logic) operators instead of the symbolic equivalent &&, || and !.
Python uses the is and is not identity operators to check if two values refer to the same object or not.
Python uses the in and not in membership operators to test whether or not a sequence contains a value. The in keyword is also used to iterate through a sequence in a forloop.
Python makes a distinction between lists (mutable) written as [2, 3, 5] and tuples (immutable) written as (7, 11, 13).
In Python strings can be concatenated by adding them, using the arithmetic operator for addition.
Anonymous functions are implemented using lambda expressions that is written as lambda [parameters]: expression.
In Python, a List comprehension is written as [expression for item in list]. List comprehensions are a more elegant and concise way to create lists. It can also be used when working with strings or tuples.
A Python generator expression is written as (expression for item in list). These anonymous generator functions create a single element on request, and therefore more memory efficient than an equivalent list comprehension.
Conditional expressions are written as X if condition else Y. The condition is evaluated first. If condition is True, X is evaluated and its value is returned, and if condition is False, Y is evaluated and its value is returned.

Uses

Python can serve as a scripting language for automation.
Python is often used for web development and web applications.
Python competes against Fortran and C/C++ in scientific computing and data science.
Python is commonly used in data analysis, artificial intelligence and machine learning.
Python is often used in natural language processing.
Python can be used in game development.
Python is embedded in many software products as a scripting language.
Many operating systems include Python as a standard component.
Python is used extensively in information security and exploit development.

Introduction to Python

Blikoor — Wed, 16 Feb 2022 13:36:02 +0000

This Python series is for beginner programmers with some programming knowledge, but it is not required. Although not comprehensive, I hope that this series can quickly guide beginners past the initial syntax hurdle — so that they can spend more time writing code.

It is important to note that the aim isn't to replace books, courses, tutorials, and other resources but rather to supplement the initial learning experience.

— Part 5 in the series is coming soon —

Setting up a Python development environment

Blikoor — Wed, 02 Feb 2022 12:52:45 +0000

The coverimage showcase a tutorial by Clear Code (YouTube, GitHub).

When you're a new programmer, much time and effort go into learning that first programming language. Once you gain enough familiarity with the ins and outs, you can start to invest time into building a development environment that will boost your productivity. Here follow my opinionated attempt to systematize some of the best practices for setting up a new Python development environment.

Windows Terminal
- Execution policy
- New profiles
Pyenv
- Pyenv installation
- Pyenv maintenance
Poetry
- Poetry installation
- Poetry maintenance
Git & GitHUb
- Git installation
- Git maintenance
Repository
- Existing project
- New project
- Manage projects
- Fast track new repos
PyCharm
- Open projects
- Configure Python interpreter
- Default project directory
- Suggested Plugins
- Install plugins
- IDE integration
Known issues

Windows Terminal

Developers spend enough time in terminals and shell programs, to deserve a better terminal. Windows Terminal is a customizable multi-tabbed terminal application that can run any shell program or terminal emulator. The new command-line front-end can be installed from the Microsoft Store.

Execution policy

In Windows 10, the execution policy is set to restricted by default. This means that Windows PowerShell cannot execute any script, but you can change this policy. Refer to the Microsoft Docs for more information.

1. Open Windows PowerShell and type the following to get a list of all the execution policies.

PS Get-ExecutionPolicy -List

>         Scope ExecutionPolicy
>         ----- ---------------
> MachinePolicy       Undefined
>    UserPolicy       Undefined
>       Process       Undefined
>   CurrentUser       Undefined
>  LocalMachine       Undefined

2. Set the execution policy in the CurrentUser scope.

PS Set-ExecutionPolicy RemoteSigned -scope CurrentUser

3. Verify that execution policy for the CurrentUser scope is set.

PS Get-ExecutionPolicy -scope CurrentUser

If you later want to remove the execution policy, type the following.

PS Set-ExecutionPolicy -ExecutionPolicy Undefined -Scope CurrentUser

New profiles

If a command-line tool does not have a profile auto-generated for you, you can add it manually by editing the settings.json file. Follow these steps to add a profile for most command-line tools and shells. Refer to the Microsoft Docs for more information.

Python terminal

1. First you need to generate a guid value. These take the format of {00000000-0000-0000-0000-000000000000}. You can generate a guidin Windows PowerShell.

PS [guid]::NewGuid()

> 393188ce-14fa-4a3d-a556-21982206494a

2. Inspect the properties of the python terminal's shortcut, take note of the full path to the python executable, any command-line switches used, and the default starting directory.

3. You'll notice that the executable has an embedded icon, but Windows Terminal requires a separate icon or picture file. This step is optional, but if you like to add the icon to the new profile, you will have to extract it from the executable with a 3rd party tool. There are several free tools available, like Thumbico, IconsExtract, Quick Any2Ico and IconExplorer.

4. Press the Ctrl + , keyboard combination or open the drop-down menu and select Settings and then click on Open JSON file. to open the settings.json file in your favourite text editor.

5. Scroll down to find the "profiles": section to add the new profile. Remember that you can make use of environment variables such as %PROGRAMFILES% or %USERPROFILE% in any path depending on where the executable is located. Copy the following profile into your settings.json, but replace the contents of each property with the correct information.

            {
                "commandline": "%USERPROFILE%\\AppData\\Local\\Programs\\Python\\Python310\\python.exe",
                "guid": "{393188ce-14fa-4a3d-a556-21982206494a}",
                "hidden": false,
                "icon": "%USERPROFILE%\\AppData\\Local\\Programs\\Python\\Python310\\python.ico",
                "name": "Python 3.10 (64-bit)",
                "startingDirectory": "%USERPROFILE%\\AppData\\Local\\Programs\\Python\\Python310\\"
            }

Git Bash terminal

1. Similarly to the steps above, generate a guid value in Windows PowerShell.

PS [guid]::NewGuid()

> da73a63c-697d-4a3f-b7c6-b51996b66c91

2. Extract the icon from the executable.

3. Open the settings.json file in your favourite text editor, and add the new profile.

            {
                "commandline": "%PROGRAMFILES%\\Git\\bin\\bash.exe -li",
                "guid": "{da73a63c-697d-4a3f-b7c6-b51996b66c91}",
                "hidden": false,
                "icon": "%PROGRAMFILES%\\Git\\git.ico",
                "name": "Git Bash",
                "startingDirectory": "%USERPROFILE%"
            }

Git CMD terminal

1. Generate a guid value in Windows PowerShell.

PS [guid]::NewGuid()

> b8fc6eae-eb19-4e9e-8564-a2221b1ab55e

2. Inspect the properties of the Git CMD terminal's shortcut.

3. Open the settings.json file in your favourite text editor, and add the new profile.

            {
                "commandline": "%PROGRAMFILES%\\Git\\git-cmd.exe --cd-to-home",
                "guid": "{da73a63c-697d-4a3f-b7c6-b51996b66c91}",
                "hidden": false,
                "icon": "%PROGRAMFILES%\\Git\\git.ico",
                "name": "Git CMD",
                "startingDirectory": "%USERPROFILE%"
            }

pyenv

Meet pyenv, a simple Python version management tool. It lets you change the global Python version, install multiple Python versions, set directory-specific Python versions, and create/manage virtual python environments.

Pyenv installation

1. Install pyenv-win by following the instructions. You can download the zip file, or if you already have Python installed like me, you can use pip instead.

PS Expand-Archive -LiteralPath $env:USERPROFILE\Downloads\pyenv-win-master.zip -DestinationPath $env:USERPROFILE\.pyenv

PS pip install pyenv-win --target $env:USERPROFILE\.pyenv

2. If you already had Python installed, you need to disable the Python launcher.

Right-click on the Start button or press the Windows key + X keyboard combination.
When the WinX menu opens, select "Apps and Features", then click on "App Execution Aliases".
Turn off the App Installer aliases for Python.

3. Add new system environment variables for pyenv.

PS [System.Environment]::SetEnvironmentVariable('PYENV',$env:USERPROFILE + "\.pyenv\pyenv-win\","User")
PS [System.Environment]::SetEnvironmentVariable('PYENV_ROOT',$env:USERPROFILE + "\.pyenv\pyenv-win\","User")
PS [System.Environment]::SetEnvironmentVariable('PYENV_HOME',$env:USERPROFILE + "\.pyenv\pyenv-win\","User")

4. Add pyenv to your user Path variable.

PS [System.Environment]::SetEnvironmentVariable('path', $env:USERPROFILE + "\.pyenv\pyenv-win\bin;" + $env:USERPROFILE + "\.pyenv\pyenv-win\shims;" + [System.Environment]::GetEnvironmentVariable('path', "User"),"User")

5. Close, reopen the terminal, and type the following to verify pyenv is working.

PS pyenv --version

If you receive an error: "Command not found.", check if the environment variables are set properly.

Press Windows key + R keyboard combination.
When the Run application opens, type SystemPropertiesAdvanced.exe, and click the Ok button.

6. Run rehash from your home directory (i.e. %USERPROFILE%).

PS pyenv rehash

7. Update the Python cached version database.

PS pyenv update

8. List all the Python versions available to install.

PS pyenv install --list

9. Install the latest stable Python version.

PS pyenv install 3.10.0

10. Verify that the Python version was installed.

PS pyenv versions

11. Set the global interpreter to the newly installed Python, if there is no global interpreter.

PS pyenv global 3.10.0

12. Run rehash from your home directory (i.e. %USERPROFILE%).

PS pyenv rehash

Pyenv maintenance

To uninstall a Python version.

PS pyenv uninstall 3.10.0

To update Python version changes and maintain shims, rehash from your home directory.

PS pyenv rehash

To update pyenv-win to the latest stable version.

PS pip install --upgrade pyenv-win

Poetry

Poetry is a tool for dependency management and packaging in Python. It allows you to declare the libraries your project depends on and it will manage (install/update) them for you.

Poetry installation

Install Poetry by following these instructions. Poetry provides a custom installer that will install Poetry isolated from the rest of your system.

1. Install Poetry by running the following script.

PS (Invoke-WebRequest -Uri https://raw.githubusercontent.com/python-poetry/poetry/master/install-poetry.py -UseBasicParsing).Content | python -

2. Verify that Poetry is working.

PS poetry --version

3. If you receive an error: "Command not found.", add Poetry to your user Path variable.

PS [System.Environment]::SetEnvironmentVariable('path', $env:USERPROFILE + "\AppData\Roaming\Python\Scripts;" + [System.Environment]::GetEnvironmentVariable('path', "User"),"User")

4. Close, reopen the terminal, and type the following to verify that Poetry is working.

PS poetry --version

Poetry maintenance

To Spawn a shell, according to the $SHELL environment variable. A shell is required to use command line tools from within the virtual environment.

PS poetry shell

To uninstall Poetry run the installer again with the --uninstall option or use pip.

PS pip uninstall poetry

PS python install-poetry.py --uninstall

To update Poetry to the latest stable version.

PS poetry self update

To list the current configuration of Poetry.

PS poetry config --list

To create the Virtualenv in the project's root directory.

PS poetry config virtualenvs.in-project true

To create the Virtualenv in the default directory.

PS poetry config virtualenvs.in-project None

Git & GitHub

Git is a distributed version control system. GitHub provides internet hosting for software development and version control using Git. You can access GitHub in various ways: in the browser, via a desktop application, with the API, or via the command line. Each way of accessing GitHub supports different modes of authentication. It should go without saying that these days everyone should protect their GitHub account with Two-factor authentication (2FA).

To use Git on the command line, you'll need to download, install, and configure Git or GitHub CLI. If you don't want to use the command line, you can instead download and install the free GitHub Desktop or Sourcetree clients.

When connecting to a GitHub repository from Git, you'll need to authenticate with GitHub using either HTTPS (recommended) or SSH. Although SSH-based authentication is considered the most secure, it can be more of a challenge to set up and manage. On the other hand, the less secure HTTPS-based authentication is much easier to use and provides the flexibility to authorize tokens for specific tasks.

It can be time-consuming and frustrating to enter credentials every time we interact with repositories. When connecting to a GitHub repository, every connection needs a username & password (PAT) when using the HTTPS protocol and an SSH key passphrase when using the SSH protocol. The Git credential system and ssh-agent can reduce this annoyance.

Git credentials system

The Git credential-helper can be configured in several modes: cache, store, osxkeychain, ~~winstore~~, ~~manager~~, and most notably manager-core.
In Windows, since Git v2.29.0.windows.1, Git comes with a bundled Git Credential Manager Core (GCM Core), which provides secure git credential storage. GCM Core is the default setting on Windows and called implicitly by Git. Git will initially request a username and PAT when interacting with a repository. On subsequent interactions, Git will re-use existing credentials or tokens that GCM Core stored as long as they're valid. Refer to the Pro Git Book, and man pages for Git for more information.

git-ecosystem / git-credential-manager

Secure, cross-platform Git credential storage with authentication to GitHub, Azure Repos, and other popular Git hosting services.

Git Credential Manager

Git Credential Manager (GCM) is a secure Git credential helper built on .NET that runs on Windows, macOS, and Linux. It aims to provide a consistent and secure authentication experience, including multi-factor auth, to every major source control hosting service and platform.

GCM supports (in alphabetical order) Azure DevOps, Azure DevOps Server (formerly Team Foundation Server), Bitbucket, GitHub, and GitLab Compare to Git's built-in credential helpers (Windows: wincred, macOS: osxkeychain, Linux: gnome-keyring/libsecret), which provide single-factor authentication support for username/password only.

GCM replaces both the .NET Framework-based Git Credential Manager for Windows and the Java-based Git Credential Manager for Mac and Linux.

Install

See the installation instructions for the current version of GCM for install options for your operating system.

Current status

Git Credential Manager is currently available for Windows, macOS, and Linux*. GCM only works with HTTP(S) remotes; you can still use Git with SSH:

View on GitHub

ssh-agent

The ssh-agent that is included with git, while technically a Windows executable, is configured for a pseudo-Linux environment. Thankfully, Windows 10 (version 1809 and later) now incorporate an SSH client to provide SSH authentication without using any third-party clients. Portable OpenSSH is the Microsoft fork of the OpenSSH open source project. Once the ssh-agent is running as a service that stores your various SSH keys, this can facilitate authentication without entering a passphrase each time. Refer to the Pro Git Book, OpenSSH Manual, and Microsoft Docs for more information.

PowerShell / openssh-portable

Portable OpenSSH, all Win32-OpenSSH releases and wiki are managed at https://github.com/powershell/Win32-OpenSSH

Portable OpenSSH

OpenSSH is a complete implementation of the SSH protocol (version 2) for secure remote login, command execution and file transfer. It includes a client ssh and server sshd, file transfer utilities scp and sftp as well as tools for key generation (ssh-keygen), run-time key storage (ssh-agent) and a number of supporting programs.

This is a port of OpenBSD's OpenSSH to most Unix-like operating systems, including Linux, OS X and Cygwin. Portable OpenSSH polyfills OpenBSD APIs that are not available elsewhere, adds sshd sandboxing for more operating systems and includes support for OS-native authentication and auditing (e.g. using PAM).

Documentation

The official documentation for OpenSSH are the man pages for each tool:

Stable Releases

Stable release tarballs are available from a number of download mirrors. We recommend the use of a stable release for most…

View on GitHub

Git installation

1. Download, run Git for Windows and follow the installation wizard steps. Refer to the Pro Git book for more information.

2. Open a terminal and type the following, to set your Git usename.

PS git config --global user.name blikoor

3. Set your email, if email privacy is enabled on remote, use the GitHub-provided noreply email address. Refere to GitHub Docs for more information.

PS git config --global user.email  60975288+blikoor@users.noreply.github.com

4. Create a ~/.gitcommit_template file. Using a custom commit template can help you to follow a structured outline and make better commit messages. A good starting point will be to read more about well-written commit messages and following the Conventional Commits specification. Copy everything below into your own file.

#Conventional Commits 1.0.0
# Please enter the commit message for your changes. Lines starting
# with '#' will be ignored, and an empty message aborts the commit.
# Separate subject, body and footer(s) with a blank line.
# --------------------------------------------------------------------
# The commit message should be structured as follows:
# <type>[optional scope]: <description>
# |<----   Use a maximum of 50 characters   ---->|


# Why was this change made?
# [optional body]
# --------------------------------------------------------------------
# |<---   Try To Limit Each Line to a Maximum Of 70 Characters   --->|


# [optional footer(s)]
# Provide links or keys to any relevant tickets, articles, etc.
# Example: Github issue #23
# --------------------------------------------------------------------
# Types can be
#    feat       - introduces a new feature to the codebase
#    fix        - bug fix for your application
#    refactor   - refactoring production code
#    style      - formatting, corrections, etc; no code change
#    docs       - changes to documentation
#    test       - adding or refactoring tests; no code change
#    chore      - updating grunt tasks etc; no code change
# Use ! to draw attention to a breaking change
# --------------------------------------------------------------------
# For more information, visit:
# https://www.conventionalcommits.org/en/v1.0.0/
# https://chris.beams.io/posts/git-commit/

5. Set the default global commit template. Refer to the Pro Git Book for more information.

PS git config --global commit.template ~/.gitcommit_template

6. Choose between creating and using a personal access token (PAT) or a Secure Shell (SSH) public/private key pair for authentication.

Personal access token

6.1 Verify that your configuration setting for the Git credential-helper is set to manager-core. As mentioned earlier, if you installed the latest Git for Windows release, GCM Core should be the default setting. If this isn't the case for you, refer to Git maintenance for more information.

PS git config credential.helper

> manager-core

6.2 Create a personal access token on GitHub in your account settings, by following the visual instructions. Setting an expiration date on personal access tokens is recommended, tokens that expire can be regenerated. Refer to GitHub Docs for more information.

6.3 Once you have a token, you can enter it instead of your password when performing Git operations over HTTPS.

PS git clone https://github.com/blikoor/pygame-pong.git

6.4 When prompted, type your username and paste the PAT you copied.

> Username: blikoor
> Password: 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

SSH Public/Private key pair

The Windows OpenSSH client and server are optional features that might need to be installed.
6.1 Install OpenSSH through Windows Settings, follow the steps below.

Right-click on the Start button or press the Windows key + X keyboard combination.
When the WinX menu opens, select "Apps and Features", then click on "Optional features".
Verify that the OpenSSH Client appear in the list of installed features.
If not click on "Add a feature" to install it.
Type 'ssh' in the search dialog box to find all the SSH features.
Click the corresponding check box, and click the Install button.

Install OpenSSH using Windows PowerShell, run PowerShell as an Administrator. Verify whether or not OpenSSH is already available.

PS Get-WindowsCapability -Online | Where-Object Name -like 'OpenSSH*'

> Name  : OpenSSH.Client~~~~0.0.1.0
> State : Installed
>
> Name  : OpenSSH.Server~~~~0.0.1.0
> State : NotPresent

If not, install the OpenSSH client component. Refer to Microsoft Docs for more information.

PS Add-WindowsCapability -Online -Name OpenSSH.Client~~~~0.0.1.0

6.2 After installing OpenSSH in Windows, verify the status of the SSH services.

PS get-service *ssh*

> Status   Name               DisplayName
> ------   ----               -----------
> Stopped  ssh-agent          OpenSSH Authentication Agent

6.3 The ssh-agent service needs to be started and can also be configured to start automatically with Windows. Run PowerShell as an Administrator.

PS Start-Service ssh-agent | Set-Service ssh-agent -StartupType Automatic

6.4 Verify that the path for the ssh-agent used by Git is properly configured and associated with OpenSSH in Windows. Validate that your output is similar. The ssh-agent executable should be in the System32 directory, not the Git for Windows program directory (C:\Program Files\Git\cmd\start-ssh-agent.cmd). If this isn't the case for you, refer to Known issues for solutions.

PS Get-Command ssh | Select-Object Source

> Source
> ------
> C:\Windows\System32\OpenSSH\ssh.exe

6.5 Check for existing SSH keys before generating a new key pair. The default filenames for public and private keys respectively look like the following: id_ed25519.pub, id_ed25519, id_rsa.pub, id_rsa. If you receive an error: "No such file or directory.", you do not have existing SSH key pairs in the default location.

PS Get-ChildItem $env:USERPROFILE\.ssh

6.6 Generate a new SSH key pair if you don't have a supported SSH key or don't wish to use any that are available. Only use the RSA algorithm when your system don't support Ed25519.

PS ssh-keygen -t ed25519 -C "your_email@example.com"

PS ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

When prompted to enter a file in which to save the key, press Enter. This accepts the default file and location.

> Enter a file in which to save the key:[Press enter]

When prompted, type a secure passphrase.

> Enter passphrase (empty for no passphrase): [Type passphrase]
> Enter same passphrase again: [Type passphrase again]

6.7 Now that the keys are generated, add the private key to the ssh-agent and the public key to your GitHub account.

PS ssh-add $env:USERPROFILE\.ssh\id_ed25519

6.8 Add the public key to your GitHub account. Open the id_ed25519.pub file in a text editor. The contents of this file is your public key. Select and copy everything. Follow the visual instructions to add the key to GitHub account.

6.9 Only after generating SSH keys, adding them to the ssh-agent and your GitHub account, can you test the SSH connection.

PS ssh -T git@github.com

> The authenticity of host 'github.com (IP ADDRESS)' can't be established.
> RSA key fingerprint is SHA256:nThbg6kXUpJWGl7E1IGOCspRomTxdCARLviKw6E5SY8.
> Are you sure you want to continue connecting (yes/no)?

Verify that the fingerprint in the message you see matches GitHub's RSA public key fingerprint. If it does, then type yes.

> Hi username! You've successfully authenticated, but GitHub does not
> provide shell access.

Git maintenance

It turned out to be quite challenging to manage SSH keys. I couldn't even figure out how to just list all keys, delete all keys, and delete individual keys stored by the ssh-agent.

How do I manage SSH keys stored in the ssh-agent (Portable OpenSSH)?

Blikoor ・ Nov 18 '21

#git #github #help #openssh

In contrast, the Credential Manager (GCM Core) not only allows you to save your credentials but also allows you to view, delete, add, backup, and restore credentials. There are two ways to open the Credential Manager in windows.
Open the Control Panel and click on User Accounts, Credential Manager, and Windows Credentials.

Run the Credential Manager Command Line Utility.

PS rundll32.exe keymgr.dll, KRShowKeyMgr

To set or change your default editor.

PS git config --global core.editor ~/AppData/Local/atom/app-1.58.0/atom.exe --wait

To list the global configuration variables.

$ git config --global -l

To list all of your configuration variables and from where they are coming.

$ git config --show-origin -l

To list your configuration variables.

$ git config -l

To list the local repository's configuration variables.

$ git config --local -l

To list existing remotes of the local repository.

$ git remote -v

To add the remote connection that points to the original repository. This allows you to sync changes made in both repositories.

$ git remote add upstream https://github.com/blikoor/pygame-pong.git

To rename an existing remote connection.

$ git remote rename origen origin

To switch the remote connection from HTTPS to SSH, your URL might look like: git@github.com:USERNAME/REPOSITORY.git

$ git remote set-url origin git@github.com:blikoor/pygame-pong.git

To switch the remote connection from SSH to HTTPS, your URL might look like: https://github.com/USERNAME/REPOSITORY.git

$ git remote set-url origin https://github.com/blikoor/pygame-pong.git

To check the installed Git version. Make sure that Git v2.29.0.windows.1 or later is installed.

$ git --version

To check the installed GCM Core version. Make sure that GCM Core v2.0.252.766 or later is installed.

$ git credential-manager-core --version

To set the Git credential-helper to manager-core.

$ git config --global credential.helper manager-core

Repository

Local repositories reside on the developers' computers. In contrast, remote repositories are hosted on a server that is accessible for all team members.
back to top

Existing project

Open a terminal and change your current directory to the parent directory for the project (e.g., C:\repos).

1. Clone a repository from GitHub to your local computer.

PS PS cd /repos
PS git clone https://github.com/blikoor/pygame-pong.git

2. Change your current directory to the project directory (e.g., C:\repos\your-project), and set a Python version as the local version for this directory.

PS cd pygame-pong
PS pyenv local 3.10.0

3. Verify the active Python version for this directory.

PS pyenv versions

PS python --version

4. Make a virtual environment with Poetry and Virtualenv.

PS poetry env use python

5. Spawn a shell, according to the $SHELL environment variable. A shell is required to use command line tools from within the virtual environment.

PS poetry shell

3. Install the dependencies, as specified in the pyproject.toml and poetry.lock file.

PS poetry install

New project

Open a terminal and change your current directory to the parent directory for the project (e.g., C:\repos).

1. Create a directory structure for the project.

PS cd /repos
PS poetry new pygame-pong

2. Change your current directory to the project directory (e.g., C:\repos\your-project), and set a Python version as the local version for this directory.

PS cd pygame-pong
PS pyenv local 3.10.0

3. Verify the active Python version for this directory.

PS pyenv versions

PS python --version

4. Make a virtual environment with Poetry and Virtualenv.

PS poetry env use python

5. Spawn a shell, according to the $SHELL environment variable. A shell is required to use command line tools from within the virtual environment.

PS poetry shell

6. Initialize the repository of your project.

PS git init

7. Add the primary remote HTTPS or SSH connection for the repository.

# to add the remote HTTPS connection
PS git remote add origin https://github.com/blikoor/pygame-pong.git
# to add the remote SSH connection
PS git remote add origin git@github.com:blikoor/pygame-pong.git

8. Create a .gitignore file in your repository's root directory to tell Git which files and directories to ignore when you make a commit. The github/gitignore public repository has a comprehensive list of examples, and the gitignore.io website can generate a .gitignore file for you. For more information refer to the Pro Git book, man pages for Git, and GitHub Docs.

9. Create a .gitattributes file in your repository's root directory to keep certain files from displaying in diffs, or counting towards the repository language stats. The alexkaratarakis/gitattributes public repository has a comphensive list of examples. For more information refer to the Pro Git book, man pages for Git and GitHub Docs.

Production dependencies

Install the libraries or frameworks used to build the project.

10. Add pygame to the virtual environment. Pygame is a cross-platform set of Python modules designed for developing video games.

PS poetry add pygame

Development dependencies

Install packages to use during the development of the project.

11. Add pytest-cov to the virtual environment. The plugin pytest-cov provides some extra functionality for pytest, Poetry's default testing framework. Poetry already created the tests folder structure along with the rest of the project directory structure.

PS poetry add --dev pytest-cov

12. Add Pylint to the virtual environment. Pylint is a tool for finding bugs and style problems in Python source code.

PS poetry add --dev pylint

13. Pylint isn’t perfect, you need a configuration file to take full advantage of it. Download Google's pylintrc file and save it in the project's root directory. Another option is to generate a sample .pylintrc file with --generate-rcfile and configure it yourself.

PS pylint --generate-rcfile > .pylintrc

14. Since the Google internal style guide differ slightly from PEP 8, we need to customize their .pylintrc file to avoid conflicts between Pylint and Black (installed next). Open the .pylintrc file in a text editor and search for the indent-string setting. Copy and replace it with the following:

indent-string='    '

15. Verify that Pylint is working (shell required).

PS pylint --version

16. Add Black to the virtual environment. Black is a uncompromising Python code formatter. Black is still in beta at the time of writing, hence allowing pre-releases.

PS poetry add --dev black --allow-prereleases

17. Verify that Black is working (Shell required).

PS black --version

18. Add mypy to the virtual environment. mypy is a static type checker for Python.

PS poetry add --dev mypy

19. Verify that mypy is working (shell required).

PS mypy --version

20. mypy is the de facto static type checker for Python. However, its default configuration is too lenient. Custom configuration settings can be added to a mypy.ini file. Refer to the documentation or use the example below.

[mypy]
disallow_untyped_defs = True
disallow_any_unimported = True
no_implicit_optional = True
check_untyped_defs = True
warn_return_any = True
show_error_codes = True
warn_unused_ignores = True
warn_unused_configs = True

The best mypy configuration depends on the project. As a rule of thumb, make the configuration strict by default and loosen it per module if needed. A good practice when using an ignore comment is to ignore only the specific type of an error instead of silencing mypy completely for a line of code. In other words, use:

# type: ignore[<error-code>]

21. Add isort to the virtual environment. isort is a utility that sort imports alphabetically, and automatically separated into sections and by type.

PS poetry add --dev isort

22. Verify that isort is working (shell required).

PS isort --version

23. isort needs some configuration for compatibility with Black. The configuration settings can be added to a dedicated .isort.cfg file. Refer to the documentation or use the example below.

[settings]
profile = black
multi_line_output = 3
include_trailing_comma = True
force_grid_wrap = 0
use_parentheses = True
line_length = 88
skip_gitignore = True
ensure_newline_before_comments = True

24. Add pre-commit to the virtual environment. pre-commit is a framework for managing and maintaining multi-language pre-commit hooks.

PS poetry add --dev pre-commit

25. Verify that pre-commit is working (shell required).

PS pre-commit --version

26. Create a pre-commit configuration file.

PS pre-commit sample-config > .pre-commit-config.yaml

27. Install the Git hook scripts so that pre-commit run automatically on each commit.

PS pre-commit install

> pre-commit installed at .git/hooks/pre-commit

28. Add pre-commit plugin hooks to the .pre-commit-config.yaml file. Copy everything below and append it to your configuration file, but change the repository mappings of each hook to reflect the correct version. Refer to the documentation for more supported hooks.

-   repo: https://github.com/PyCQA/pylint
    rev: v2.12.2
    hooks:
    - id: pylint
-   repo: https://github.com/psf/black
    rev: 21.12b0
    hooks:
    - id: black
-   repo: https://github.com/pre-commit/mirrors-mypy
    rev: v0.930
    hooks:
    - id: mypy
-   repo: https://github.com/PyCQA/isort
    rev: 5.10.1
    hooks:
    - id: isort

29. Update the hooks to the latest version automatically.

PS pre-commit autoupdate

30. Run the hooks against all of the files after adding new hooks, usually pre-commit will only run on the changed files.

$ pre-commit run --all-files

Manage projects

It is best to manage the project in the project folder and from within a shell for the virtual environment.

To see isort's configuration, as well as sources of config options.

PS isort --show-config

To see the files isort will process with the current configuration.

PS isort --show-files

To get basic information about the currently activated virtual environment.

PS poetry env info

To list environments associated with this project.

PS poetry env list

To check the pyproject.toml file for errors.

PS poetry check

To show a breakdown of all the packages currently installed to the project, including dependencies of dependencies.

PS poetry show

To update dependencies specified in the pyproject.toml to their latest versions, and update the poetry.lock file accordingly.

PS poetry update

To export the poetry.lock file of the project to a requirements.txt file for some reason.

PS poetry export -f requirements.txt > requirements.txt

To remove dependencies from the virtual environment, updating the pyproject.toml and poetry.lock files accordingly.

PS poetry remove <package-name>

To update the project's Python version to the latest released version. Make sure to run the first set of commands from your home directory and the second set from the project root folder. Verify that the [tool.poetry.dependencies] section in the pyproject.toml file, reflect the new Python version. Remember to configure the new virtualenv for the project in the Pycharm IDE.

PS pyenv update
PS pyenv install 3.10.2
PS pyenv rehash

PS pyenv local 3.10.2
PS pyenv versions
PS poetry env use python
PS poetry install

To delete existing virtual environments.

PS poetry env info
PS poetry env remove pygame-pong-hEbvnVPS-py3.10

To unset a Python version as the local version for this directory.

PS pyenv local --unset

Fast track new repos

Here is how you can create a new project in a just a couple of minutes, assuming you have Pyenv and Poetry installed already.

Open a terminal and type the following:

PS cd /repos
PS poetry new your-project
PS cd your-project
PS pyenv local 3.10.0
PS poetry env use python
PS poetry shell
PS poetry add --dev pytest-cov pylint mypy isort pre-commit
PS poetry add --dev black --allow-prereleases
PS pre-commit sample-config > .pre-commit-config.yaml |
PS pre-commit install

2. Download Google's pylintrc file and save it in the project's root directory. Open the .pylintrc file in a text editor to replace the indent-string setting with the following:

indent-string='    '

3. Copy everything below and paste it into a mypy.ini file within the project's root directory.

[mypy]
disallow_untyped_defs = True
disallow_any_unimported = True
no_implicit_optional = True
check_untyped_defs = True
warn_return_any = True
show_error_codes = True
warn_unused_ignores = True
warn_unused_configs = True

4. Copy everything below and paste it into a .isort.cfg file within the project's root directory.

[settings]
profile = black
multi_line_output = 3
include_trailing_comma = True
force_grid_wrap = 0
use_parentheses = True
line_length = 88
skip_gitignore = True
ensure_newline_before_comments = True

5. Copy everything below and append it to your .pre-commit-config.yaml file, but change the repository mappings of each hook to reflect the correct version.

-   repo: https://github.com/PyCQA/pylint
    rev: v2.12.2
    hooks:
    - id: pylint
-   repo: https://github.com/psf/black
    rev: 21.12b0
    hooks:
    - id: black
-   repo: https://github.com/pre-commit/mirrors-mypy
    rev: v0.930
    hooks:
    - id: mypy
-   repo: https://github.com/PyCQA/isort
    rev: 5.10.1
    hooks:
    - id: isort

6. Copy everything from a template and paste it into a .gitignore file within the project's root directory.

7. Copy everything from a template and paste it into a .gitattributes file within the project's root directory.

8. Open a terminal and type the following:

$ git init
$ pre-commit autoupdate
$ pre-commit run --all-files

PyCharm

PyCharm Community Edition is a free, open-source, cross-platform IDE designed for pure Python development. Download, run the Standalone Installer, and follow the installation wizard steps. Refer to the Installation guide for more information.
back to top

Open projects

1. To open your project from disk, do one of the following:
On the Welcome Screen, click the Open button.

From the main menu, select File | Open.

2. In the "Open File or Project" dialog that opens, find location of the project directory.

3. Click OK.
back to top

Configure Python interpreter

1. Press Crtl + Alt + S keyboard combination, to open the project settings.

2. Go to Project | Python Interpreter. Then click on the cog icon and select Add.

3. In the left-hand pane of the "Add Python Interpreter" dialog, select Poetry Environment.

4. Select the Existing environment option. Expand the Interpreter list and select any of the existing Poetry environments. Alternatively, find an interpreter and specify a path to it.
back to top

Default project directory

1. Press Crtl + Alt + S keyboard combination, to open the project settings.

2. Go to Apearance & Behaviour | System Settings. Then click on the folder icon to browse and select the default project folder for all projects (e.g., C:\repos).

3.\ Click the OK button.
back to top

Suggested plugins

Pycharm offers support for plugins to extend the core functionality of PyCharm and improve productivity. The following is only a short list of noteworthy community rated plugins, browse the Jet Brains Marketplace for more.

Free plugins

Pylint provides both real-time and on-demand scanning of Python files with Pylint from within the PyCharm IDE.

File Watchers allows the executing of tasks triggered by file modifications.

Rainbow Brackets colors nested parentheses, brackets or braces in your code.

AceJump allows you to quickly navigate the caret to any position visible in the editor.

String Manipulation provides case switching, sorting, filtering, incrementing, aligning to columns, grepping, escaping, encoding, and more.

Zero Width Characters Locator adds an inspection that prevents some hard to find bugs related to invisible zero width characters in source code and resources.

Grazie provides intelligent spelling and grammar checks for text that you write in the IDE.

IDE Features Trainer helps you learn basic shortcuts and essential features interactively - right inside the IDE.

Key Promoter X helps you to learn essential shortcuts while you are working.

Freemium plugins

Kite is an AI-powered coding assistant featuring code completion snippets, advanced function signatures, and instant documentation.

Tabnine is an AI coding assistant featuring code completion, AI-powered code completion, AI copilot, AI code snippets, code suggestion, code prediction, code hinting, or content assist.

WakaTime provides metrics, insights, and time tracking automatically generated from your programming activity.
back to top

Install plugins

1. Press Crtl + Alt + S keyboard combination, to open the IDE settings.

2. Go to Plugins. Then click on the Marketplace tab to browse and install plugins.

3. Find the plugin in the Marketplace and click install.
back to top

IDE integration

Black

1. Press Crtl + Alt + S keyboard combination, to open the IDE settings.

2. Go to Tools | External Tools. Then press Alt + Insert keyboard combination, to add a new tool.

3. Add a new external tool with the following values:
Name: Black
Description: Black is the uncompromising Python code formatter.
Program: $PyInterpreterDirectory$/black
Arguments: $FilePath$
Working directory: $ProjectFileDir$

4. Click OK button.

5. Format the currently opened file by selecting Tools | External Tools | Black from the menu.

1. Make sure you have the File Watchers plugin installed.

2. Press Crtl + Alt + S keyboard combination, to open the IDE settings.

3. Go to Tools | File Watchers. Then press Alt + Insert keyboard combination, to add a new watcher.

4. Add a new watcher with the following values:
Name: Black
File type: Python
Scope: Project Files
Program: $PyInterpreterDirectory$/black
Arguments: $FilePath$
Output paths to refresh: $FilePath$
Working directory: $ProjectFileDir$

5. In advanced Options
Uncheck "Auto-save edited files to trigger the watcher"
Uncheck "Trigger the watcher on external changes"

6. Click OK button.

mypy

1. Press Crtl + Alt + S keyboard combination, to open the IDE settings.

2. Go to Tools | External Tools. Then press Alt + Insert keyboard combination, to add a new tool.

3. Add a new external tool with the following values:
Name: mypy
Description: mypy is the de facto static type checker for Python.
Program: $PyInterpreterDirectory$/mypy
Arguments: $FilePath$
Working directory: $ProjectFileDir$

4. Click OK button.

5. Format the currently opened file by selecting Tools | External Tools | Black from the menu.

1. Make sure you have the File Watchers plugin installed.

2. Press Crtl + Alt + S keyboard combination, to open the IDE settings.

3. Go to Tools | File Watchers. Then press Alt + Insert keyboard combination, to add a new watcher.

4. Add a new watcher with the following values:
Name: mypy
File type: Python
Scope: Project Files
Program: $PyInterpreterDirectory$/mypy
Arguments: $FilePath$
Output paths to refresh: $FilePath$
Working directory: $ProjectFileDir$

5. In advanced Options
Uncheck "Auto-save edited files to trigger the watcher"
Uncheck "Trigger the watcher on external changes"

6. Click OK button.

isort

In short, there is no viable integration option available that I am aware of at the moment. The available isort plugin is outdated, and there are issues when trying to use either External Tools or the File Watchers plugin for this purpose.
back to top

Known issues

1. At the time of writing, I encountered an issue with Poetry's caching. When installing Poetry or dependencies you may encounter the following error: "ValueError, some whl file in the cache does not exist.". There are currently two accepted community workarounds:
Simply delete the AppData\Local\pypoetry\Cache\artifacts folder.

Export a requirements.txt file with Poetry.

PS poetry export -f requirements.txt --output requirements.txt --without-hashes

Install the project's dependencies with pip instead.

PS pip install -r requirements.txt

2. If you installed the latest Git for Windows release, Git should automatically detect the existence of OpenSSH in Windows and should properly configure and associate with OpenSSH. This information is mostly here for completeness and in case someone does experience issues (referring to step 6.4 of Git).

The workaround for this is to change your Git global configuration to use the OpenSSH executable. Refer to the man pages for Git for more information. Run the following command in Windows PowerShell.

PS git config --global core.sshCommand "'C:\Windows\System32\OpenSSH\ssh.exe'"

Append the following to the [core] section in your ~/.config file. Refer to the man pages for Git for more information.

[core]
    sshCommand = \"C:\\Windows\\System32\\OpenSSH\\ssh.exe\"

If you still experience issues, you can override the Git auto-detection whether commands refer to OpenSSH by setting the GIT_SSH environment variable. Refer to the man pages for Git for more information.

PS [Environment]::SetEnvironmentVariable("GIT_SSH", "$((Get-Command ssh).Source)", [System.EnvironmentVariableTarget]::User)

How do I manage SSH keys stored in the ssh-agent (Portable OpenSSH)?

Blikoor — Thu, 18 Nov 2021 12:13:42 +0000

• Windows 10 v20H2 • Git v2.33.0.windows.2 • Portable OpenSSH

I'm at my wit's end trying to figure out how to manage SSH keys stored by the ssh-agent. I expect to be able to list the keys and delete all or individual keys as needed. The Microsoft Docs doesn't give any indication of how to do this, but at least point you to the OpenSSH Manual.

However, the commands do not work!
I have searched for solutions on the internet, but I couldn't find any. I'll explain the issue in more detail with the following steps:

I Verified that the path for the ssh-agent used by Git is properly configured and associated with Portable OpenSSH in Windows.

PS Get-Command ssh | Select-Object Source

> Source
> ------
> C:\Windows\System32\OpenSSH\ssh.exe

1. Test the SSH connection to confirm that SSH authentication is working.

PS ssh -T git@github.com

> Enter passphrase for key 'C:\Users\Blikoor/.ssh/id_ed25519':
> Hi blikoor! You've successfully authenticated, but GitHub does not provide shell access.

2. To lists the public keys of all identities currently managed by the ssh-agent. I expected a list containing the Ed25519 key(s) stored by the agent.

PS ssh-add -L

> The agent has no identities.

3. To delete a specific or list of identities from the ssh-agent. I expected the agent to remove the private key corresponding to the specified public key.

PS ssh-add -d $env:USERPROFILE\.ssh\id_ed25519.pub

> Could not remove identity "C:\Users\Blikoor\.ssh\id_ed25519.pub": agent refused operation

4. To delete all identities from the ssh-agent. I expected the agent to remove all the private keys, but even though it seems successful, the SSH authentication test in the next step disproof this assumption.

PS ssh-add -D

> All identities removed.

5. Test the SSH connection again after deleting all keys. I expected that the test will fail, yet the second test is successful as well.

PS ssh -T git@github.com

> Enter passphrase for key 'C:\Users\Blikoor/.ssh/id_ed25519':
> Hi blikoor! You've successfully authenticated, but GitHub does not provide shell access.

Customize Git Bash shell

Blikoor — Sun, 31 Oct 2021 16:27:24 +0000

Due to the need to maintain backward compatibility, newer features of Bash are rarely enabled by default. MinGW64 (Minimalist GNU for Windows x64) has to be configured to take full advantage of these features. Improve your productivity with several simple tweaks that can enhance Bash out-of-the-box without using external stuff. I will assume that Git for Windows and optionally also Windows Terminal are already installed.

Customize Startup Files

The Git bash shell is invoked as an interactive login shell for Git-only authentication access. Bash uses a few startup files to configure the shell environment for users. It will source files like ~/.bash_profile, ~/.bash_login, and ~/.profile in the order given. The first readable file that exists is sourced.

Bash Profile

1. Create a ~/.bash_profile file. The .bash_profile contains commands for setting the shell's environment variables. A ~/.bash_profile can be used instead of ~/.profile but is read by Bash only. Since the shell is interactive, the ~/.bashrc file is not sourced. Refer to the Bash Manual for more information. Copy everything below into your own file.



# Source the ~/.bashrc file if it exists
if [ -f ~/.bashrc ]
then
    . ~/.bashrc
fi

Bash shell Script

2. Create a ~/.bashrc file. The .bashrc file contains commands that are specific to the Bash shell. It is the best place for aliases and bash-related functions. Copy everything below into your own file.



# Git aliases
alias gs='git status -sb'
alias gcc='git checkout'
alias gcm='git checkout master'
alias gaa='git add --all'
alias gc='git commit -m $2'
alias push='git push'
alias gpo='git push origin'
alias pull='git pull'
alias clone='git clone'
alias stash='git stash'
alias pop='git stash pop'
alias ga='git add'
alias gb='git branch'
alias gl="git log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)<%an>%Creset' --abbrev-commit"
alias gm='git merge'

# Bash aliases
alias .='cd .'
alias ..='cd ..'
alias ...='cd ../../'
alias ....='cd ../../../'
alias .....='cd ../../../../'
alias bashclear='echo "" > ~/.bash_history'
alias cls='clear'
alias ls='ls -F --color=auto --show-control-chars'
alias ll='ls -l'
alias ll.='ls -la'
alias lls='ls -la --sort=size'
alias llt='ls -la --sort=time'
alias rm='rm -iv'
alias work='cd /c/repos'

# Bash shell settings
# Typing a directory name just by itself will automatically change into that directory.
shopt -s autocd

# Automatically fix directory name typos when changing directory.
shopt -s cdspell

# Automatically expand directory globs and fix directory name typos whilst completing. 
# Note, this works in conjuction with the cdspell option listed above.
shopt -s direxpand dirspell

# Enable the ** globstar recursive pattern in file and directory expansions.
# For example, ls **/*.txt will list all text files in the current directory hierarchy.
shopt -s globstar

# Ignore lines which begin with a <space> and match previous entries.
# Erase duplicate entries in history file.
HISTCONTROL=ignoreboth:erasedups

# Ignore saving short- and other listed commands to the history file.
HISTIGNORE=?:??:history

# The maximum number of lines in the history file.
HISTFILESIZE=99999

# The number of entries to save in the history file.
HISTSIZE=99999

# Set Bash to save each command to history, right after it has been executed.
PROMPT_COMMAND='history -a'

# Save multi-line commands in one history entry.
shopt -s cmdhist

# Append commands to the history file, instead of overwriting it.
# History substitution are not immediately passed to the shell parser.
shopt -s histappend histverify

Git Bash Prompt

The Git Bash prompt is set by a shell script called git-prompt.sh and can be found in the c/Program\ Files/Git/etc/profile.d directory. Notice that in lines 8-10, a custom ~/.config/git/git-prompt.sh file will be sourced, if it exists. I believe that this is the recommended method to override the default settings.



# lines omitted
if test -f ~/.config/git/git-prompt.sh
then
    . ~/.config/git/git-prompt.sh
else
    # lines omitted
fi
# lines omitted

3. Create a ~/.config/git/git-prompt.sh file. The git-prompt.sh file contains commands for setting the title of the Git Bash terminal and the Bash prompt string. Copy everything below into your own file.



# Custom prompt settings
PROMPT_DIRTRIM=4                         # Shorten deep paths in the prompt
PS1='\[\033]0;Git | Bash v\v | \W\007\]' # set window title
PS1="$PS1"'\n'                           # new line
PS1="$PS1"'\[\033[30;45m\] [\A] '        # black text, magenta, 24h time
PS1="$PS1"'\[\033[30;42m\] \u '          # black text, green, user
#PS1="$PS1"'\[\033[30;42m\]@\h '          # black text, green, @host
PS1="$PS1"'\[\033[30;43m\] \w '          # black text, yellow, working director
if test -z "$WINELOADERNOEXEC"
then
    GIT_EXEC_PATH="$(git --exec-path 2>/dev/null)"
    COMPLETION_PATH="${GIT_EXEC_PATH%/libexec/git-core}"
    COMPLETION_PATH="${COMPLETION_PATH%/lib/git-core}"
    COMPLETION_PATH="$COMPLETION_PATH/share/git/completion"
    if test -f "$COMPLETION_PATH/git-prompt.sh"
    then
        . "$COMPLETION_PATH/git-completion.bash"
        . "$COMPLETION_PATH/git-prompt.sh"
        PS1="$PS1"'\[\033[97;46m\]'  # white text, cyan
        PS1="$PS1"'`__git_ps1`'      # bash function
    fi
fi
PS1="$PS1"'\[\033[0m\]'        # change color
PS1="$PS1"'\n'                 # new line
PS1="$PS1"'$ '                 # prompt: always $

# Git status options
# Shows * or + for unstaged and staged changes, respectively.
export GIT_PS1_SHOWSTASHSTATE=true

# shows $ if there are any stashes.
export GIT_PS1_SHOWDIRTYSTATE=true

# Shows % if there are any untracked files.
export GIT_PS1_SHOWUNTRACKEDFILES=true

# shows <, >, <>, or = when your branch is behind, ahead, diverged from,
# or in sync with the upstream branch, respectively.
export GIT_PS1_SHOWUPSTREAM="auto"

User Configuration

4. Create a ~/.inputrc file. This file contains commands to configure command history, directory display, and keyboard bindings using the built-in GNU Readline library. Refer to the Bash Manual, and Readline Documentation for more information.



# Disable beeps & bells, and do not display control characters.
set bell-style none
set echo-control-characters off

# The TAB key cycles forward through the completion choices.
# Press an arrow key, such as right-arrow, to choose a selection.
TAB: menu-complete

# The Shift-TAB key cycles backward through the completion choices.
# Like TAB, press an arrow key, such as right-arrow, to choose a selection.
"\e[Z": menu-complete-backward

# The first TAB key press will display a list that match the given prefix.
# The next TAB key press will start cycling through the available choices.
set menu-complete-display-prefix on

# Display completion matches upon the first press of the TAB key.
#set show-all-if-ambiguous on

#Enable colors when completing filenames and directories.
set colored-stats on

# Completion matches of multiple items highlight the matching prefix in color.
set colored-completion-prefix on

# Ignore case when completing.
set completion-ignore-case on

# Treat hypens and underscores as equivalent when completing.
set completion-map-case on

# Append the / character to the end of symlinked directories when completing.
set mark-symlinked-directories on

# Enable incremental history navigation with the UP and DOWN arrow keys.
# This will use the already typed text as a required prefix.
"\e[A": history-search-backward
"\e[B": history-search-forward

The Readline library also provides several useful shortcuts.

Keyboard shortcut	Description
Control-A	Go to beginning of line.
Control-E	Go to the end of the line.
Alt-B	Go back one word.
Alt-F	Go forward on word.
Alt-Backspace	Delete backward one word.
Alt-D	Delete forward one word.
Control-R	Search back through history.
Control-R	Cycle backward through history.
Control-Shift-R	Cycle forward through history.
Alt-.	Append an argument of the previous command.

Finished Result

5. After the customization is done, restart the terminal or open a new Git Bash tab in Windows Terminal. Your Git Bash should look similar to the result below.

Bash Utilities

Some Bash utilities are also included with Git for Windows and may be used to enhance your Git experience if the default behavior is not desired. These utilities will need to be configured in each independent development environment. Refer to the Pro Git Book for more information.

The git-completion and git-prompt scripts can be found in the following directory. /c/Program\ Files/Git/mingw64/share/git/completion/ Copy the git-completion.bash and git-prompt.sh to your home directory.

To use the scripts append the following lines to the ~/.bashrc file.



# Enable tab completion for Git commands
source ~/.git-completion.bash
# Change bash prompt to display current Git branch and status
source ~/.git-prompt.sh

Where to start

Blikoor — Wed, 08 Sep 2021 06:08:48 +0000

My programming journey began with studying BCom Informatics (Information Systems) back in seemingly the dark ages of studying computing, where you did not have much choice in your field of study. I was mainly interested in game development, but my first introduction to programming was with COBOL and C++. These days academic institutions provide study programs geared towards game development.

As a new developer, you may hear that "C++ is the language that the pros use.", and therefore you should use it too. But do not start with C++ unless you're an experienced developer. Because sometimes using what the pros use isn't the right thing to do. The first language you learn shouldn't have a steep learning curve. With more knowledge and experience under your belt, you'll be able to transition to whatever the pros use. You might also feel tempted to jump straight in a game engine, but you're going to get stuck often and hit frustrating roadblocks. You first need to learn the basics of programming to build a solid foundation.

I recommend starting with Python. Learn to make games with any of the dominant Python game libraries, Pygame, Cocos2D, PYGLET, Panda3D, or OGRE. Python is easy to learn, and there's a lot of resources available. It is also the most commonly used language for scripting, automation, and developing plugins for graphic applications. Move to the Godot Engine once you have a good understanding of Python, then GDScript will make a lot more sense.

My second recommendation would be to start with C# and learn to make games with MonoGame. C# is a modern, easy-to-learn derivative of C++ that has a higher learning curve than Python. Again, once you have a good understanding of C#, you'll have an easy transition to Unity.

Because of its multidisciplinary nature, game development can feel overwhelming at first. To make games alone or as part of a small team, you'll need to learn game design and programming. That's a lot to tackle all at once! Be patient and enjoy the journey. Start small, focus on code and design separately, honing each skill you need on its own.

My GameDev Journey

Blikoor — Mon, 06 Sep 2021 07:10:05 +0000

Esteemed friends, welcome to my dev blog. A direct English translation for my pseudo name would be "Tinear", it hints towards an old Afrikaans proverb: 'n Blikoor wees — So genoem omdat Vrystaters dan kwansuis dom sou wees omdat hulle nie met blikore kan hoor nie. In other words, just hinting towards the province of origin. 😜

I have been learning to program for a few years now, but I have never really developed anything. Studying several programming languages in courses over the years and following along with tutorials, I still find myself in Tutorial Purgatory. But although I still feel like a beginner, I like to think that I am a game developer by heart. 😏

The general consensus seems to be that there are numerous convincing reasons to blog about your journey, for new developers and professionals alike. I look forward to assisting other developers in good faith and hopefully escape Tutorial Purgatory myself in the process. Admittedly, it would be equally great to learn from other community members as well. 😎

Forem: Blikoor

The print function

Syntax

Escape sequences

Printing to terminal

String formatting

Syntax

field_name

conversion

format_spec

Printing to a file

Learning Python

Software

Documentation

PEPs

Books

Tutorials

Interactive Tutorials & Books

Tutorial Videos

Courses

Practise Exercises & Coding Challenges

Podcasts

What is Python?

Design philosophy & Features

Statements & Control flow

Built-in types

Expressions

Uses

Introduction to Python

— Part 5 in the series is coming soon —

Setting up a Python development environment

Table of Contents

Windows Terminal

Execution policy

New profiles

Python terminal

Git Bash terminal

Git CMD terminal

pyenv

Pyenv installation

Pyenv maintenance

Poetry

Poetry installation

Poetry maintenance

Git & GitHub

Git credentials system

git-ecosystem / git-credential-manager

Secure, cross-platform Git credential storage with authentication to GitHub, Azure Repos, and other popular Git hosting services.

Git Credential Manager

Install

Current status

ssh-agent

PowerShell / openssh-portable

Portable OpenSSH, all Win32-OpenSSH releases and wiki are managed at https://github.com/powershell/Win32-OpenSSH

Portable OpenSSH

Documentation

Stable Releases

Git installation

Personal access token

SSH Public/Private key pair

Git maintenance

How do I manage SSH keys stored in the ssh-agent (Portable OpenSSH)?

Blikoor ・ Nov 18 '21

Repository

Existing project

New project

Production dependencies

Development dependencies

Manage projects

Fast track new repos

PyCharm

Open projects

Configure Python interpreter

Default project directory

Suggested plugins

Free plugins

Freemium plugins

Install plugins

IDE integration

Black