Beiträge von ClaudiaF

Datei kann ich nicht laden, ftp error 533 prohibited file name

Daher die Infos bezogen auf deine vorherige Version.

Du hattest da ein while True:
was letztendlich bedeutet: laufe IMMER die Schleife durch.

Gut das Kodi das Script in einem eigenen Thread startet, ansonsten würde,
wenn das Script im Mainloop Thread läuft, nichts mehr funktionieren ausser diesem Script.

Wenn nun Kodi gestoppt werden soll, informiert Kodi die laufenden Threads darüber, nur dein
Thread hat nichts anders zu tun als in der Schleife zu laufen. Früher oder später wird Kodi, den thread terminieren
aber das ist nicht wirklich die feine Art, oder?

Damit das Script nun die Möglichkeit hat sauber zu enden, müsstest Du also ein waitForAbort einsetzen damit deine while Schleife
abgebrochen werden kann. Siehe https://codedocs.xyz/xbmc/xbmc/grou…06abcda904e8249

In etwa

while not xbmc.Monitor().waitForAbort(2):
...

Damit wird für 2 Sekunden gewartet ob Kodi terminieren will, wenn nicht die Schleife weiter abarbeiten

Du kannst dein while True behalten, solltest aber wissen, dass wenn Du Dateien bearbeitest währendessen dir Kodi deinen Thread terminiert,
diese korrumpiert werden können. Also ich würde lieber waitForAbort nehmen.

