miniminitel 1.0.3__tar.gz

miniminitel-1.0.3/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: miniminitel
+Version: 1.0.3
+Summary: Simple Minitel interface in Python
+Author: Portevent
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Portevent/MiniMinitel
+Project-URL: Issues, https://github.com/Portevent/MiniMinitel/issues
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pillow
+Requires-Dist: pyserial
+
+# MiniMinitel
+MiniMinitel is a simple Minitel interface in python. It has been created with the help of :
+- http://543210.free.fr/TV/stum1b.pdf
+- https://wiki-ima.plil.fr/mediawiki/images/b/b1/Minitel.pdf
+- https://github.com/eserandour/Minitel1B_Hard
+
+```python
+from miniminitel import MiniMinitel
+
+with MiniMinitel("COM4") as minitel:
+    minitel.clear()
+    
+    minitel.cursor_move_to(4, 4)
+    minitel.write_double_grandeur("Hello world")
+
+    minitel.write_at(6, 6, "I'm a MiniMinitel")
+    minitel.set_blinking()
+    minitel.write_at(6, 7, "And I look cool")
+    minitel.set_non_blinking()
+
+```
+
+# Setup
+## Python
+MiniMinitel is a work in progress, no version are published to PyPI yet.  
+Library is written with Python 3.10, no support for other version are guaranteed (should be compatible Python 3.11+)
+```commandline
+pip install miniminitel
+```
+
+## Minitel
+Minitel need to be pluggged to computer throught serial port. Documentation need to be written 

miniminitel-1.0.3/README.md

@@ -0,0 +1,32 @@
+# MiniMinitel
+MiniMinitel is a simple Minitel interface in python. It has been created with the help of :
+- http://543210.free.fr/TV/stum1b.pdf
+- https://wiki-ima.plil.fr/mediawiki/images/b/b1/Minitel.pdf
+- https://github.com/eserandour/Minitel1B_Hard
+
+```python
+from miniminitel import MiniMinitel
+
+with MiniMinitel("COM4") as minitel:
+    minitel.clear()
+    
+    minitel.cursor_move_to(4, 4)
+    minitel.write_double_grandeur("Hello world")
+
+    minitel.write_at(6, 6, "I'm a MiniMinitel")
+    minitel.set_blinking()
+    minitel.write_at(6, 7, "And I look cool")
+    minitel.set_non_blinking()
+
+```
+
+# Setup
+## Python
+MiniMinitel is a work in progress, no version are published to PyPI yet.  
+Library is written with Python 3.10, no support for other version are guaranteed (should be compatible Python 3.11+)
+```commandline
+pip install miniminitel
+```
+
+## Minitel
+Minitel need to be pluggged to computer throught serial port. Documentation need to be written 

miniminitel-1.0.3/pyproject.toml

@@ -0,0 +1,26 @@
+[project]
+name = "miniminitel"
+version = "1.0.3"
+authors = [
+  { name="Portevent" },
+]
+description = "Simple Minitel interface in Python"
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3"
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+dependencies = [
+  "pillow",
+  "pyserial"
+]
+
+[project.urls]
+Homepage = "https://github.com/Portevent/MiniMinitel"
+Issues = "https://github.com/Portevent/MiniMinitel/issues"
+
+[build-system]
+requires = ["setuptools >= 80.9.0"]
+build-backend = "setuptools.build_meta"

miniminitel-1.0.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

miniminitel-1.0.3/src/miniminitel/C0.py

@@ -0,0 +1,39 @@
+# C0 grid
+
+# http://543210.free.fr/TV/stum1b.pdf - page 92 (95 in pdf)
+
+NUL : bytes = b'\x00' #             Documentation required
+SCH : bytes = b'\x01' #             Documentation required
+
+
+EOT : bytes = b'\x04' #             Documentation required
+ENQ : bytes = b'\x05' #             Documentation required
+
+BEL : bytes = b'\x07' #             Ring a bell
+BS : bytes = b'\x08' # Ctrl + H     Move cursor left
+HT : bytes = b'\x09' # Ctrl + I     Move cursor right
+TAB : bytes = HT     # HT is sometimes called TAB
+LF : bytes = b'\x0A' # Ctrl + J     Move cursor down
+VT : bytes = b'\x0B' # Ctrl + K     Move cursor up
+FF : bytes = b'\x0C' #              Return cursor to start of first line. Clear all. Explicit article separator
+CR : bytes = b'\x0D' # <--'         Move cursor to origin
+SO : bytes = b'\x0E' #              Switch to G1 characters
+SI : bytes = b'\x0F' #              Revert to standart alphanum characters (G0)
+
+DLE : bytes = b'\x10' #              Documentation required
+Con : bytes = b'\x11' #              Cursor on
+Rep : bytes = b'\x12' #              Documentation required
+Sep : bytes = b'\x13' #              Documentation required
+Coff : bytes = b'\x14' #              Cursor off
+NACK : bytes = b'\x15' #              Documentation required
+SYN : bytes = b'\x16' #              Documentation required
+
+CAN : bytes = b'\x18' # Ctrl + X    Add space till end of line
+SS2 : bytes = b'\x19' #              Documentation required
+SUB : bytes = b'\x1A' #              Documentation required
+ESC : bytes = b'\x1B' #              Esc code (used to access C1 grid)
+SS3 : bytes = b'\x1D' #              Documentation required
+RS : bytes = b'\x1E' #              Return cursor to start of first line. Explicit article separator
+
+US : bytes = b'\x1F' #              Explicit article separator
+

