Python try_install_package 예제들

예제 #1

파일: Pin.py 프로젝트: mhetzi/mqttRaspberry

# -*- coding: utf-8 -*-
try:
    from gpiozero import LED, Button
except ImportError as ie:
    try:
        import Tools.error as err
        err.try_install_package('gpiozero', throw=ie, ask=True)
    except err.RestartError:
        from gpiozero import LED, Button
import enum
import time
import logging


class PinDirection(enum.Enum):
    OUT = 0
    IN = 1
    IN_PULL_UP = 2
    IN_PULL_LOW = 3


class PinEventEdge(enum.Enum):
    RISING = 0
    FALLING = 1
    BOTH = 3


class Pin:
    def __init__(self, pin: int, direction: PinDirection, init=-1):
        self._pin = pin
        self._pulse_width = None

예제 #2

파일: Main.py 프로젝트: mhetzi/mqttRaspberry

from typing import Union
import paho.mqtt.client as mclient
import logging

import  Tools.Config as conf
from    Tools.PluginManager import PluginManager, PluginInterface
from    Tools.Devices.Sensor import Sensor, SensorDeviceClasses

try:
    import pyudev
except ImportError as ie:
    import Tools.error as err
    try:
        err.try_install_package('pyudev', throw=ie, ask=False) # Dont ask, plugin is wanted! So try to get it up and running
    except err.RestartError:
        import pyudev

import Mods.udev.prototypes as udevp

class UdevPlugin(PluginInterface):
    _plugin_manager: Union[PluginManager, None] = None
    _sub_plugins: list[udevp.UdevDeviceProcessor] = []

    def __init__(self, client: mclient.Client, opts: conf.PluginConfig, logger: logging.Logger, device_id: str):
        self._config = opts
        self.__client = client
        self.__logger = logger.getChild("udev")

        self._context = pyudev.Context()

        if opts["displays/enabled"]:

예제 #3

# -*- coding: utf-8 -*-
import json
import logging
import os
import re
import math

import paho.mqtt.client as mclient
import schedule

try:
    import Adafruit_DHT
except ImportError as ie:
    try:
        import Tools.error as err
        err.try_install_package('Adafruit_DHT', throw=ie, ask=True)
    except err.RestartError:
        import Adafruit_DHT
import Tools.Config as conf
from Tools import RangeTools

from Tools.Devices.Sensor import Sensor, SensorDeviceClasses
from Tools.Devices.Filters.TooHighFilter import TooHighFilter
from Tools.Devices.Filters.RangedFilter import RangedFilter

from Tools.PluginManager import PluginInterface


class PluginLoader:
    @staticmethod
    def getConfigKey():

예제 #4

from Tools.PluginManager import PluginManager

import logging
import os
import re
import schedule
import threading

import hashlib
try:
    from pyfingerprint.pyfingerprint import PyFingerprint
    from pyfingerprint.pyfingerprint import FINGERPRINT_CHARBUFFER1
except ImportError as ie: 
    try:
        import Tools.error as err
        err.try_install_package('pyfingerprint', throw=ie, ask=True)
    except err.RestartError:
        from pyfingerprint.pyfingerprint import PyFingerprint
        from pyfingerprint.pyfingerprint import FINGERPRINT_CHARBUFFER1

try:
    import gpiozero
except ImportError as ie:
    try:
        import Tools.error as err
        err.try_install_package('gpiozero', throw=ie, ask=True)
    except err.RestartError:
        import gpiozero

from Tools import Pin

예제 #5

파일: Autodiscovery.py 프로젝트: mhetzi/mqttRaspberry

# -*- coding: utf-8 -*-

import enum
from typing import Union
try:
    import json
except ImportError:
    import simplejson as json
import logging

try:
    import paho.mqtt.client as mclient
except ImportError as ie:
    from Tools import error as err
    try:
        err.try_install_package('paho.mqtt', throw=ie, ask=False)
    except err.RestartError:
        import paho.mqtt.client as mclient


class Component(enum.Enum):
    BINARY_SENROR = "binary_sensor"
    COVER = "cover"
    FAN = "fan"
    LIGHT = "light"
    SWITCH = "switch"
    SENSOR = "sensor"
    LOCK = "lock"
    CLIMATE = "climate"

예제 #6

파일: plugin.py 프로젝트: mhetzi/mqttRaspberry

# -*- coding: utf-8 -*-

import paho.mqtt.client as mclient
import Tools.Config as conf
import Tools.Autodiscovery as ad
import logging
import os
import re
import schedule
import weakref
try:
    import serial
except ImportError as ie:
    try:
        import Tools.error as err
        err.try_install_package('pyserial', throw=ie, ask=True)
    except err.RestartError:
        import serial

