slides/tuesday_02.html

<!DOCTYPE html>
<html>
  <head>
    <title>Digital Summer School 2024: TUE02</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
    <link rel="stylesheet" href="../style.css">  </head>
  <body>
    <textarea id="source">


class: center, middle, titlepage
### TUE02: *Intro to Git, Python.*

---
class: contentpage
### **Agenda**

1. IDEs         
    1.1 Jupyter     
2. Git
3. GitHub    
4. Python    
    4.1 Why Python?    
    4.2 How Python?    
    4.3 Types of Python    
    4.4 Basics: Print    
    4.5 Basics: Strings     
    4.6 Basics: Variables     
    4.7 Basics: Types    
    4.8 Basics: Lists    
    4.9 Basics: For Loops    
    4.10 Basics: Libraries  
    4.11 Basics: If statements          
    4.12 Basics: Subprocess    
    4.13 Basics: Exceptions
5. Practical 🏋️


---
class: contentpage
### **1. IDEs**

Before we start writing any Python scripts, we need to set up a DEVELOPER ENVIRONMENT!!


---
class: contentpage
### **1. IDEs**


An IDE is an environment in which we write (and sometimes can also run!) code. We **could** write a script using a basic text editor (Notepad!), but it is not much fun, and we will make loads of mistakes. 

IDEs generally come with tools to help us code better.

The most popular options for Python are Visual Studio Code, PyCharm, Sublime Text... there are heaps and heaps of these.

If you are looking for one to start with, I would recommend Visual Studio Code. It is easy to install and has a good balance of tools and extensibility.

https://code.visualstudio.com/

If you are concerned about telemetry, there is a fork called VS Codium which has removed this component.

https://vscodium.com/


---
class: contentpage
### **1.1 Jupyter**

When looking at coding in Python, you might come across mentions of Jupyter and Jupyter notebooks. A Jupyter notebook is a document that comprises various blocks of text and code that can be run in any order, or executed directly.

Jupyter is open source, so there are plenty of platforms that have "borrowed" the same concept: Google Colaboratory, Netflix Nteract, Microsoft Fabric notebooks. Visual Studio Code can also run Jupyter notebooks.

The ability to integrate explanatory text, graphics, code and even interactive widgets is a reason why it is quite popular in science and academic contexts.

Because our focus of this course is more on functional and operational processes, we won't really be looking at Jupyter any further, but keep it in mind if you want to do data analysis, fancy reports or just have a more interactive experience with Python.

---
class: contentpage
### **2. Git**

What is Git? 


---
class: contentpage
### **2. Git**


Git is one of these things which is completely ubiquitous in its domain, like Photoshop or Google.

Git is a software management command line application written by Linus Torvalds, who was also responsible for creating Linux.

It is primarily a code version-management system, which can be used to keep track of our code, allow management of different variants as they are developed, and collaboration between multiple programmers.

Git itself is a command line application, but there are many options for graphical interfaces. It is also built-in to most modern IDEs (including Visual Studio Code).


---
class: contentpage
### **2. Git**

Turn your FOLDER into a REPOSITORY. WOW!

```sh
git init
```

There is now a hidden folder called `.git` that will handle version management.

---
class: contentpage
### **2. Git**


We can update the file changes in the main folder space using `git add`

```sh
git add *
```

Git commit lets us label this snapshot, a good opportunity to provide some context to what work was undertaken.


```sh
git commit -m 'starting here'
```

Do a few of these, and then we can see the logs!

```sh
git log
```

Knowing a bit about working with the Git CLI is not a bad idea, especially if you need to resolve a complex version/merge problem, but generally speaking you could mostly get by with a graphical IDE integration and GitHub.

```sh
git --help
```


---
class: contentpage
### **3. GitHub**


GitHub is to Git what Facebook is to Faces.

GitHub is a website that allows developers to host their software projects using Git, with a lot of other useful features to help with keeping track of projects.

In the previous example, we were just storing work on our own computers; GitHub lets us host it online, with benefits for collaboration between different coders.

It has been owned by Microsoft since it was bought in 2018. GitLab is also an equivalent platform that has some superior features, but GitHub still has much more traffic.


---
class: contentpage
### **3. GitHub**

Practical: 

- Login to GitHub
- Make a "repository"
- Add a file
- Clone to your computer


---
class: tangentpage
### **Tangent: GitHub Authentication via SSH**

Once we start working with GitHub we will want a means of authenticating our computer so that we can read and write code, including private repositories.

A popular method of achieveing this is via SSH. This means creating a secret key on our computer, we share a "public" component with GitHub and then can authenticate that our computer is authorised to read and write our repositoreis.

We can create a new SSH key (if none exist) with the following command, and step through the prompts

```sh
ssh-keygen
```

We then copy the pub (public) part of the key to GitHub under `Settings` -> `SSH and GPG keys` -> `New SSH key`

We should now have the ability to clone and commit to our GitHub repos.