Zum anderen Problem, höchstwahrscheinlich blockt der time.sleep(5) den ersten DisplayUpdate.
Evtl. mal xmbc.sleep probieren (siehe https://codedocs.xyz/xbmc/xbmc/grou…ec4a7a5a1073e7e),
vlt. blockiert das den Update nicht oder den Weg gehen, den ich vorher vorgeschlagen habe.
Vorsicht, xbmc.sleep nutzt msec also 2000 für 2 Sekunden angeben.

Cheers
Claudia

@tjost

um dich nun ganz zu verwirren , globale variablen haben natürlich ihre Existenzberechtigung,
aber wie schon BJ1 richtig sagt, sind sie nicht gern gesehen.

Wer sich aber mal in der Standardbibliothek umsieht, wird des öfteren darauf treffen.
Und wenn diese richtig eingesetzt werden, dann gibt es, aus meiner Sicht, keinen Grund sie zu meiden.

Meines Wissens sind globale Variablen in einem Modul der einzige sichere Weg um zum Beispiel eine Singleton-Klasse abzubilden.

Was aber ein NoGo ist, und da gebe ich wiederum BJ1 Recht, ist eine Variable in einer Funktion
als global zu definieren um diese dann modulweit bekanntzumachen.
Nein, dann sofort auf Modulebene defnieren.

Das ist aber für den Anfang, meiner Meinung nach, für dich noch nicht wirklich interessant.
Du solltest wissen das es die Unterschiede gibt damit Du weißt wie Du darauf reagieren kannst.

Cheers
Claudia

@DaVu - einmischen ist immer erlaubt, ist doch der Sinn eines Forums

Cheers
Claudia

Nein, Python erlaubt Dir auch Funktionen als Parameter zu nutzen aber diese müssen dann auch aufgerufen werden.

Bezüglich Funtion als Parameter einer Funktion folgendes Beispiel:

def a():
    print 'a'
    return 'a ist fertig'


def b(parameter=a):
    print 'b'
    print parameter()

Wenn Du nun die Funktion b aufrufst ohne einen Parameter zu übergeben also einfach mit

b(), die Klammern sorgen dafür das Python weiß dass dies eine aufrufbare Funktion ist,

dann bekommst Du als Ausgabe

b
a
a ist fertig

Wichtig ist hier die Zeile 7, parameter muß die Klammer haben damit der übergebene Parameter ausgeführt wird.
Wenn Du nun aber eine andere Funktion, wie z.B. anonyme Fuktionen aufrufen würdest z. B.

b(lambda:1+1)

dann würde die Ausgabe so aussehen

b
2

Zu deinem konkreten Fall, ich denke Du willst eine Funktion, die eigentlich so aussieht

def open_image_and_display(image_path):
    image = Image.open(image_path).resize((disp.width, disp.height), Image.ANTIALIAS).convert('1')
    disp.image(image)

Eine Funktion die als Parameter den Pfad zu einer Imagedatei erhält und dann dementsprechend ein Bild erzeugt und anzeigt.

Du kannst nun auch die Funktion so ändern, dass Du einen Defaultwerte dem Parameter image_path zuweist ala

def open_image_and_display(image_path='WOHIN_AUCH_IMMER'):
    image = Image.open(image_path).resize((disp.width, disp.height), Image.ANTIALIAS).convert('1')
    disp.image(image)

Dann würde immer dann wenn Du nur

open_image_and_display()

aufrufst der Pfad WOHIN_AUCH_IMMER genommen um die Bilddatei zu lesen,
ansonsten das was Du übergibst.

Eine Sache die im Zusammenahng mit Funktionen und Variablen wichtig ist,
Python kennt/nutzt das Konzept zu global und local Namespaces.
Das heisst, das es einen definiert Namensraum gibt in dem eine Variable gültig ist
und damit zugreifbar und änderbar ist.

Funktionen definieren ihren eigenen lokalen Namensraum.
Soll heissen, wenn Du eine Funktion hast die auf eine Variable zugreift die ausserhalb der Funktion
definiert wurde kannst Du nur lesend darauf zugreifen. Wenn Du innerhalb einer Funktion eine
Variable ändern willst die ausserhalb definiert wurde schlägt das fehl, ausser Du definierst vorher
dass die Variable aus dem global Namespace kommt, mit dem statement global.

Cheers
Claudia

@tjost

Dein Code ist schon eine Herausforderung

zu Problem 2.
füge

toggled_text = ''

vor dem while True: ein und innerhalb z.B.

elif window=="10502":

machst Du dann

toggled_text = "WOAS IS?" if toggled_text == "Music" else "Music"

und anstelle von "Music" gibst Du bei draw.text dann die Variable toggled_text an.

Damit würde mit jedem Durchlauf zwischen Music und WOAS IS? gewechselt.

Generell würde ich Dir empfehlen eine Funktion zu definieren, welche das aktuelle Bild erstellt und anzeigt.

Etwa wie

def create_and_display_image(top_text='test', bottom_text='test', top_font=font36, bottom_font=font28):
        draw.rectangle((0,0,width,height), outline=0, fill=0)
        w,h = draw.textsize(top_text, font=top_font)
        mid = (width-w)/2
        draw.text((mid, top), top_text, font=top_font, fill=255)
        w,h = draw.textsize(bottom_text, font=bottom_font)
        mid = (width-w)/2
        draw.text((mid, padding), bottom_text, font=bottom_font, fill=255)
        disp.image(image)

aufgerufen ohne Parameter werden die Standardwerte genommen. Ansonsten die die übergeben werden also in etwa

if PlayerisMovies==True:
    create_and_display_image(systemtime, videotime)

oder

elif PlayerisEpisodes==True:
    create_and_display_image("S:{} /E:{}".format(season, episode), videotime)

oder

elif window=="10016":
    create_and_display_image("System", "Settings", font32)

Wenn Du aber den top_font nicht übergeben willst, den bottom_font aber schon mußt du diesen benennen also

create_and_display_image("System", "Settings", bottom_font=font32)

damit python auch richtig zuordnen kann, sprich weiß, dass der übergebene dritte Parameter eigentlich der vierte ist.

Damit wären 90% deines redundanten Codes nicht mehr nötig.

Zu Problem 1,
ich habe mal in die Python Bibliothek von Adafruit geschaut und es sieht nicht aus als ob es eine interne Routine gibt, welche das
ein- und auslaufen eines Textes bewirkt. Das heisst Du hast aus meiner Sicht folgende Möglichkeiten.

1) Du könntest einen Thread erstellen, der diese Animation auf Anforderung erfüllt, nicht ganz trivial
2) Du könntest innerhalb deines while loops einen weiteren loop bauen der die Animation macht, durch den Timeout würde das aber wahrscheinlich unschön
3) Du überdenkst dein Konzept und versuchst das geforderte über Callbacks zu lösen (in wie weit alles über den Mechanismus zu lösen ist, vermag ich nicht zu sagen, hab ich nicht recherchiert.)

Deinen while True würde ich gegen einen waitForAbort tauschen, damit Kodi auch die Möglichkeit hat sauber zu stoppen.
Die pass statements sind überflüssig wenn Du Code im Block hast genauso wie die Funktionen innerhalb der Blöcke wenn sie
eh nur im Block einmalig .laufen