import Mods.victron.Constants as CONST
from Mods.victron.vcSerial import Connection

from Mods.victron.mppt import MPPT


class VeDirectPlugin:
    _topic = None
    _shed_Job = None
    _plugin_manager = None
    _do_register = False
    _do_register_was_connected = False

예제 #7

import paho.mqtt.client as mclient
import Tools.Config as conf
import logging
import os
import re
from Tools import ResettableTimer
import json
import threading
import datetime

try:
    from soundmeter import meter
except ImportError as ie:
    try:
        import Tools.error as err
        err.try_install_package('soundmeter', throw=ie, ask=True)
    except err.RestartError:
        from soundmeter import meter


class PluginLoader:
    @staticmethod
    def getConfigKey():
        return "soundmeter"

    @staticmethod
    def getPlugin(client: mclient.Client, opts: conf.BasicConfig,
                  logger: logging.Logger, device_id: str):
        return SoundMeterWrapper(client, opts, logger, device_id)

    @staticmethod

예제 #8

파일: Config.py 프로젝트: mhetzi/mqttRaspberry

try:
    import json
except ImportError:
    import simplejson as json

FILEWATCHING = False
try:
    from watchdog.observers import Observer
    import watchdog.events as watchevents

    FILEWATCHING = True
except ImportError:
    try:
        import Tools.error as err
        err.try_install_package('watchdog')
    except err.RestartError:
        from watchdog.observers import Observer
        import watchdog.events as watchevents
        FILEWATCHING = True
    except:
        FILEWATCHING = False
from typing import Dict, Tuple, Sequence, Union


class DictBrowser:
    def __init__(self,
                 backing_dict: dict,
                 logger: logging.Logger = None) -> None:
        self._dict = backing_dict
        #self._log = logger if logger is not None else logging.getLogger("Launch.DictBrowser")

예제 #9

else:
    def _name_hack(self):
        # PR_SET_NAME = 15
        libcap.prctl(15, self.name.encode())
        threading.Thread._bootstrap_original(self)

    threading.Thread._bootstrap_original = threading.Thread._bootstrap
    threading.Thread._bootstrap = _name_hack


try:
    import setproctitle
except ImportError as ie:
    from Tools import error as err
    try:
        err.try_install_package('setproctitle', throw=ie, ask=False)
    except err.RestartError:
        try:
            import setproctitle
        except:
            pass
    except:
        pass

class Launcher:

    pm = None
    reload_event = threading.Event()
    reload = True
    reconnect_time = 0.1
    mqtt_client = None

예제 #10

# -*- coding: utf-8 -*-
# Um das skript ohne sudo verwenden zu können:
# sudo sudo setcap 'cap_net_raw,cap_net_admin+eip' $(readlink -f $(which python3))

import time
import datetime
try:
    from beacontools import BeaconScanner, EddystoneTLMFrame, EddystoneFilter
except ImportError as ie:
    try:
        import Tools.error as err
        err.try_install_package('beacontools', throw=ie, ask=True)
    except err.RestartError:
        import beacontools
import paho.mqtt.client as mclient
import Tools.Config as conf
import logging
import Tools.PluginManager as pm

import threading
import json


class PluginLoader:
    @staticmethod
    def getConfigKey():
        return "BleTrack"

    @staticmethod
    def getPlugin(client: mclient.Client, opts: conf.BasicConfig,
                  logger: logging.Logger, device_id: str):

예제 #11

파일: pBh1750.py 프로젝트: mhetzi/mqttRaspberry

# -*- coding: utf-8 -*-
import paho.mqtt.client as mclient
import Tools.Config as conf
import logging
import os
import re

import schedule

try:
    import smbus
except ImportError as ie:
    try:
        import Tools.error as err
        err.try_install_package('smbus', throw=ie, ask=True)
    except err.RestartError:
        import smbus
import Mods.referenz.bh1750 as bhref

class PluginLoader:

    @staticmethod
    def getConfigKey():
        return "BH1750"

    @staticmethod
    def getPlugin(client: mclient.Client, opts: conf.BasicConfig, logger: logging.Logger, device_id: str):
        return bh1750(client, opts, logger, device_id)

    @staticmethod
    def runConfig(conf: conf.BasicConfig, logger:logging.Logger):

예제 #12

파일: pPiUndervoltage.py 프로젝트: mhetzi/mqttRaspberry

# -*- coding: utf-8 -*-
import paho.mqtt.client as mclient
import Tools.Config as conf
import Tools.Autodiscovery as ad
import logging
import os
import re
import schedule
import weakref

try:
    from rpi_bad_power import new_under_voltage
