Svelte Basics

Styling React Components

In Arch, it's the little things. Hang on to them. Cherish your ability to do anything. You've earned it.

Here's how to adjust your screen brightness.



## Docs

Who doesn't need help setting up Arch? Arch saves you with some great wiki docs. There's one on many [methods for adjusting screen brightness](https://wiki.archlinux.org/title/backlight#ACPI).

I had no luck with any of the utilities like xbacklight. `xrandr --brightness` worked, but it only adjusts perceived brightness through color adjustment, not real backlight output.

What follows in the method that worked for me. I have a laptop with an amd gpu.

## Adjust with ACPI Hardware

Find out what hardware you have by listing this directory:

```bash
ls /sys/class/backlight/
```

That will show you your graphics card. From there, you can see aspects of the backlight, including:

```bash
~ ➜ ls -1 /sys/class/backlight/amdgpu_bl0
actual_brightness
bl_power
brightness
device
max_brightness
power
scale
subsystem
type
```

Current brightness is in `brightness`. Min brightness is `0`. Max brightness is the value in `max_brightness`.

Only the root user can adjust the brightness, so switch to be root. I didn't have any luck adjusting the udev rules to allow non-root adjustment.

Get a root shell by typing `su`. Then echo the brightness value into the file that you desire.

```
[root@machine]# echo 100 > /sys/class/backlight/amdgpu_bl0/brightness
```

How to adjust screen brightness in arch on amd gpu laptop

Adjust Screen Brightness in Arch

This is a method for debuggging FastAPI with pdb debugger.



## pdb

[pdb](https://docs.python.org/3/library/pdb.html) is a debugger built right into the python standard library. You don't need to install a library. You don't need a fancy IDE.

## FastAPI

This debugging method should have broad application, but here we will use it in a FastAPI app.

[FastAPI](https://fastapi.tiangolo.com/) is a framework for building web APIs in python. Here's a basic application:

```
from datetime import datetime
from fastapi import FastAPI

app = FastAPI()

@app.get('/')
def root():
    now = datetime.now()
    return { "now": now }
```

There's one endpoint. It returns the current time. 

## Run with uvicorn

[uvicorn](https://www.uvicorn.org/) is an ASGI web server implementation. You can use it to run FastAPI. Install:

```
poetry add uvicorn
```

And start:

```
uvicorn main:app --reload
```

The `main:app` argument is the path to your `app` variable inside the `main.py` module. The `--reload` flag detects changes to the files and restarts the server automatically for dev mode.


If we call it, it works:

```
❯ curl localhost:8000
{"now":"2022-06-02T06:53:58.376421"}%
```

## pdb Debugging

This is all a contrived example. There's not too much to debug. But let's add a breakpoint and try it out. Let's determine what the value of `now` is at runtime.

The breakpoint is added by adding code. You need to import `pdb` and the set the breakpoint. Do that with a one-liner:

```
import pdb; pdb.set_trace()
```

Add that line below the `now` variable assignment:

```
@app.get('/')
def root():
    now = datetime.now()
    import pdb; pdb.set_trace()
    return { "now": now }
```

And stop and restart `uvicorn`, now with a `--debug` flag:

```
uvicorn main:app --reload --debug
```

Then curl to hit the code:

```
❯ curl localhost:8000
```

It'll hang, and the process for `uvicorn` will change from the usually app log to stdout to show a `pdb` repl:

```
> /Users/jaketrent/dev/ohai-fastapi/main.py(10)root()
-> return { "now": now }
(Pdb)
```

It stops on the line of the breakpoint. Here, you can examine the local variables by name. We want to see the value of `now`, so we type:

```
(Pdb) now
datetime.datetime(2022, 6, 2, 8, 2, 50, 139827)
```

And look at that! We see the value at runtime.

At the `(Pdb)` prompt, you can run the usual debugger commands. These are done with text commands. Type `?` to see a list of possible commands:

```
(Pdb) ?

Documented commands (type help <topic>):
========================================
EOF    c          d        h         list      q        rv       undisplay
a      cl         debug    help      ll        quit     s        unt
alias  clear      disable  ignore    longlist  r        source   until
args   commands   display  interact  n         restart  step     up
b      condition  down     j         next      return   tbreak   w
break  cont       enable   jump      p         retval   u        whatis
bt     continue   exit     l         pp        run      unalias  where

Miscellaneous help topics:
==========================
exec  pdb
```

You can run `help` on any of these commands, such as `help c`, and you can see:

```
(Pdb) help c
c(ont(inue))
        Continue execution, only stop when a breakpoint is encountered.
```

Now that we're done debugging, we'll press `c` for continue to move past our breakpoint. At that point, curl returns:

```
{"now":"2022-06-02T08:02:50.139827"}
```

`pdb` is a capable debugger. It doesn't require extra tooling. FastAPI can't keep any secrets from us!

How to debug FastAPI in python with pdb debugger

Debug FastAPI with pdb

How to add a cookie to a curl request.



First, find your cookie. Perhaps you're making a test request to an API that your web app uses. You could fire up the web app, authenticate, open devtools and see the cookie in the request headers. Copy it. Keep it secret. Keep it safe.

Then back to the terminal where you belong:

```
curl --cookie "<cookiename>=<cookievalue>" <url>
```

The notable option is here is `--cookie`. The format of the cookie header is for to send the cookie name, followed by an `=` equal sign, followed by the cookie value.


For example:

```
curl --cookie "myjwt=abc123" http://localhost:8080/my/api
```

Add a Cookie to a Curl

To run an async test in pytest, it must be marked. It can be a pain to mark them all individually. Here's how to mark them all async at once.



## Asynchronous tests

You'd need an asynchronous test for asynchronous code under test. For instance, [Quart](https://pgjones.gitlab.io/quart/) is an app server where all the endpoints are asynchronous.  If you were testing that Quart app, you might create a test like:

```python
from quart import Quart
async def test_thing():
    client = Quart("appname", static_folder=None).test_client()
    response = await client.get("/api/thing")
    assert response.status_code == 200
```

When running `pytest`, the use of `async` and `await` keywords will fail, reporting that a plugin is needed.

## Plugin

The plugin that enables async testing in pytest is [pytest-asyncio](https://pypi.org/project/pytest-asyncio/). To install:

```
poetry add pytest-asyncio
```

Or instead of poetry, use the package manager of your choice.

## Mark individually

Now you'd be able to mark a test individually. In your test file, write:

```python
import pytest

@pytest.mark.asyncio
async def test_1():
    # ...

@pytest.mark.asyncio
async def test_2():
    # ...
```

## Mark all tests async

But if you have many tests in a single module, this can be annoying to repeat the decorator. To [mark all tests in the module async](https://docs.pytest.org/en/6.2.x/example/markers.html#marking-whole-classes-or-modules), you mark a special module-global variable called `pytestmark`. At the top of your test file add:

```python
import pytest

pytestmark = pytest.mark.asyncio
```

Now you have no more need to decorate every test function.

Skill up with a sweet course

Find spicey tips in tech

Adjust Screen Brightness in Arch

Debug FastAPI with pdb

Add a Cookie to a Curl

Mark All Tests as Async in pytest