---
class: tangentpage
### **Tangent: Set GitHub Authorship**

We can commit code, but we want our changes to be attributed to us. This can be set globally on your computer using the following commands.
      
```sh
git config --global user.email "paulduchesne@tuta.io"
git config --global user.name "paulduchesne"
```
      
---
class: contentpage
### **3. GitHub**

Now you can "fork" the summer-school repository. 

https://github.com/paulduchesne/summer-school-2024

Forking is when you copy all of my code into your own space (like "copy" "paste"). You are now free to modify it as much as you like. 

If you do something cool and want to merge it back in to the original project, you can make a "pull request", which we will discuss a bit later.

---
class: tangentpage
### **Setup**

- Fork repository from https://github.com/paulduchesne/summer-school-2024.
- Clone it locally to your computer.
- Copy media folder from Desktop.

---
class: contentpage
### **4. Python**

Python is a general purpose programming language from the 1980s, which is amongst one of the most popular in the world. It can be used to create all sorts of interesting things across the disciplines of data science, web development, machine learning... and digital archiving.


---
class: contentpage
### **4.1 Why Python?**


While the command-line can be handy for simple processes, we will likely want to switch to a programming language to create more complex systems.


---
class: contentpage
### **4.2 How Python?**

The act of writing a Python script and executing the script are distinct. A Python script can be written in any text editor or IDE, but we will require the Python Interpreter for it to do anything.


In practise, this will look like: 
Use a text editor/IDE to write your script.

```python
hello = "hi"
```

save as -> `myscript.py`

In the command line, use the Python Interpreter to execute the code

```sh
python myscript.py
```

Depending on your install, you may need to specifically call `python3`.


---
class: contentpage
### **4.3 Types of Python**
Like most software, there are many different versions of Python, with version 3.12 being the current version.

There was a significant change in code between Python2 and Python3, which required a lot of script rewriting.

Be careful if you are on macOS, as Python2.7 is still installed by default, so just calling `python my_script.py` might have unexpected results.

Good idea to check your version of Python with

```sh
python --version
```

or 


```sh
python3 --version
```

On Unix systems (macOS and Linux) you can also see exactly which Python interpreter is running with `which python`. 

---
class: contentpage
### **4.3 Types of Python**


Anaconda is a distribution of Python which comes with its own package management system for external libraries. 

It seems to be most popular with data science and machine learning projects, where managing different versions of different libraries can become tricky. I wouldn't really recommend using it unless this becomes a problem for you.


---
class: contentpage
### **4.4 Basics: Print**

The simplest Python action is to print something:

```python
print('greeting')
```
This is the Python equivalent of `echo` which we saw in the last session.

---
class: contentpage
### **4.5 Basics: Strings**

A "string" in Python is a line of text (emojis allowed!) which Python identifies by using quotations marks (double or single are fine at this stage).

```python
print('greeting')
```

Note that if we do not use quotation marks, Python does not know that this is a line of text, and does not know what to do with it.


```python
print(greeting)
```

!!! ERROR !!!

The code here is actually 'legal,' but we have inadvertently created what is called a 'variable' which we have not defined.

Python doesn't know what `greeting` (without quotations) means.

---
class: contentpage
### **4.6 Basics: Variables**

Text-without-quotations is what is known as a "variable", and is a placeholder for some other value.

```python
greeting = 'hello'
print(greeting)
```


A variable must be a combination of letters, numbers and underscores, no spaces, and no "reserved" Python keywords (eg "print").


This is very useful when we want to take a value and modify it.
```python
a_number = 1986
print(a_number)
a_number = a_number/10
print(a_number)
a_number = a_number+16
print(a_number)
a_number = a_number+a_number
print(a_number)
```
or when we have an unknown values we are working with (eg, perform an action on all files in a folder).


---
class: contentpage
### **4.7 Basics: Types**

In Python, there is the concept of different data types, of which we have seen two: *strings* and *numbers*.

These can be identified by using the type() method.

```python
print(type('hello'))
```


Variables inherit type. Note Python is a "dynamic typed" language, we don't need to explicitly instruct on type, it figures it out for us.
This means we can write code a lot faster, but it can cause problems if we think a variable is a certain type, and we get it wrong. As an example, `100` (an integer), `'100'` (a string) are different things.

```python
greeting = 'hello'
print(type(greeting))
```

Different types will behave differently, and throw an error if a logical result is not possible.

```python
a_number = 100
print(a_number+a_number, a_number / 2)
a_string = '100'
print(a_string+a_string, a_string / 2)
```


---
class: contentpage
### **4.8 Basics: Lists**

A very important concept in Python is a list or an "array". 

```python
some_people = ['paul', 'david', 'bethany', 'shana']
```

Lists can contain a mix of types.

```python
mixed_types = ['hello', 27, 3.1415]
```


---
class: contentpage
### **4.9 Basics: For Loops**