Die Doku zur Kodi API https://codedocs.xyz/xbmc/xbmc/group__python.html

Und fürs nächste mal, sei mir bitte nicht böse, den Code säubern, sprich ungenutztes entweder löschen und kommentieren,
damit machst Du es anderen leichter sich durchzuwurschteln.

So, das soll es für das erste gewesen sein.

Cheers
Claudia

Moanst Du hinterhalb?
Hintendran hoab I ned gefundn

Cheers
Claudia

@tjost

das braucht ein bisschen Zeit, langsam steige ich bei deinem Code durch.
Allerdings sind drei Sachen schon mal fragwürdig

1.)
Du ermittelst playerisplaying = xbmc.getCondVisibility("Player.HasMedia"),
laut Doku gibt die Funtion aber True (1) or False (0) as a bool zurück
Daher würde ich vermuten dass innerhalb deines while loops
entweder if playerisplaying==True: oder aber elif playerisplaying==False: ausgeführt wird, aber niemals else:

2.)
dadurch das Du fast alles innerhalb des while loops ausführst werden unter anderem
diese Zeilen

path = addon.getAddonInfo('path').decode('utf-8')
fullpath = os.path.join(path, 'icon/')
display = os.path.join(fullpath, thumb + suffix).decode('utf-8')
error = os.path.join(fullpath, "error" + suffix).decode('utf-8')
alternate = os.path.join(fullpath, 'error' + suffix)
menu = os.path.join(fullpath, 'menu' + suffix)
fontpath = os.path.join(fullpath, 'tiny' + suffix2)
font10 = ImageFont.truetype('/usr/share/fonts/liberation/LiberationSans-Regular.ttf', 10)
font18 = ImageFont.truetype('/usr/share/fonts/liberation/LiberationSans-Regular.ttf', 18)
font28 = ImageFont.truetype('/usr/share/fonts/liberation/LiberationSans-Regular.ttf', 28)
font30 = ImageFont.truetype('/usr/share/fonts/liberation/LiberationSans-Regular.ttf', 30)
font32 = ImageFont.truetype('/usr/share/fonts/liberation/LiberationSans-Regular.ttf', 32)
font36 = ImageFont.truetype('/usr/share/fonts/liberation/LiberationSans-Regular.ttf', 36)
font60 = ImageFont.truetype('/usr/share/fonts/liberation/LiberationSans-Regular.ttf', 60)

immer wieder ausgeführt, die sehen für mich aber so aus als ob die nur einmal beim
Start ermittelt werden müssten.

3.)
sys.setdefaultencoding('utf-8')

kann man machen, wenn man weiß was man tut.
In wie weit die Adafruit_SSD1306 Bibliothek da mitspielt mag ich nicht zu sage,da ich die Bibliothek
nicht benutze. Das gleiche gilt für alle anderen Bibliothek die Du per import einbindest.

Also immer ein Auge darauf haben.

Cheers

Claudia

Zur Info Link ist falsch

The requested URL /kodi/.repo/skin/_skin/script.silentservice.xbmc/http://mraap.de/kodi/.repo/skin/_skin/script.silentservice.xbmc/script.silentservice.xbmc-3.0.0.zip was not found on this server.
Additionally, a 404 Not Founderror was encountered while trying to use an ErrorDocument to handle the request.

Hab aber das zip auf dem Server gefunden - schaue es mir an und melde mich wieder.

Cheers
Claudia

Bei deinem 10 Zeilen Beispiel wird das erste draw.text vom zweiten draw.text überschrieben.
Entweder einen pause (time.sleep) dazwischen oder falls die vorher gesetzt ist über eine Variable
den Zustand ermitteln und dementsprechend setzen.

Ohne den kompletten Code ist schwerlich zu sagen was alles Einfluß hat.

Cheers
Claudia

1) in dem Du den Text immer um eine Stelle nach links oder rechts verschiebst
2) meinst Du etwas wie 2 Texte zu toggeln?
also etwa

Zeige Text Video wenn letzter Text Music war ansonsten zeige Text Music
oder suchst Du generell die Möglichkeit Text je nach Bedarf auszutauschen?

Beim ersten würdest Du den Text der anzuzeigen ist in einer Variable speichern und
dann beim nächsten Aufruf/Durchlauf ... abgleichen etwa

