.. vim:   noexpandtab fileencoding=utf-8 nomodified   wrap textwidth=200 foldmethod=marker foldmarker={{{,}}} foldcolumn=4 ruler showcmd lcs=tab\:|- list

|cobra| Atomic write
################################################################################

:date: 2023.04.10 08:24:38
:tags: hint,python
:summary: Atomic write in Python
:title: Atomic write
:nice_title: |cobra| Atomic write |cobra|

%HEADER%

Atomic write
--------------------------------------------------------------------------------

|Gilhad >| In the `make -j24` will be run many Python programs at the same time. The programs would need wite to some file concurently in a way, that each program would append a single string and then let all other programs to write there too. How to do atomic write with smallest possible blocking time?

|chatGPT >| To ensure atomic writes with the smallest possible blocking time, you can use the `fcntl` module in Python to obtain a file lock before writing to the file. Here's an example of how you can achieve this:


.. code:: python

		import fcntl
		
		with open('filename', 'a') as f:
				fcntl.flock(f, fcntl.LOCK_EX)
				f.write('string to append\n')
				fcntl.flock(f, fcntl.LOCK_UN)

In this example, `fcntl.flock(f, fcntl.LOCK_EX)` acquires an exclusive lock on the file `f`, ensuring that no other process can write to it simultaneously. Once the lock is acquired, the program writes the string to the file and releases the lock using `fcntl.flock(f, fcntl.LOCK_UN).` The with statement ensures that the file is automatically closed once the write operation is completed.

You can use this method in your Python programs to ensure that writes are atomic and that multiple processes can write to the same file without causing conflicts.

non-locking read
--------------------------------------------------------------------------------

|Gilhad >| Nice :) Can I also read the file (without locking this time)?

|chatGPT >| Yes, you can read the file without locking it. When you open a file in Python with the `open()` function, you can specify the `mode` in which you want to open it. For reading, you should use the mode `r`:


.. code:: python

		with open('filename', 'r') as f:
				data = f.read()
				# do something with data

The `with` statement ensures that the file is properly closed after reading, even if an error occurs. The `read()` method reads the entire contents of the file into the `data` variable. You can then process the `data` as needed.

It's important to note that while reading a file does not require locking, it's still a good idea to use a context manager like with `open()` to ensure that the file is properly closed after reading, especially if you're working with many files or running many Python programs concurrently.



RST a CSS
--------------

|chatGPT >| To mark inline code, you can use the backtick character () to surround the code. For example, to mark the word code` as inline code, you would write:


.. code:: css

		Use the `code` element to mark inline code.

This will render as:

* Use the `code` element to mark inline code.

|Gilhad >| Which CSS clases will be used for that?

|chatGPT >| The CSS classes that are commonly used to style variables and inline code in reStructuredText are:

* `literal`: used to style inline literals, like file names, command line arguments, or other small snippets of code.
* `code`: used to style code blocks, which are delimited by a line of three backticks (`\`\`\``).
* `pre`: used to style preformatted text, which is delimited by a line of two backticks (`\`\``).

Here is an example of how to use these classes in CSS to style variables and inline code in reStructuredText:


.. code:: css

	.literal {
		font-family: monospace;
		background-color: #f7f7f7;
		border: 1px solid #ddd;
		padding: 0.2em 0.4em;
		border-radius: 4px;
	}
	
	.code {
		font-family: monospace;
		background-color: #f7f7f7;
		border: 1px solid #ddd;
		padding: 1em;
		border-radius: 4px;
	}
	
	.pre {
		font-family: monospace;
		background-color: #f7f7f7;
		border: 1px solid #ddd;
		padding: 1em;
		border-radius: 4px;
	}

You can use these classes in your reStructuredText files as follows:

vbnet

Here is some `inline literal text`_.

.. code-block:: python

	# This is a code block
	def hello():
		print("Hello, world!")

.. _inline literal text: some_file.py

Here is some preformatted text:

.. parsed-literal::

	This is preformatted text.
	It preserves whitespace and line breaks.