Skip to content

Example Class

Angeheftet Python3
  • Ich habe ja hier im Beitrag schon mal versucht zu erklären, wie man Daten in Python lädt und speichert. Als Beispiel dient mir meine BackupList. So lege ich das in meinen beiden Python Projekten meines Restic UI ab.

    Anhand dieses Beispieles habe ich mal eine Klasse gebaut, die das alles enthält. So in etwa ist das auch in meinen Projekten drin, da ich aber Zweifel habe das ich dort alles richtig gemacht habe, hier diese Basisarbeit. Soll auch mir die Grundlagen näher bringen.

    Für Profis, die hier mitlesen, ich freue mich über Verbesserungen und ich mache bestimmt auch einiges falsch. Also ran, einfach hier drunter kommentieren.

    Example Class

    Die Klasse beinhaltet die folgenden Funktionen.

    • Add

    • Update

    • Delete

    • Save JSON

    • Load JSON

    • Keys & Last Key

         import json
         
         
         class BackupList():
             """ Class for managing my backup data. Here only as a sample.
                 Functions Add, Update, Delete, Save JSON, Load JSON and Keys, Last Key implemented.
             """
         
             def __init__(self, name, repository):
                 # instantiate an empty dict
                 self.name = name
                 self.repository = repository
         
             @staticmethod
             def add(name, repository):
                 # Add an object
                 print("ADD", name, repository)
                 backups[(BackupList.last_key()) + 1] = BackupList(name, repository)
         
             @staticmethod
             def update(counter, name, repository):
             # Update an object
                 try:
                     backups[counter].name = name
                     backups[counter].repository = repository
                     backups.update()
                 except IOError:
                     print("Error")
         
             @staticmethod
             def delete(number):
                 # Delete an object
                 backups.pop(number)
         
             @staticmethod
             def keys():
                 # Create keys list
                 keys_list = []
         
                 # redo keys_list
                 for key in backups:
                     keys_list.append(key)
         
                 print("Keys:", keys_list)
         
             @staticmethod
             def save_json():
                 # Save my class as JSON
                 backups_json = {}
                 for count, value in enumerate(backups):
                     print("Save", backups[value].name)
                     backups_json[value] = {'name': backups[value].name, 'repository': backups[value].repository}
         
                 # save backups to JSON
                 with open('mydata.json', 'w') as f:
                     json.dump(backups_json, f)
         
             @staticmethod
             def load_json():
                 # load JSON
                 with (open('mydata.json', 'r')) as f:
                     backups_reload = json.load(f)
         
                 # Create objects for my class
                 for count, value in enumerate(backups_reload.values()):
                     print("Reload", value['name'], "Counter:", count)
                     backups[count] = BackupList(value['name'], value['repository'])
         
             @staticmethod
             def last_key():
                 # Create last key
                 last_key = list(dict.keys(backups))[-1]
                 return last_key
         
         
         # create an empty dict
         backups = {}
         
         # Load data from filesystem
         BackupList.load_json()
         
         
         def main():
             # Add an entry
             #BackupList.add('Test02', '/home/frankm/repo2')
             #BackupList.add('Test03', '/home/frankm/repo3')
             #BackupList.add('Test04', '/home/frankm/repo4')
         
             # Print some data
             #print(backups[0].name)
             #print(backups[1].name)
         
             # Del an entry
             #BackupList.delete(1)
         
             print ('-------------')
         
             # Print keys
             BackupList.keys()
         
             print ('-------------')
         
             # Save data as JSON file
             BackupList.save_json()
         
             print ('-------------')
         
             # Uncomment to update entry backups[4]
             #BackupList.update(4, "TESTING6", "REPO")
             # After update we must save the data
             #BackupList.save_json()
         
             print ('-------------')
         
             # Print data from backups
             for count, value in enumerate(backups):
                 print("Control", count, backups[value].name)
         
         
         
         if __name__ == "__main__":
             main()
      

    Ich hoffe es hilft dem ein oder anderen Einsteiger in das Thema JSON und Daten dauerhaft speichern.

    Den Beispielcode findet ihr -> https://gitlab.com/-/snippets/2438459

  • FrankMF FrankM hat am auf dieses Thema verwiesen
  • Aufgrund diverser Code Stellen in meinen beiden Projekten, die etwas wirr aussahen, habe ich ja obige Grundlagenarbeit gemacht gehabt.

    Am Wochenende habe ich dann das Erlernte in die Tat umgesetzt und mein PyWebIO Projekt vollständig umgebaut. Dabei konnte ich viel Code eliminieren und es wesentlich übersichtlicher gestalten.

    Dabei lernt man dann auch immer wieder eine Menge dazu und so entstand meine erste Funktion mit **kwargs 🙂

    @staticmethod
        def update(counter, **kwargs):
    

    Wer was im Code wühlen möchte, findet das Repo zu meinem Restic UI auf Basis von PyWebIO hier.

    Da die Funktionen jetzt alle drin sind und hoffentlich auch alle funktionieren, mach ich mal die Tage wieder ein Video. Dabei finde ich immer die meisten Fehler 😁

  • FrankMF FrankM hat dieses Thema am angepinnt
  • In meinem PywebIO Projekt tauchte heute ein alter Bekannter auf. Wenn ich einen Eintrag (innerhalb der Liste) löschte, war das etwas durcheinander 🤔

    Ja, den Fehler kenne ich schon was länger und stolper immer mal wieder drüber. Heute z.B.

    Also mal grübeln 🤓

    Das mache ich, wenn ich einen Eintrag lösche

    case 'Yes':
       # delete entrie
       BackupList.delete((line - 1))
    
       # save json
       BackupList.save_json()
     
       # Load data from filesystem
       BackupList.load_json()
    
       # Reload Tab Backup
       backup()
    

    Ich mache folgendes

    • lösche den Eintrag
    • speicher die Liste
    • lade die Liste
    • baue den Tab wieder auf

    Das führt aber dazu, das meine Liste die als Objekt im Speicher steht nicht aktuell ist. Im Gegenteil, da ist dann etwas Unordnung. Ich brauchte also die Möglichkeit mein Objekt backups irgendwie zurückzusetzen.

    Mal gegoogelt und die Dinge sind manchmal wirklich total easy 🙂

    # clear dict
    backups.clear()
    

    Das leert das Objekt und im nächsten Schritt kann ich es wieder befüllen.

    Lösung

    case 'Yes':
       # delete entrie
       BackupList.delete((line - 1))
    
       # save json
       BackupList.save_json()
     
       # clear dict
       backups.clear()
       
       # Load data from filesystem
       BackupList.load_json()
    
       # Reload Tab Backup
       backup()
    

    Problem erledigt. Damit ich das noch finde, wenn mein Kopf das nicht mehr hergibt, notiere ich das hier.

  • 0 Stimmen
    5 Beiträge
    128 Aufrufe
    FrankMF

    Hab ChatGPT nochmal nach der Installation auf einem Production Server befragt.

    ChatGPT

    Certainly! Here's a short example of the steps you can follow to deploy a Flask application on a production server using Nginx and Gunicorn:

    Prepare your server:

    Set up a server (e.g., using a cloud provider like AWS, DigitalOcean, or a dedicated server) and ensure it has a clean, up-to-date installation of a Linux distribution (e.g., Ubuntu or CentOS).

    Install required software:

    Install necessary software packages on your server. You'll need Python, pip (Python package manager), Nginx, and Gunicorn. You can use your distribution's package manager (e.g., apt for Ubuntu or yum for CentOS) to install these dependencies.

    Deploy your Flask application:

    Copy your Flask application code and any required dependencies to your server.

    Set up a virtual environment (optional but recommended):

    Create a virtual environment for your Flask application to isolate its dependencies. You can use venv or virtualenv for this purpose.

    Install Flask and any required Python packages within your virtual environment:

    pip install flask

    Test your Flask application:

    Ensure your Flask application runs correctly within your server's virtual environment.

    Configure Gunicorn:

    Create a Gunicorn configuration file (e.g., gunicorn_config.py) to specify the settings for running your Flask application. Here's a simple example: workers = 4 # Number of Gunicorn worker processes bind = '0.0.0.0:8000' # The address and port Gunicorn should listen on

    Start Gunicorn:

    Start Gunicorn with your Flask application: gunicorn -c gunicorn_config.py your_app:app

    Configure Nginx:

    Create an Nginx server block (often located in /etc/nginx/sites-available) to define how Nginx should handle incoming requests. Here's a simplified example: server { listen 80; server_name your_domain.com www.your_domain.com; location / { proxy_pass http://127.0.0.1:8000; # Pass requests to Gunicorn proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; } }

    Enable the Nginx server block and restart Nginx:

    sudo ln -s /etc/nginx/sites-available/your_config /etc/nginx/sites-enabled/ sudo nginx -t # Test Nginx configuration sudo systemctl restart nginx

    Configure your DNS:

    Point your domain name to your server's IP address.

    Secure your server (optional but recommended):

    Set up SSL/TLS certificates for your domain to enable HTTPS. You can use Let's Encrypt for free SSL certificates.

    Monitor your application:

    Set up monitoring tools and logs to keep track of your application's performance and troubleshoot any issues.

    These are the basic steps to deploy a Flask application on a production server with Nginx and Gunicorn. Please note that this is a simplified example, and there are many additional considerations, such as database configuration, security, and optimization, depending on your specific application and requirements. It's also important to keep your server and software up to date and follow security best practices to ensure the stability and security of your production environment.

    Das werde ich doch mal ausprobieren 😎

  • Pycharm - Umzug auf neuen Rechner

    Linux
    1
    0 Stimmen
    1 Beiträge
    52 Aufrufe
    Niemand hat geantwortet
  • Python & Redis-Datenbank

    Verschoben Linux
    3
    0 Stimmen
    3 Beiträge
    94 Aufrufe
    FrankMF

    Heute dann die nächste Herausforderung. Mein JSON soll so aussehen, damit ich das entsprechend erweitern kann.

    Stocks {0: {'stockname': 'Deutsche Telekom Aktie', 'wkn1': '4534543534', 'wkn2': 'sfsdfsdfsfdfd', 'quantity': 100}, 1: {'stockname': 'Henkel', 'wkn1': '4534543534', 'wkn2': 'sfsdfsdfsfdfd', 'quantity': 50}}

    Die Daten sollen wie oben schon ausprobiert, in einer Redis Datenbank liegen. So weit auch kein großes Problem. ABER, der Zugriff auf diese Daten war dann meine nächste Hürde 🙂

    Ok, ich habe also mehrere Einträge im JSON File bzw. in der Datenbank. Wie komme ich da nun wieder dran. Ein paar ☕ später dann die Lösung.

    Wie komme ich an den einzelnen Eintrag, also über den Index??

    r1.json().get('stocks', 1)

    Gibt als Ergebnis

    {'stockname': 'Henkel', 'wkn1': '4534543534', 'wkn2': 'sfsdfsdfsfdfd', 'quantity': 50}

    Ok, das passt schon mal. Somit kann man dann gewohnt auf die einzelnen Elemente zugreifen.

    print("TESTING", testing['stockname'])

    Ausgabe

    TESTING Henkel

    Ok, Teil 1 erledigt. Jetzt habe ich ja irgendwann mehrere Elemente in der Liste und brauch dann den letzten Index , um damit was machen zu können. Also, z.B. durch die Daten zu loopen.

    objkeys = r1.json().objkeys('stocks') print("Objkeys", objkeys)

    Ausgabe

    Objkeys ['0', '1']

    Ok, kommt eine Liste des Index zurück. Damit kann man arbeiten 😉

    Ich hatte dann zum Testen mittels einer while Schleife die Daten geladen, aber jetzt beim Tippen klingelt es und wir machen das schön mit enumerate 😉

    @staticmethod def load(): data = {} for count, value in enumerate(objkeys): testing = r1.json().get('stocks', count) data[count] = { "stockname": testing['stockname'], "wkn1": testing['wkn1'], "wkn2": testing['wkn2'], "quantity": testing['quantity']} return data

    Somit habe ich die Daten aus der Redis Datenbank in einem Objekt und kann damit arbeiten.

  • Restic UI - Stand Januar 2023

    PyWebIO
    1
    0 Stimmen
    1 Beiträge
    100 Aufrufe
    Niemand hat geantwortet
  • List comprehensions

    Python3
    1
    0 Stimmen
    1 Beiträge
    54 Aufrufe
    Niemand hat geantwortet
  • Python - Match-Case Statement

    Python3
    1
    0 Stimmen
    1 Beiträge
    82 Aufrufe
    Niemand hat geantwortet
  • Qt 5 Designer

    Python3
    1
    0 Stimmen
    1 Beiträge
    92 Aufrufe
    Niemand hat geantwortet
  • PyQt6 - QSettings

    Python3
    3
    0 Stimmen
    3 Beiträge
    205 Aufrufe
    FrankMF
    Möglichkeit 1

    Das hier

    settings = QSettings("Frank_Mankel", "Restic_UI")

    erzeugt unter

    /home/frank/.config/Frank_Mankel/Restic_UI.conf

    die Konfigurationsdatei.

    Möglichkeit 2

    Das hier

    settings = QSettings("Restic_UI")

    erzeugt unter

    /home/frank/.config/Restic_UI.conf

    die Konfigurationsdatei.

    Damit habe ich die grundlegenden Dinge, hoffentlich 😉 , verstanden.

    Für den Rest mal in die Dokumentation schauen.

    Sehr hilfreich war auch mal ein Blick auf die Definition der Klasse. Rechtsklick auf QSettings und dann Go to Definition

    class QSettings(QObject): class Scope(enum.Enum): UserScope = ... # type: QSettings.Scope SystemScope = ... # type: QSettings.Scope class Format(enum.Enum): NativeFormat = ... # type: QSettings.Format IniFormat = ... # type: QSettings.Format InvalidFormat = ... # type: QSettings.Format class Status(enum.Enum): NoError = ... # type: QSettings.Status AccessError = ... # type: QSettings.Status FormatError = ... # type: QSettings.Status [..gekürzt..]