miniminitel-1.0.3/src/miniminitel/C1.py

@@ -0,0 +1,37 @@
+# C1 grid
+
+# http://543210.free.fr/TV/stum1b.pdf - page 92 (95 in pdf)
+
+NOIR : bytes = b'\x40'
+ROUGE : bytes = b'\x41'
+VERT : bytes = b'\x42'
+JAUNE : bytes = b'\x43'
+BLEU : bytes = b'\x44'
+MAJENTA : bytes = b'\x45'
+CYAN : bytes = b'\x46'
+BLANC : bytes = b'\x47'
+CLIGNOTEMENT : bytes = b'\x48'
+FIXE : bytes = b'\x49'
+
+
+GRANDEUR_NORMALE : bytes = b'\x4C'
+DOUBLE_HAUTEUR   : bytes = b'\x4D'
+DOUBLE_LARGEUR   : bytes = b'\x4E'
+DOUBLE_GRANDEUR  : bytes = b'\x4F'
+
+FOND_NOIR : bytes = b'\x50'
+FOND_ROUGE : bytes = b'\x51'
+FOND_VERT : bytes = b'\x52'
+FOND_JAUNE : bytes = b'\x53'
+FOND_BLEU : bytes = b'\x54'
+FOND_MAJENTA : bytes = b'\x55'
+FOND_CYAN : bytes = b'\x56'
+FOND_BLANC : bytes = b'\x57'
+
+MASQUAGE : bytes = b'\x58'
+LIGNAGE_FIN : bytes = b'\x59'
+LIGNAGE_DEBUT : bytes = b'\x5A'
+FOND_NORMAL : bytes = b'\x5C'
+FOND_INVERSE : bytes = b'\x5D'
+DEMASQUAGE : bytes = b'\x5F'
+

miniminitel-1.0.3/src/miniminitel/__init__.py

@@ -0,0 +1 @@
+from .miniminitel import MiniMinitel

miniminitel-1.0.3/src/miniminitel/miniminitel.py

@@ -0,0 +1,5 @@
+from .minitel_image import MinitelImage
+
+
+class MiniMinitel(MinitelImage):
+    pass

miniminitel-1.0.3/src/miniminitel/minitel_controller.py