Another key concept is the "for loop", which lets us work through a list, and apply an action to each list elements. This is exactly the same concept we saw earlier during the command line session.

```python
for a_number in [17, 27, 37, 47]:
    print(a_number)
```
Worth noting at this point, spaces in Python matter. We need to indent the `print(a_number)` element with two or four spaces, so that the Python Interpreter knows what is going on!

```python
for a_number in [17, 27, 37, 47]:
    print(a_number + 4)
```

We can use this pattern to start to perform interesting file operations, but first we will need to find a library to help us work with file paths!


---
class: contentpage
### **4.10 Basics: Libraries**

Libraries are just chunks of Python code which other people wrote, and save us having to build everything from scratch.
Many useful libraries come pre-included with Python by default, but you can install others to do highly specific, or write your own!

For now, we are going to use a very useful library called Pathlib.

```python
import pathlib
for filename in ['0086400.dpx', 'not_a_file.dpx']:
    print(filename, type(filename))
    pathlib_filename = pathlib.Path.cwd() / 'media' / 'film_scan' / filename
    print(pathlib_filename, type(pathlib_filename))
    print(pathlib_filename.exists())
```

Note the `.exists()` method at the end of the `pathlib_filename`? 

This is a "method" to check if the file exists at that location or not, and returns True or False. Different types have different methods (ie things you can do with them). This is also where documentation becomes very useful, to know what methods are available to use.

https://docs.python.org/3/library/pathlib.html


---
class: contentpage
### **4.11 Basics: If statements**

`If statements` let us route operations depending on an assessment on whether something is true or not.

```python
a_number = 37
if a_number < 10:
  print('the number is less than ten')
elif a_number > 100:
  print('the number is greater than one hundred')
elif a_number == 900:
  print('the number is nine hundred')
else:
  print('what is this number?')
```


Typical symbols here are '<' something is less than something else, '>' greater than, '==' equals, and '!=' not equals.

Worth paying attention to the difference between '=' which means "this thing is this thing" (defining a variable, an assertion), '==' means "does this thing equal this thing?" (assess the truth of a statement, a question).

Also, you can use these checks outside of if statements.

```python
print(900 == 700)
```


---
class: contentpage
### **4.11 Basics: If statements**

We can also use "if statements" inside "for loops", or "for loops" inside "if statements", and on and on. This is where we can introduce complex logic (also known as "decision trees").

```python
import pathlib
for filename in ['0086400.dpx', 'not_a_file.dpx']:
    pathlib_filename = pathlib.Path.cwd() / 'media' / 'film_scan' / filename
    if pathlib_filename.exists():
        print(pathlib_filename, 'THE FILE EXISTS, HOORAY')
    else:
        print(pathlib_filename, 'WHERE IS THAT FILE?')
    
print('done.')
```


---
class: contentpage
### **4.12 Basics: Subprocess**


I wanted to introduce the `subprocess` library. Subprocess is cool because we can call command line applications from within Python!


This can be useful if you want to orchestrate tools sequentially (extract video metadata with MediaInfo, transcode using FFmpeg, make a checksum).


```python
import subprocess
subprocess.call(['ffmpeg', '-version'])

```


A good part of this is that we can have processes defined which work inside or outside of Python (e.g. a specific FFmpeg command to convert video files).

Bad news is that this can make our scripts OS dependant (e.g. "copy a file" CLI command is different on macOS or Windows). One of the strengths of Python is that normally it can run the same scripts OS-agnostic.


You will also notice `subprocess` needs the command expressed as an array of strings.


---
class: contentpage
### **4.13 Basics: Exceptions**


A very important feature of your code is what is called "exception handling". This is where something unexpected or undesired happens, and you want to stop your script and say, "SOMETHING HAS GONE WRONG".

```python
import pathlib
for filename in ['0086400.dpx', 'not_a_file.dpx']:
    pathlib_filename = pathlib.Path.cwd() / 'media' / 'film_scan' / filename
    if pathlib_filename.exists():
        print(pathlib_filename, 'THE FILE EXISTS, HOORAY')
    else:
        raise Exception('WHERE IS FILE', pathlib_filename)

print('done.')


```

Note that if we run this and the file is not found, it does not progress past the raised exception. We never get to the "done" print statement.


---
class: contentpage
### **5. Practical**

We are going to:

- Log into GitHub.

- Fork the `summer-school-2024` repo, so we each have our own copy.

- Clone it to your computer to work on locally.

- Write a script in your favourite IDE to check filesizes on our scan files, and raise an exception if a certain condition is not met.

- Use Git to commit changes back to GitHub (CLI and IDE).

- Quick tour of GitHub issues, version control and branches.

---
class: contentpage, middle

This has been an introduction to Python and Git!


    </textarea>
    <script src="https://remarkjs.com/downloads/remark-latest.min.js" type="text/javascript"></script>
    <script type="text/javascript">var slideshow = remark.create({ratio: "16:9"});</script>
  </body>
</html>