draw('Video' if last_message == 'Music' else 'Music)

Der 2te Fall wäre normalerweise mit einer Funktion zu lösen die dann den jweiligen Text schreibt.

Der Code ist nur zur Veranschaulichung, kann so nicht verwendet werden.

Cheers
Claudia

>Oh man... Ich muss endlich mein "Büro" erweitern, damit ich mehr zum Basteln komme

Du sagst es

Cheers
Claudia

Zitat von SkyBird1980

Und da ist der RPI eh raus... der Anschluss kann nur bis 100 Mbit und WLAN ist kein vernünftiges Medium zum Testen.

Ah, guter Einwand - das hatte ich schon wieder vergessen, könnte aber im Addon hintelegt werden
dass eine Warnung ausgegeben wird wenn das Netzwerkinterface nur 100Mbit hat.

Cheers
Claudia

@hh_jung
Vielen Danke für die Erklärungen. Bin ja auch ein Kabelkunde und hab das gleiche Problem, 400Mbit sollen es sein,
aber max. 160Mbit bekomme ich meisstens. Hab noch was dazu gefunden auf der breitbandmessung.de

https://breitbandmessung.de/fragen-und-antworten

Interessehalber schaue ich mal wie ein Addon das machen könnte.
Erste Idee,

- stündlich einen ping und einen download test (mit dem upload weiß ich noch nicht ...) auf vorher definierbare Server durchführen.
- protokollieren in einer CSV-Datei
- Report-Meldung, wie es momentan mit den Leistungen aussieht auf Anfrage
- ggf. Möglichkeit dieses als Mail zu verschicken

Weitere Ideen?

Das ganze hat dann leider wenig Aussagekraft gegenüber dem Provider, aber ein Ansatz ist erstmal da.

Cheers
Claudia

Hätte da drei Fragen:

> über Maßnahmen zum Zugangzum offenen Internet liegt nach Ansicht der Bundesnetzagentur bei FestnetzBreitbandanschlüssen2 im Download vor

Was bedeutet hier Zugang zum offenen Internet ? Hinweis auf eine amerikanische Lösung?

und bei den Messparametern

> Die Messungen sollen über die im Rahmen der Breitbandmessung bereitgestellte installierbareVersion durchgeführt werden.

Verstehe ich nicht, was wollen die?

>Darüber hinaus sollen die Empfehlungen der Bundesnetzagentur zur Durchführung der Messungenbeachtet werden.

Kennt jemand den offiziellen Link dazu?

Danke
Claudia

Mögliche Ansätze wenn nur 2 Profile benutzt werden.

1.)
Eines als default setzen unter Settings->Profiles

und das andere über das Skript starten wenn die Voraussetzungen geschaffen sind.

Wichtig ist nur, dass nur das Profile das default ist auch eine autoexec.py hat und eben in dieser nur das andere Profile geladen werden kann.

2. )
Über __file__ ermitteln welches autoexec.py gerade ausgeführt wird und dementsprechend handeln.

Cheers
Claudia

Durch das Laden des Profiles wird anscheinened die autoexec.py gestartet was dann natürlich
im Loop endet, da die autoexec wiederum das Profile lädt ...

Cheers
Claudia

Bin das Thema Batchverarbeitung noch einmal angegangen und habe es etwas geändert.
Ich hoffe die Kommentare und der Code sind ausreichend.

import xbmc
import xbmcgui
import xbmcvfs
import time
import os


USER_ADDON_DIRECTORY = xbmc.translatePath('special://userdata/addon_data')
LOG_DIRECTORY = os.path.join(USER_ADDON_DIRECTORY, __xbmcaddonid__)
LOG_FILE = 'kodi_user.[definition='1','0']log[/definition]'
FULL_LOG_FILE_PATH = os.path.join(LOG_DIRECTORY, LOG_FILE)


# settings - modify to your needs
MAXIMUM_WAIT_TIME = 60 # used for RunAddon calls
SLEEP_TIME = 5         # -"-
DIALOG_AUTO_CLOSE_TIME = 10


# -----------------------------------------------------------------------------
# logging function


def logger(msg, file=FULL_LOG_FILE_PATH):
    with open(file, 'a') as f:
        f.write('{} - {}\n'.format(time.ctime(), msg))




# -----------------------------------------------------------------------------
# subclass yesno dialog because we want True in case of autoclose