@@ -0,0 +1,183 @@
+from typing import Callable
+
+from .C0 import ESC, BS, LF, CAN, TAB, Sep
+from .minitel_dialog_code import MinitelInput, MinitelCode
+from .minitel_videotex_attributes import MinitelVideotexAttributes
+
+
+class MinitelController(MinitelVideotexAttributes):
+
+    def write(self, text: str):
+        """
+        Write text on Minitel
+        :param text: text
+        """
+        self._write_byte(bytes(text, encoding="ascii"))
+
+    def write_at(self, x: int, y: int, text: str) -> None:
+        """
+        Move cursor to position and write to
+        :param x: Column
+        :param y: Row
+        :param text: Text
+        """
+        self.cursor_move_to(x, y)
+        self.write(text)
+
+    def write_double_grandeur(self, text: str) -> None:
+        """
+        Write with double grandeur
+        :param text: Text
+        """
+        self.set_double_grandeur()
+        self.write(text)
+        self.set_grandeur_normale()
+
+    def write_double_largeur(self, text: str):
+        """
+        Write with double largeur
+        :param text: Text
+        """
+        self.set_double_largeur()
+        self.write(text)
+        self.set_grandeur_normale()
+
+    def write_double_hauteur(self, text: str):
+        """
+        Write with double hauteur
+        :param text: Text
+        """
+        self.set_double_hauteur()
+        self.write(text)
+        self.set_grandeur_normale()
+
+    def start_listening(self, on_read: Callable[[MinitelInput], None]):
+        """
+        Listen to port and pass MinitelInput to callback
+        :param on_read: Action to perform on read
+        """
+        value = self.ser.read_all() # Clear buffer before, usefull to get rid of bootup code
+        # print(f"READALL -> {value}")
+
+        while True:
+            value = self.ser.read()
+            print(f" -> {value}")
+
+            if value == ESC: # Mode téléinformatique
+                word = self.ser.read() + self.ser.read()
+
+                match word:
+                    case b'OM':
+                        on_read(MinitelInput(MinitelCode.ENVOI))
+
+                    case b'OP':
+                        on_read(MinitelInput(MinitelCode.SOMMAIRE))
+
+                    case b'OQ':
+                        on_read(MinitelInput(MinitelCode.ANNULATION))
+
+                    case b'OR':
+                        on_read(MinitelInput(MinitelCode.RETOUR))
+
+                    case b'OS':
+                        on_read(MinitelInput(MinitelCode.REPETITION))
+
+                    case b'Om':
+                        on_read(MinitelInput(MinitelCode.GUIDE))
+
+                    case b'Ol':
+                        on_read(MinitelInput(MinitelCode.CORRECTION))
+
+                    case b'On':
+                        on_read(MinitelInput(MinitelCode.SUITE))
+
+                    case b'[A':
+                        on_read(MinitelInput(MinitelCode.MOVE_UP))
+
+                    case b'[B':
+                        on_read(MinitelInput(MinitelCode.MOVE_DOWN))
+
+                    case b'[C':
+                        on_read(MinitelInput(MinitelCode.MOVE_RIGHT))
+
+                    case b'[D':
+                        on_read(MinitelInput(MinitelCode.MOVE_LEFT))
+
+                    case b'[H':
+                        on_read(MinitelInput(MinitelCode.GO_BACK_UP))
+
+                    case b'[L':
+                        on_read(MinitelInput(MinitelCode.INSERT_LINE))
+
+                    case b'[M':
+                        on_read(MinitelInput(MinitelCode.SUPPR_LINE))
+
+                    case b'[P':
+                        on_read(MinitelInput(MinitelCode.SUPPR_COLUMN))
+
+                    case b'[4':
+                        word += self.ser.read()
+                        # print(f"INSERT COLUMN {word}")
+                        on_read(MinitelInput(MinitelCode.INSERT_COLUMN, word.decode()))
+
+                    case b'[2':
+                        word += self.ser.read()
+                        # print(f"E.Page {word}")
+                        on_read(MinitelInput(MinitelCode.E_Page, word.decode()))
+
+                    case _:
+                        on_read(MinitelInput(MinitelCode.UNKNOWN_CODE, word.decode()))
+
+            elif value == Sep: # Mode télétel
+                word = self.ser.read()
+
+                match word:
+                    case b'A':
+                        on_read(MinitelInput(MinitelCode.ENVOI))
+
+                    case b'F':
+                        on_read(MinitelInput(MinitelCode.SOMMAIRE))
+
+                    case b'E':
+                        on_read(MinitelInput(MinitelCode.ANNULATION))
+
+                    case b'B':
+                        on_read(MinitelInput(MinitelCode.RETOUR))
+
+                    case b'C':
+                        on_read(MinitelInput(MinitelCode.REPETITION))
+
+                    case b'D':
+                        on_read(MinitelInput(MinitelCode.GUIDE))
+
+                    case b'G':
+                        on_read(MinitelInput(MinitelCode.CORRECTION))
+
+                    case b'H':
+                        on_read(MinitelInput(MinitelCode.SUITE))
+
+                    case b'Y':
+                        on_read(MinitelInput(MinitelCode.CONNEXION))
+
+                    case _:
+                        on_read(MinitelInput(MinitelCode.UNKNOWN_CODE, word.decode()))
+            else:
+                # Can't add this check in match, as match value: case BS: will map value onto BS
+                if value == BS:
+                    on_read(MinitelInput(MinitelCode.BS))  # Ctrl + H
+                elif value == LF:
+                    on_read(MinitelInput(MinitelCode.LF)) # Ctrl + J
+                elif value == CAN:
+                    on_read(MinitelInput(MinitelCode.CAN)) # Ctrl + X
+                elif value == TAB:
+                    on_read(MinitelInput(MinitelCode.TAB)) # Ctrl + I
+                else:
+                    match value:
+                        case b'\x00':
+                            on_read(MinitelInput(MinitelCode.BRK)) # Ctrl + Connexion
+                        case b'\x7f':
+                            on_read(MinitelInput(MinitelCode.DELETE)) # Ctrl + Connexion
+                        case b'\r':
+                            on_read(MinitelInput(MinitelCode.CARRIAGE_RETURN)) # ENTER
+                        case _:
+                            on_read(MinitelInput(MinitelCode.TEXT, value.decode()))

miniminitel-1.0.3/src/miniminitel/minitel_csi.py