except ImportError as ie:
    try:
        import Tools.error as err
        err.try_install_package('rpi-bad-power', throw=ie, ask=True)
    except err.RestartError:
        from rpi_bad_power import new_under_voltage

from Tools.Devices import BinarySensor


class PluginLoader:
    @staticmethod
    def getConfigKey():
        return "rPiUndervoltage"

    @staticmethod
    def getPlugin(client: mclient.Client, opts: conf.BasicConfig,
                  logger: logging.Logger, device_id: str):
        return RaspberryPiUndervoltageDetector(client, opts, logger, device_id)

예제 #13

파일: Main.py 프로젝트: mhetzi/mqttRaspberry

import shutil
from math import nan, isnan

try:
    import picamera as cam
    import picamera.array as cama
except ImportError:
    import Mods.referenz.picamera.picamera as cam
    import Mods.referenz.picamera.picamera.array as cama

try:
    from PIL import Image, ImageDraw, ImageFont
except ImportError as ie:
    try:
        import Tools.error as err
        err.try_install_package('pillow', throw=ie, ask=True)
    except err.RestartError:
        from PIL import Image, ImageDraw, ImageFont
try:
    import numpy as np
except ImportError as ie:
    try:
        import Tools.error as err
        err.try_install_package('numpy', throw=ie, ask=True)
    except err.RestartError:
        import numpy

try:
    import piexif
    import piexif.helper
except ImportError as ie:

예제 #14

from Tools.PluginManager import PluginManager
import paho.mqtt.client as mclient
import Tools.Config as conf
import Tools.Autodiscovery as ad
import logging
import os
import re
import schedule
import weakref

try:
    import wmi
except ImportError as ie:
    try:
        import Tools.error as err
        err.try_install_package('wmi', throw=ie, ask=True)
    except err.RestartError:
        import wmi

from Tools.Devices import BinarySensor

from Mods.win32submods.wmi_PnP import WMI_PnP
from Mods.win32submods.pwr.WindowEvents import WindowEventProcessor
from Mods.win32submods.systray import win32Systray


class PluginLoader:
    @staticmethod
    def getConfigKey():
        return "MS_Windows_Sensors"

예제 #15

파일: pPiWs2812B.py 프로젝트: mhetzi/mqttRaspberry

# -*- coding: utf-8 -*-
import paho.mqtt.client as mclient
import Tools.Config as conf
import Tools.Autodiscovery as ad
import logging
import os
import re
import schedule
import weakref

try:
    from rpi_ws281x import PixelStrip, Color
except ImportError as ie:
    try:
        import Tools.error as err
        err.try_install_package('rpi_ws281x', throw=ie, ask=True)
    except err.RestartError:
        from rpi_ws281x import PixelStrip, Color

from Tools.Devices import BinarySensor


class PluginLoader:
    @staticmethod
    def getConfigKey():
        return "pWs2812B on RaspberryPi"

    @staticmethod
    def getPlugin(client: mclient.Client, opts: conf.BasicConfig,
                  logger: logging.Logger, device_id: str):
        return RaspberryPiWs281x(client, opts, logger, device_id)

예제 #16

파일: pLogind.py 프로젝트: mhetzi/mqttRaspberry

"""
Könnte sein dass es nur als Benutzerservice (systemctl --user) funktioniert!
Could be that this Plugin only works when run as user service (systemctl --user)!
"""
try:
    import dbus
except ImportError as ie:
    try:
        import Tools.error as err
        err.try_install_package('dbus-python', throw=ie, ask=True)
    except err.RestartError:
        import dbus

from typing import IO, Union
import paho.mqtt.client as mclient
import Tools.Config as conf
import Tools.Autodiscovery as autodisc
import Tools.PluginManager as PluginMan
from Tools.Devices.Lock import Switch, Lock, LockState
from Tools.Devices.BinarySensor import BinarySensor
import logging
import schedule
import json
import os
import threading
import gi
gi.require_version('GLib', '2.0')
from gi.repository import GLib

from time import sleep

예제 #17

import datetime
import logging
import threading
from typing import Union

from Tools.Devices.Filters.TooLowFilter import TooLowFilter

try:
    import dlms_cosem.time as dlms_time
except ImportError as ie:
    try:
        import Tools.error as err
        err.try_install_package('dlms-cosem', throw=ie, ask=False)
    except err.RestartError:
        import dlms_cosem.time as dlms_time

try:
    from Cryptodome.Cipher import AES
except ImportError as ie:
    try:
        import Tools.error as err
        err.try_install_package('pycryptodomex', throw=ie, ask=False)
    except err.RestartError:
        from Cryptodome.Cipher import AES

try:
    import serial
except ImportError as ie:
    try:
        import Tools.error as err
        err.try_install_package('pyserial', throw=ie, ask=False)