class _Dialog(xbmcgui.Dialog):


    def __init__(self):
        super(_Dialog,self).__init__()


    def yesno(self, heading='', line1='', line2='', line3='', autoclose=0):
        start = time.time()
        result = super(_Dialog, self).yesno(heading, line1, line2, line3, nolabel='abort', yeslabel='ok', autoclose=autoclose*1000)
        duration = (time.time() - start)
        return True if autoclose > 0 and duration >= autoclose else result


# -----------------------------------------------------------------------------
# some predefined exceptions


class BackupError(Exception):
    def __init__(self, _message):
        self.message = _message
    def __str__(self):
        return repr(self.message)


class PrerequisiteError(Exception):
    def __init__(self, _message):
        self.message = _message
    def __str__(self):
        return repr(self.message)


class TimeOutError(Exception):
    def __init__(self, _message):
        self.message = "{} didn't finish on time".format(_message)
    def __str__(self):
        return repr(self.message)
# -----------------------------------------------------------------------------
# subclass xbmc.Monitor in order to get callbacks executed


class _MONITOR(xbmc.Monitor):


    task_is_still_running = False
    task_event_waiting_for = ''
    rollback_needed = False
    error_is_set = False
    exception_object = None


    def __init__(self, _maximum_wait_time, _sleep_time):
        super(_MONITOR, self).__init__()
        self.maximum_wait_time = _maximum_wait_time*1000
        self.sleep_time = _sleep_time*1000




# -----------------------------------------------------------------------------
# callback
# it is needed to use either waitForAbort or xmbc.sleep in the
# main loop function of the class otherwise they won't get called ! ????


    def onNotification(self, sender, method, data):
        if (sender=='xbmc') and (self.task_event_waiting_for==method):
            self.task_is_still_running = False




# -----------------------------------------------------------------------------
# decorator used to init some variables, get the method which indicates finished
# and does logging for every task starting


    def mark_running(event_waiting_for=''):
        def wrapper(func):
            def function_call(self):
                self.task_is_still_running = True
                self.error_handler(reset=True)
                self.task_event_waiting_for = event_waiting_for
                logger('%s is running' % func.__name__)
                return func(self)
            return function_call
        return wrapper




# -----------------------------------------------------------------------------
# instead of try...except block errors should uses error_handler function
# to give the choice to continue if user decides


    def error_handler(self, _exception_object=None ,reset=False):
        self.error_is_set = False if reset else True
        self.exception_object = None if reset else _exception_object




# -----------------------------------------------------------------------------
# start of the batch tasks
# mark_running decorator does not get a finishing method means
# the function needs to handle task_is_still_running itself.


    @mark_running()
    def check_prerequisite(self):
        # simulate doing stuff
        # this could be things like checking if network is available, nas is on ...
        if _Dialog().yesno('Checking prerequisite','Please wait... Press abort to simulate error', autoclose=5):
            logger('check_prerequisite is ok')
        else:
            self.error_handler(PrerequisiteError('No network'))
        self.task_is_still_running = False




# -----------------------------------------------------------------------------


    @mark_running()
    def backup_library(self):
        # simulate doing stuff
        # in reality this isn't easy to solve as
        # a) there is no method/property which returns the database files in use and
        # b) KODI holds the databases open at runtime and in order
        #    to make a proper backup the database files needs to be closed
        # While using an KODI addon the only solution might be to do a sql dump
        if _Dialog().yesno('Backup database','Please wait... Press abort to simulate error', autoclose=3):
            logger('backup is ok')
        else:
            self.error_handler(BackupError('No space left on device'))
        self.task_is_still_running = False




# -----------------------------------------------------------------------------
# decorator gets the method means, onNotification checks if this method is
# called and sets task_is_still_running=False


    @mark_running('VideoLibrary.OnCleanFinished')
    def clean_library(self):
        xbmc.executebuiltin('CleanLibrary(video)')
        # self.task_is_still_running = False will be set by callback function onNotification




# -----------------------------------------------------------------------------


    @mark_running('VideoLibrary.OnScanFinished')
    def update_library(self):
        xbmc.executebuiltin('UpdateLibrary(video)')
        # self.task_is_still_running = False will be set by callback function onNotification