@@ -0,0 +1,142 @@
+from .minitel_videotex import MinitelVideotex
+
+class MinitelCSI(MinitelVideotex):
+    """
+    Minitel CSI commands
+    """
+
+    def move_cursor_up(self, n: int = 1):
+        """
+        Move cursor up n time
+        Note : when n = 1, this function is similar to shiftCursorUp()
+        """
+        self._write_csi()
+        self._write_bytes_p(n)
+        self._write_byte(b'\x41')
+
+    def move_cursor_down(self, n: int = 1):
+        """
+        Move cursor down n time
+        Note : when n = 1, this function is similar to shiftCursorDown()
+        """
+        self._write_csi()
+        self._write_bytes_p(n)
+        self._write_byte(b'\x42')
+
+    def move_cursor_right(self, n: int = 1):
+        """
+        Move cursor right n time
+        Note : when n = 1, this function is similar to shiftCursorRight()
+        """
+        self._write_csi()
+        self._write_bytes_p(n)
+        self._write_byte(b'\x43')
+
+    def move_cursor_left(self, n: int = 1):
+        """
+        Move cursor left n time
+        Note : when n = 1, this function is similar to shiftCursorLeft()
+        """
+        self._write_csi()
+        self._write_bytes_p(n)
+        self._write_byte(b'\x44')
+
+    def cursor_move_to(self, x: int, y: int):
+        """
+        Move cursor to row X and column Y
+        :param x: from 01 to 24
+        :param y: from 01 to 40 (or 80)
+        """
+        self._write_csi()
+        self._write_bytes_p(y)
+        self._write_byte(b'\x3B')
+        self._write_bytes_p(x)
+        self._write_byte(b'\x48')
+
+    def clear_all_after(self):
+        """
+        Clear everything after the cursor till last row (doesn't move cursor)
+        """
+        self._write_csi()
+        # self._writeByte(b'\x30') Optional, doesn't matter
+        self._write_byte(b'\x4A')
+
+    def clear_all_before(self):
+        """
+        Clear everything before the cursor till first row (doesn't move cursor)
+        """
+        self._write_csi()
+        self._write_byte(b'\x31')
+        self._write_byte(b'\x4A')
+
+    def clear_screen(self):
+        """
+        Clear everything (doesn't move cursor)
+        """
+        self._write_csi()
+        self._write_byte(b'\x32')
+        self._write_byte(b'\x4A')
+
+    def clear_row_end(self):
+        """
+        Clear after the cursor till the end of row (doesn't move cursor)
+        """
+        self._write_csi()
+        # self._writeByte(b'\x30') Optional
+        self._write_byte(b'\x4B')
+
+    def clear_row_start(self):
+        """
+        Clear before the cursor till the start of row (doesn't move cursor)
+        """
+        self._write_csi()
+        self._write_byte(b'\x31')
+        self._write_byte(b'\x4B')
+
+    def clear_row(self):
+        """
+        Clear current row (doesn't move cursor)
+        """
+        self._write_csi()
+        self._write_byte(b'\x32')
+        self._write_byte(b'\x4B')
+
+    def insert_rows(self, count: int):
+        """
+        Insert n rows
+        """
+        self._write_csi()
+        self._write_bytes_p(count)
+        self._write_byte(b'\x4C')
+
+    def clear_rows(self, count: int):
+        """
+        Clear n rows
+        """
+        self._write_csi()
+        self._write_bytes_p(count)
+        self._write_byte(b'\x4D')
+
+    def clear_characters(self, count: int):
+        """
+        Clear n character
+        """
+        self._write_csi()
+        self._write_bytes_p(count)
+        self._write_byte(b'\x50')
+
+    def insert_mode_on(self):
+        """
+        Activate insertion mode
+        """
+        self._write_csi()
+        self._write_byte(b'\x34')
+        self._write_byte(b'\x68')
+
+    def insert_mode_off(self):
+        """
+        Deactivate insertion mode
+        """
+        self._write_csi()
+        self._write_byte(b'\x34')
+        self._write_byte(b'\x6C')

miniminitel-1.0.3/src/miniminitel/minitel_dialog_code.py

@@ -0,0 +1,38 @@
+class MinitelCode:
+    TEXT = 'TEXT'
+    ENVOI = 'ENVOI'
+    SOMMAIRE = "SOMMAIRE"
+    ANNULATION = "ANNULATION"
+    RETOUR = "RETOUR"
+    REPETITION = "REPETITION"
+    GUIDE = 'GUIDE'
+    CORRECTION = "CORRECTION"
+    SUITE = "SUITE"
+    MOVE_UP = "MOVE UP"
+    MOVE_DOWN = "MOVE DOWN"
+    MOVE_RIGHT = "MOVE RIGHT"
+    MOVE_LEFT = "MOVE LEFT"
+    GO_BACK_UP = "GO BACK UP"
+    INSERT_LINE = "INSERT LINE"
+    SUPPR_LINE = "SUPPR LINE"
+    SUPPR_COLUMN = "SUPPR COLUMN"
+    INSERT_COLUMN = "INSERT COLUMN"
+    E_Page = "E.Page"
+    CONNEXION = "CONNEXION"
+    BS = "BS"
+    LF = "LF"
+    CAN = "CAN"
+    TAB = "TAB"
+    BRK = "BRK"
+    DELETE = "DELETE"
+    CARRIAGE_RETURN = "CARRIAGE RETURN"
+    UNKNOWN_CODE = "UNKNOWN CODE"
+
+class MinitelInput:
+    code: str
+    text: str
+
+    def __init__(self, code: str, text: str = ""):
+        self.code = code
+        self.text = text
+

miniminitel-1.0.3/src/miniminitel/minitel_image.py

@@ -0,0 +1,234 @@
+from random import random
+
+from PIL import Image
+
+from .minitel_controller import MinitelController
+
+def pseudo_random(min_value: int, max_value: int, bias = 1):
+    return min_value + int((max_value - min_value) * (random() ** bias))
+
+# Palette Minitel (8 couleurs) en RGB
+minitel_palette = [
+    (0, 0, 0),  # Noir
+    (255, 0, 0),  # Rouge
+    (0, 255, 0),  # Vert
+    (255, 255, 0),  # Jaune
+    (0, 0, 255),  # Bleu
+    (255, 0, 255),  # Magenta
+    (0, 255, 255),  # Cyan
+    (255, 255, 255)  # Blanc
+]
+
+pixel_to_g1_code = {
+    "000000": "20", "100000": "21", "010000": "22", "110000": "23",
+    "001000": "24", "101000": "25", "011000": "26", "111000": "27",
+    "000100": "28", "100100": "29", "010100": "2A", "110100": "2B",
+    "001100": "2C", "101100": "2D", "011100": "2E", "111100": "2F",
+    "000010": "30", "100010": "31", "010010": "32", "110010": "33",
+    "001010": "34", "101010": "35", "011010": "36", "111010": "37",
+    "000110": "38", "100110": "39", "010110": "3A", "110110": "3B",
+    "001110": "3C", "101110": "3D", "011110": "3E", "111110": "3F",
+    "000001": "60", "100001": "61", "010001": "62", "110001": "63",
+    "001001": "64", "101001": "65", "011001": "66", "111001": "67",
+    "000101": "68", "100101": "69", "010101": "6A", "110101": "6B",
+    "001101": "6C", "101101": "6D", "011101": "6E", "111101": "6F",
+    "000011": "70", "100011": "71", "010011": "72", "110011": "73",
+    "001011": "74", "101011": "75", "011011": "76", "111011": "77",
+    "000111": "78", "100111": "79", "010111": "7A", "110111": "7B",
+    "001111": "7C", "101111": "7D", "011111": "7E", "111111": "7F"
+}
+
+color_codes = {
+    (0, 0, 0):       ("1B40", "1B50"),
+    (255, 0, 0):     ("1B41", "1B51"),
+    (0, 255, 0):     ("1B42", "1B52"),
+    (255, 255, 0):   ("1B43", "1B53"),
+    (0, 0, 255):     ("1B44", "1B54"),
+    (255, 0, 255):   ("1B45", "1B55"),
+    (0, 255, 255):   ("1B46", "1B56"),
+    (255, 255, 255): ("1B47", "1B57")
+}
+
+
+minitel_color_names = {
+    "Black": (0, 0, 0),
+    "Red": (255, 0, 0),
+    "Green": (0, 255, 0),
+    "Yellow": (255, 255, 0),
+    "Blue": (0, 0, 255),
+    "Magenta": (255, 0, 255),
+    "Cyan": (0, 255, 255),
+    "White": (255, 255, 255)
+}
+
+class MinitelImage(MinitelController):
+
+    def _convert_image_to_minitel_palette(self, image):
+        image = image.convert("RGB")
+        pixels = image.load()
+        for y in range(image.height):
+            for x in range(image.width):
+                original_color = pixels[x, y]
+                closest_color = min(minitel_palette,
+                                    key=lambda color: sum((color[i] - original_color[i]) ** 2 for i in range(3)))
+                pixels[x, y] = closest_color
+        return image
+
+    def _get_preview_image(self, filepath, mode="resize", bg_color=(0, 0, 0)):
+        image = Image.open(filepath)
+        image = image.convert("RGB")
+        target_width, target_height = 80, 72
+
+        if mode == "resize":
+            image = image.resize((target_width, target_height), Image.LANCZOS)
+        elif mode == "center":
+            iw, ih = image.size
+            if iw > target_width or ih > target_height:
+                scale_factor = min(target_width / iw, target_height / ih)
+                new_width = int(iw * scale_factor)
+                new_height = int(ih * scale_factor)
+                image = image.resize((new_width, new_height), Image.LANCZOS)
+                iw, ih = image.size
+            new_img = Image.new("RGB", (target_width, target_height), bg_color)
+            left = (target_width - iw) // 2
+            top = (target_height - ih) // 2
+            new_img.paste(image, (left, top))
+            image = new_img
+
+        image = self._convert_image_to_minitel_palette(image)
+        return image
+
+    def _image_to_g1_row(self, filepath, mode="resize", bg_color=(0, 0, 0)):
+        image = self._get_preview_image(filepath, mode, bg_color)
+        mosaic_hex_list = []
+        mosaic_hex = ""
+        target_width, target_height = 80, 72
+        for y in range(0, target_height, 3):
+            for x in range(0, target_width, 2):
+                block_pixels = [
+                    image.getpixel((x, y)),
+                    image.getpixel((x + 1, y)),
+                    image.getpixel((x, y + 1)),
+                    image.getpixel((x + 1, y + 1)),
+                    image.getpixel((x, y + 2)),
+                    image.getpixel((x + 1, y + 2))
+                ]
+                color_count = {}
+                for pixel in block_pixels:
+                    color_count[pixel] = color_count.get(pixel, 0) + 1
+                sorted_colors = sorted(color_count.items(), key=lambda item: item[1], reverse=True)
+                bg, fg = sorted_colors[0][0], (sorted_colors[1][0] if len(sorted_colors) > 1 else (255, 255, 255))
+                if bg == fg:
+                    fg = (0, 0, 0) if bg != (0, 0, 0) else (255, 255, 255)
+                binary_string = ''.join(['1' if pixel == fg else '0' for pixel in block_pixels])
+                g1_code = pixel_to_g1_code.get(binary_string, "7F")
+                cell = color_codes[bg][1] + color_codes[fg][0] + g1_code
+                mosaic_hex += cell
+            mosaic_hex_list.append(mosaic_hex)
+            mosaic_hex = ""
+        return mosaic_hex_list
+
+    def _image_to_g1(self, filepath, mode="resize", bg_color=(0, 0, 0)):
+        image = self._get_preview_image(filepath, mode, bg_color)
+        mosaic_hex = ""
+        target_width, target_height = 80, 72
+        for y in range(0, target_height, 3):
+            for x in range(0, target_width, 2):
+                block_pixels = [
+                    image.getpixel((x, y)),
+                    image.getpixel((x + 1, y)),
+                    image.getpixel((x, y + 1)),
+                    image.getpixel((x + 1, y + 1)),
+                    image.getpixel((x, y + 2)),
+                    image.getpixel((x + 1, y + 2))
+                ]
+                color_count = {}
+                for pixel in block_pixels:
+                    color_count[pixel] = color_count.get(pixel, 0) + 1
+                sorted_colors = sorted(color_count.items(), key=lambda item: item[1], reverse=True)
+                bg, fg = sorted_colors[0][0], (sorted_colors[1][0] if len(sorted_colors) > 1 else (255, 255, 255))
+                if bg == fg:
+                    fg = (0, 0, 0) if bg != (0, 0, 0) else (255, 255, 255)
+                binary_string = ''.join(['1' if pixel == fg else '0' for pixel in block_pixels])
+                g1_code = pixel_to_g1_code.get(binary_string, "7F")
+                cell = color_codes[bg][1] + color_codes[fg][0] + g1_code
+                mosaic_hex += cell
+        return mosaic_hex
+
+    def display_image(self, filepath: str, mode="resize", bg_color=(0, 0, 0)) -> None:
+        """
+        Display image
+        :param filepath: path to image
+        :param mode: center or resize
+        :param bg_color: background color (default is black)
+        """
+
+        self._write_byte(b'\x1B\x3B\x60\x58\x52')
+        self.cursor_off()
+        self.clear_screen()
+        self.switch_to_g1()
+        self._write_byte(b'\x1B\x3A\x6A\x43')
+
+        bg_color = minitel_color_names.get(bg_color, (0, 0, 0)) if mode == "center" else (0, 0, 0)
+
+        mosaic_hex = self._image_to_g1(filepath, mode, bg_color)
+        data_bytes = bytes.fromhex(mosaic_hex)
+        self._write_byte(data_bytes)
+
+
+    def show_image_buggy(self, filepath: str, mode="resize", bg_color=(0, 0, 0)):
+        """
+        Display image in a buggy way (will animate forever)
+        :param filepath: path to image
+        :param mode: center or resize
+        :param bg_color: background color (default is black)
+        """
+
+        self._write_byte(b'\x1B\x3B\x60\x58\x52')
+        self.cursor_off()
+        self.clear_screen()
+        self.switch_to_g1()
+        self._write_byte(b'\x1B\x3A\x6A\x43')
+
+        bg_color = minitel_color_names.get(bg_color, (0, 0, 0)) if mode == "center" else (0, 0, 0)
+
+        mosaic_hex = self._image_to_g1_row(filepath, mode, bg_color)
+        data_bytes = [bytes.fromhex(mosaic) for mosaic in mosaic_hex]
+        for line in data_bytes:
+            self._write_byte(line)
+
+        queue = []
+
+        empty = b'\x1bP\x1bG '
+
+        while True:
+            if len(queue) < 20:
+                x_max_length = 12
+
+                y = pseudo_random(2, len(data_bytes) - 2)
+                x_start = pseudo_random(5, 40 - x_max_length)
+                x_length = pseudo_random(4, x_max_length, 2)
+
+                offset = pseudo_random(0, x_length, 3)
+
+                glitch_instruction = (1+x_start, 1+y, y, 5*(x_start + offset), 5*(x_start+x_length), offset)
+                display_instruction = (1+x_start, 1+y, y, 5*(x_start), 5*(x_start+x_length), 0)
+
+                index = pseudo_random(min(len(queue), 5), len(queue))
+                index2 = pseudo_random(index, len(queue))
+                queue.insert(index, glitch_instruction)
+                queue.insert(index2+1, display_instruction)
+
+            dequeue_count = 0
+
+            if len(queue) > 4:
+                dequeue_count = 1
+            if len(queue) > 10:
+                dequeue_count = 4
+
+            for dequeue in range(dequeue_count):
+                x, y, line, fromByte, toByte, offset = queue.pop(0)
+                self.cursorMove(x, y)
+                for i in range(offset):
+                    self._write_byte(empty)
+                self._write_byte(data_bytes[line][fromByte:toByte])