# -----------------------------------------------------------------------------


    @mark_running()
    def run_artwork_downloader(self):
        artwork_log = xbmc.translatePath('special://userdata/addon_data/script.artwork.downloader/downloadreport.txt')
        # remove old download report file if exists
        if xbmcvfs.exists(artwork_log):
            xbmcvfs.delete(artwork_log)


        maximum_wait_time_reached = False
        current_wait_time = 0
        xbmc.executebuiltin('RunAddon(script.artwork.downloader)')


        # now check if the file has been recreated, which indicates artwork downloader has finished its task.
        while not (xbmcvfs.exists(artwork_log) or maximum_wait_time_reached):
            xbmc.sleep(self.sleep_time)
            current_wait_time += self.sleep_time
            maximum_wait_time_reached = True if current_wait_time >= self.maximum_wait_time else False


        if maximum_wait_time_reached:
            self.error_handler(TimeOutError("RunAddon(script.artwork.downloader)"))


        self.task_is_still_running = False




# -----------------------------------------------------------------------------


    @mark_running('VideoLibrary.OnExport')
    def export_library(self):
        xbmc.executebuiltin('exportlibrary(video,true,thumbs=true,overwrite=false,actorthumbs=false)')
        # self.task_is_still_running = False will be set by callback function onNotification




# -----------------------------------------------------------------------------
# call each tasks in a generator function
# the yield does the magic, once executed it returns control back to
# the calling process which needs to call __next__ to get the next function executed.


    def batch_processing(self):
        self.check_prerequisite(); yield
        self.backup_library(); yield
        self.clean_library(); yield
        self.update_library(); yield
        self.run_artwork_downloader(); yield
        self.export_library(); yield




# -----------------------------------------------------------------------------
# revert changes
# in reality here goes the code to revert things changed


    def rollback(self):
        logger('start rolling back')




# -----------------------------------------------------------------------------
# entry point to start batch processing
# this should be the only place within the class which does try...except
# in order to provide some kind of continue functionality


    def start(self):
        logger('start batch processing')


        try:
            # this for loop is basically calling __next__ under the hood
            for _ in self.batch_processing():
                # looping until the flag is reset
                while self.task_is_still_running:
                    # to avoid gui freezes
                    self.waitForAbort(1)


                if self.error_is_set:
                    # decide if batch processing should be continued,
                    # will be auto answered to False after autoclose timeout
                    if not xbmcgui.Dialog().yesno("Would you continue anyway?",
                                                  line1=self.exception_object.message,
                                                  autoclose=DIALOG_AUTO_CLOSE_TIME*1000):


                        # do not continue - raise the exception and
                        # jump to the needed except block
                        raise self.exception_object


                logger('  {}'.format('and finished' if not self.error_is_set else self.exception_object.message))


        except PrerequisiteError as e:
            logger('PrerequisiteError::{}'.format(e.message))


        except BackupError as e:
            logger('BackupError::{}'.format(e.message))


        # uncomment self.rollback_needed = True if rollback is needed
        except TimeOutError as e:
            logger('TimeOutError::{}'.format(e.message))
            # self.rollback_needed = True


        except Exception as e:
            # inform user about problem - allow to ignore rollback
            if xbmcgui.Dialog().yesno("Unhandled exception occurred: Rollback needed?",
                                      line1=e.message,
                                      autoclose=DIALOG_AUTO_CLOSE_TIME*1000):


                logger('Unhandled exception:{}'.format(e.message))
                self.rollback_needed = True
        finally:
            # if rollback flag is set call the rollback function
            if self.rollback_needed:
                self.rollback()
            logger('batch processing finished')




# -----------------------------------------------------------------------------
# main


def main():
    logger('*'*30)
    logger('start main')
    if not xbmcvfs.exists(LOG_DIRECTORY):
        xbmcvfs.mkdirs(LOG_DIRECTORY) # create the directory if it doesn't exist


    batch_processor = _MONITOR(MAXIMUM_WAIT_TIME,SLEEP_TIME)
    batch_processor.start()


    try:
        del batch_processor
    except:
        pass
    logger('main finished')


main()

Cheers
Claudia

Zitat von TheMexx

Meine kam nie an. Habe ihn dann in deutschland bestellt

Darf ich fragen wo?

Cheers
Claudia

Zitat von Roby

Weiß jemand wie lange dauert bis es geliefert wird
Hab vor fast 3 woche ROCK64 MEDIA BOARD COMPUTER DRAM: 4GB bestellt bis heute noch nicht erhaleten

Meine Lieferung hatte damals auch knapp 4 Wochen ab Versandtag gedauert und die
Statusnachrichten bei der Lieferverfolgung konnte man in die Tonne treten.

Cheers
Claudia

- wiki -

Merci

Cheers
Claudia