miniminitel-1.0.3/src/miniminitel/minitel_videotex.py

@@ -0,0 +1,75 @@
+from .C0 import LF, VT, BS, TAB, CR, RS, FF, US, CAN, BEL, ESC
+from .minitelinterfacing import MinitelInterfacing
+
+class MinitelVideotex(MinitelInterfacing):
+    """
+    Basic Minitel Videotex commands
+    """
+
+    def write(self, text: str):
+        self._write_byte(bytes(text, encoding="ascii"))
+
+    def shift_cursor_down(self):
+        """
+        Move cursor down one time
+        """
+        self._write_byte(LF)
+
+    def shift_cursor_up(self):
+        """
+        Move cursor right one time
+        """
+        self._write_byte(VT)
+
+    def shift_cursor_left(self):
+        """
+        Move cursor left one time
+        """
+        self._write_byte(BS)
+
+    def shift_cursor_right(self):
+        """
+        Move cursor left one time
+        """
+        self._write_byte(TAB)
+
+    def cariage_return(self):
+        """
+        Move cursor to start of the line (sometimes called Origin)
+        """
+        self._write_byte(CR)
+
+    def return_to_top_left(self):
+        """
+        (also called RS) Move cursor to start of first row. Explicit article separator
+        """
+        self._write_byte(RS)
+
+    def explicit_article_separator(self):
+        """
+        (also called US) Explicit article separator
+        """
+        self._write_byte(US)
+
+    def complete_to_end_of_line(self):
+        """
+        (also called CAN) Write spaces from cursor to end of line (doesn't move cursor)
+        """
+        self._write_byte(CAN)
+
+    def clear(self): # Clear screen, go to top left, reset attributes
+        self._write_byte(FF)
+
+    def ring_bel(self) -> None:
+        """
+        Do a quick sound
+        """
+        self._write_byte(BEL)
+
+    def ask_cursor_pos(self):
+        """
+        Ask current cursor position
+        """
+        self._write_byte(ESC)
+        self._write_byte(b'\x61')
+        # TODO : listen to anwser

miniminitel-1.0.3/src/miniminitel/minitel_videotex_attributes.py

@@ -0,0 +1,68 @@
+from .C0 import ESC
+from .C1 import DOUBLE_HAUTEUR, DOUBLE_GRANDEUR, DOUBLE_LARGEUR, GRANDEUR_NORMALE, CLIGNOTEMENT, FIXE, FOND_INVERSE, \
+    FOND_NORMAL
+from .minitel_csi import MinitelCSI
+
+
+class MinitelVideotexAttributes(MinitelCSI):
+    """
+    Minitel Videotex attributes
+    """
+
+    def _set_attribute(self, attribute) -> None:
+        """
+        Set attribute
+        :param attribute: C1 attribute
+        """
+        self._write_byte(ESC)
+        self._write_byte(attribute)
+        if attribute == DOUBLE_HAUTEUR or attribute == DOUBLE_GRANDEUR:
+            self.move_cursor_down()
+
+    def set_grandeur_normale(self) -> None:
+        """
+        Switch to normal-sized characters
+        """
+        self._set_attribute(GRANDEUR_NORMALE)
+
+    def set_double_hauteur(self) -> None:
+        """
+        Switch to double row characters
+        """
+        self._set_attribute(DOUBLE_HAUTEUR)
+
+    def set_double_largeur(self) -> None:
+        """
+        Switch to double column characters
+        """
+        self._set_attribute(DOUBLE_LARGEUR)
+
+    def set_double_grandeur(self) -> None:
+        """
+        Switch to double row and column characters
+        """
+        self._set_attribute(DOUBLE_GRANDEUR)
+
+    def set_blinking(self) -> None:
+        """
+        Switch to blinking characters
+        """
+        self._set_attribute(CLIGNOTEMENT)
+
+    def set_non_blinking(self) -> None:
+        """
+        Revert to non-blinking characters
+        """
+        self._set_attribute(FIXE)
+
+    def set_inverted_color(self) -> None:
+        """
+        Switch to inverted color characters
+        """
+        self._set_attribute(FOND_INVERSE)
+
+    def set_non_inverted_color(self) -> None:
+        """
+        Revert to non-inverted color characters
+        """
+        self._set_attribute(FOND_NORMAL)

miniminitel-1.0.3/src/miniminitel/minitelinterfacing.py

@@ -0,0 +1,91 @@
+from .C0 import ESC, Con, Coff, SO, SI
+from .serial_connection import SerialConnection
+
+MODE_TELETEL_VIDEOTEX = 0 # Teletel Videotex mode, default when booting Minitel. Use 40 columns display
+MODE_TELETEL_MIXTE = 1 # Teletel Mixte mode, can be prompted by the server. Use 80 columns display
+MODE_TELEINFORMATIQUE = 2 # Ascii mode, can be prompted by the server or user (Fnct + T then A). Use 80 columns display
+
+class MinitelInterfacing(SerialConnection):
+    """
+    Basic Minitel interface
+    """
+
+    mode = MODE_TELETEL_VIDEOTEX
+
+    def _write_csi(self):
+        """
+        Send Command Sequence Introducer code, commonly used for prompting command
+        :return:
+        """
+        self._write_byte(ESC)
+        self._write_byte(b'\x5B')
+
+    def _videotex_to_mixte(self):
+        """
+        Switch from VideoTex to Mixte
+        """
+        self._write_byte(ESC)
+        self._write_byte(b'\x3A')
+        self._write_byte(b'\x32')
+        self._write_byte(b'\x7D')
+        # Expect to receive \x13 \x70 ?
+        self.mode = MODE_TELETEL_MIXTE
+
+    def _mixte_to_videotex(self):
+        """
+        Switch from Mixte to VideoTex
+        """
+        self._write_byte(ESC)
+        self._write_byte(b'\x3A')
+        self._write_byte(b'\x32')
+        self._write_byte(b'\x7E')
+        # Expect to receive \x13 \x71 ?
+        self.mode = MODE_TELETEL_VIDEOTEX
+
+    def _teletel_to_teleinformatique(self):
+        """
+        Switch from Teletel (Mixte or VideoTex?) to Teleinformatique
+        Can be done by user with Fnct + T then A (or then F for French ASCII)
+        """
+        self._write_byte(ESC)
+        self._write_byte(b'\x3A')
+        self._write_byte(b'\x31')
+        self._write_byte(b'\x7D')
+        # Expect to receive \x1B \x5B \x3F \x7A ?
+        self.mode = MODE_TELEINFORMATIQUE
+
+    def _teleinformatique_to_videotex(self):
+        """
+        Switch from Teleinformatique to VideoTex
+        Can be done by user with Fnct + T then V
+        """
+        self._write_byte(ESC)
+        self._write_byte(b'\x5B')
+        self._write_byte(b'\x3F')
+        self._write_byte(b'\x7B')
+        # Expect to receive \x13 \x5E ?
+        self.mode = MODE_TELETEL_VIDEOTEX
+
+    def cursor_on(self):
+        """
+        Display cursor
+        """
+        self._write_byte(Con)
+
+    def cursor_off(self):
+        """
+        Hide cursor
+        """
+        self._write_byte(Coff)
+
+    def switch_to_g1(self): # Display images
+        """
+        Switch to G1 character table (used for semi graphic display)
+        """
+        self._write_byte(SO)
+
+    def revert_to_g0(self): # Revert to standard alphanum characters
+        """
+        Revert to G0 character table (alphanumeric character table)
+        """
+        self._write_byte(SI)

miniminitel-1.0.3/src/miniminitel/serial_connection.py

@@ -0,0 +1,30 @@
+import serial
+
+class SerialConnection:
+    """
+    Raw SerialConnection interface
+    """
+
+    def __init__(self, port: str = '/dev/ttyUSB0', baudrate=4800):
+        self.ser = serial.Serial(port, baudrate=baudrate, bytesize=7, parity=serial.PARITY_EVEN, stopbits=serial.STOPBITS_ONE)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.ser.close()
+
+    def _write_byte(self, byte: bytes):
+        """
+        Send byte over serial connection
+        :param byte: Bytes to send
+        """
+        self.ser.write(byte)
+
+
+    def _write_bytes_p(self, n: int):
+        if n <= 9:
+            self._write_byte((0x30 + n).to_bytes(1, "big"))
+        else :
+            self._write_byte((0x30 + (n // 10)).to_bytes(1, "big"))
+            self._write_byte((0x30 + (n % 10)).to_bytes(1, "big"))

miniminitel-1.0.3/src/miniminitel.egg-info/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: miniminitel
+Version: 1.0.3
+Summary: Simple Minitel interface in Python
+Author: Portevent
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/Portevent/MiniMinitel
+Project-URL: Issues, https://github.com/Portevent/MiniMinitel/issues
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pillow
+Requires-Dist: pyserial
+
+# MiniMinitel
+MiniMinitel is a simple Minitel interface in python. It has been created with the help of :
+- http://543210.free.fr/TV/stum1b.pdf
+- https://wiki-ima.plil.fr/mediawiki/images/b/b1/Minitel.pdf
+- https://github.com/eserandour/Minitel1B_Hard
+
+```python
+from miniminitel import MiniMinitel
+
+with MiniMinitel("COM4") as minitel:
+    minitel.clear()
+    
+    minitel.cursor_move_to(4, 4)
+    minitel.write_double_grandeur("Hello world")
+
+    minitel.write_at(6, 6, "I'm a MiniMinitel")
+    minitel.set_blinking()
+    minitel.write_at(6, 7, "And I look cool")
+    minitel.set_non_blinking()
+
+```
+
+# Setup
+## Python
+MiniMinitel is a work in progress, no version are published to PyPI yet.  
+Library is written with Python 3.10, no support for other version are guaranteed (should be compatible Python 3.11+)
+```commandline
+pip install miniminitel
+```
+
+## Minitel
+Minitel need to be pluggged to computer throught serial port. Documentation need to be written 

miniminitel-1.0.3/src/miniminitel.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+src/miniminitel/C0.py
+src/miniminitel/C1.py
+src/miniminitel/__init__.py
+src/miniminitel/miniminitel.py
+src/miniminitel/minitel_controller.py
+src/miniminitel/minitel_csi.py
+src/miniminitel/minitel_dialog_code.py
+src/miniminitel/minitel_image.py
+src/miniminitel/minitel_videotex.py
+src/miniminitel/minitel_videotex_attributes.py
+src/miniminitel/minitelinterfacing.py
+src/miniminitel/serial_connection.py
+src/miniminitel.egg-info/PKG-INFO
+src/miniminitel.egg-info/SOURCES.txt
+src/miniminitel.egg-info/dependency_links.txt
+src/miniminitel.egg-info/requires.txt
+src/miniminitel.egg-info/top_level.txt

miniminitel-1.0.3/src/miniminitel.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

miniminitel-1.0.3/src/miniminitel.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pillow
+pyserial

miniminitel-1.0.3/src/miniminitel.egg-info/top_level.txt

@@ -0,0 +1 @@
+miniminitel