Beispiel #1
0
    def __init__(self, source):
        """
        Create a video instance from the given source
        :param source: either Device ID or video file name
        """
        AlgoClass.__init__(self)

        self.web_cam, self.capture = self.set_capture(source)
        self.TOTAL_FRAMES, self.NUM_FRAMES_SKIPPED = self.set_read()

        # all should be called img
        self.before_process = None

        # updated by read(), make sure a frame exists
        self.has_frame, self.current_frame = False, None
        self.read()
        #  use to skip frame
        self.count_frame = 1

        self.motion, self.motion_region = self.set_motion_tracker(), None
        self.skin, self.skin_regions = Skin(), None

        self.masked_frame = None
        self.hand_img = None

        self.hand = None
Beispiel #2
0
def test_foo_copy():
    s = Skin()
    s.foo = []
    t = Skin(s.copy())
    u = copy.copy(s)
    assert s is not t
    assert s is not u
    assert s.foo.value is t.foo.value
    assert s.foo.value is u.foo.value
Beispiel #3
0
    def __init__(self, cells):
        """ """
        pygame.init()
        self.window = pygame.display.set_mode(constants.SET_MODE)

        self.cells = cells
        self.skin = Skin()

        self.display_maze(self.cells)
        self.draw_maze()
Beispiel #4
0
    def __init__(self, user_agent=False, proxy=False):
        self.skin = Skin()
        if user_agent and proxy:
            self.network = Motor(user_agent=True, proxy=True)
        elif user_agent:
            self.network = Motor(user_agent=True)
        elif proxy:
            self.network = Motor(proxy=True)
        else:
            self.network = Motor()

        if not os.path.exists('./{}'.format(__CONFIG__['download']['folder'])):
            os.mkdir('./{}'.format(__CONFIG__['download']['folder']))
Beispiel #5
0
def test_set_known_attribute():

    class A:

        def __init__(self):
            self.x = []

        def __getitem__(self, name):
            raise NotImplementedError

    a = A()
    s = Skin(a)
    assert a.x is s.x
    s.x = 2
    assert a.x is s.x
Beispiel #6
0
def test_equality(s, d):
    s2 = Skin(d)
    assert s is not s2
    assert s == s2
    assert s != d
    assert s.value is s2.value
    assert s2.value is d
Beispiel #7
0
 def _resolve_loot_filter_aliases(self):
     uri = self.config["loot_filter_aliases_url"]
     if not uri:
         text = pkg_resources.resource_string("pypod_launcher", "d2.yaml")
     else:
         text = self._try_open_then_download(uri)
     return Skin(yaml.load(text))
Beispiel #8
0
 async def generate_loot_filter(self):
     with self.disabled_buttons():
         target = self.pod_path / "item.filter"
         if target.exists():
             answer = QtWidgets.QMessageBox.question(
                 self.ui, "Confirmation",
                 "Are you sure you want to rewrite your 'item.filter'?")
             if answer == QtWidgets.QMessageBox.StandardButton.No:
                 return
         logger.info("generating loot filter...")
         uri = self.config["loot_filter_url"]
         try:
             template = pathlib.Path(uri).read_text()
         except Exception:
             async with self.session.get(uri.strip()) as response:
                 template = await response.text()
         d2 = Skin(
             yaml.load(
                 pkg_resources.resource_string("pypod_launcher",
                                               "d2.yaml")))
         rendered = jinja2.Template(template,
                                    line_statement_prefix="#",
                                    line_comment_prefix="##").render(d2=d2)
         header = "// Generated with pypod-launcher v{} ({})\n".format(
             version, datetime.datetime.now())
         target.write_text(header + rendered)
         logger.info("generation done")
         self.ui.status.setText("done")
Beispiel #9
0
 def __init__(self, device_name, avd_root, avd_repo_root, android_sdk_root=os.getenv('ANDROID_SDK_ROOT')):
     self.AVD_ROOT = avd_root
     self.AVD_REPO_ROOT = avd_repo_root
     # don't catch any exceptions so that they bubble up
     device_file = os.path.abspath(os.path.join(self.AVD_ROOT, 'devices', device_name + '.json'))
     device_dict = json.load(open(device_file, 'r'))
     # the loops is more elegant but the manual way will uncover any missing fields
     # for key in device_dict:
     #     self[key] = device_dict[key]
     self.name = device_dict['name']
     self.supported_versions = device_dict['supported_versions']
     if 'skin' in device_dict:
         self.skin = Skin(device_dict['skin'], self.AVD_ROOT, android_sdk_root)
     # so people have to only test 'if myDevice.skin: ...' and not for its existence
     else:
         self.skin = None
     if 'sdcard' in device_dict:
         self.sdcard = device_dict['sdcard']
     # so people have to only test 'if myDevice.sdcard: ...' and not for its existence
     else:
         self.sdcard = None
     if 'options' in device_dict:
         self.options = device_dict['options']
     # so people have to only test 'if myDevice.options: ...' and not for its existence
     else:
         self.options = None
Beispiel #10
0
def get_text_messages(message):
    global status
    global skin_name
    if status == 'main_menu':
        if message.text == "Построить графики":
            bot.send_message(message.from_user.id, "Введи название скина:")
            status = 'check_skin'
        else:
            bot.send_message(message.from_user.id, 'Ошибка в команде', reply_markup=keyboard1)

    elif status == 'check_skin':
        skin_name = message.text
        bot.send_message(message.from_user.id, "Введи название индикатора:", reply_markup=keyboard2)
        status = 'indicators_input'

    elif status == 'indicators_input':
        if message.text == "Построить графики":
            test_skin = Skin(name=skin_name, app_id=730)
            analyst = SkinAnalyst(test_skin)
            indicators_result = analyst.get_graphs_BBANDS(indicators)
            with open(f'{skin_name}.png', 'rb') as result:
                bot.send_message(message.from_user.id, "Результат получен:")
                bot.send_document(message.from_user.id, result)
                bot.send_message(message.from_user.id, str(indicators_result), reply_markup=keyboard3)

            status = 'main_menu'
        else:
            indicators.append(eval(message.text))
            print(indicators)
Beispiel #11
0
def test_defaultdict():
    d = collections.defaultdict(list)
    s = Skin(d)
    assert isinstance(s.foo.value, list)
    assert len(s) == 1
    s.bar.append(1)
    assert s.bar.value == [1]
    assert s.foo.value is d["foo"]
    assert s.bar.value is d["bar"]
Beispiel #12
0
class MazeGrid:
    """ """
    def __init__(self, cells):
        """ """
        pygame.init()
        self.window = pygame.display.set_mode(constants.SET_MODE)

        self.cells = cells
        self.skin = Skin()

        self.display_maze(self.cells)
        self.draw_maze()

    def draw_maze(self):
        """ """
        while True:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    sys.exit()

    def display_maze(self, cells):
        """ """
        paths = list(cells.cells)
        i = 0
        for path in paths:
            pos = list(list(paths)[i])[0]
            typ = list(list(paths)[i])[1]
            if typ == 'wall':
                self.image = pygame.image.load(
                    self.skin.image('wall')).convert()
            if typ == 'path':
                self.image = pygame.image.load(
                    self.skin.image('path')).convert()
            if typ == 'start':
                self.image = pygame.image.load(
                    self.skin.image('start')).convert()
            if typ == 'goal':
                self.image = pygame.image.load(
                    self.skin.image('goal')).convert()
            pos_x = pos.y * 44
            pos_y = pos.x * 44
            self.window.blit(self.image, (pos_x, pos_y))
            i = i + 1
        pygame.display.flip()
Beispiel #13
0
def test_del_known_attribute():

    class A:

        def __init__(self):
            self.x = []

        def __getitem__(self, name):
            raise NotImplementedError

    a = A()
    s = Skin(a)
    assert a.x is s.x
    del s.x
    with pytest.raises(AttributeError):
        print(a.x)
Beispiel #14
0
    def get_skin(cls, function=False):
        """
        See if this skin will do. If not create an overlay skin and return
        it. If you want a specific skin type use 'set_skin' and then this.

        - function: Specify that you will need the skin for storing
          functions. Will overlay a new one.
        """

        need_skin = function and not isinstance(cls._skin, FunctionSkin) or \
                    cls._skin is None

        if need_skin:
            cls.set_skin(function and FunctionSkin() or Skin())

        return cls._skin
Beispiel #15
0
 def update(self):
     with self.disabled_buttons():
         logger.info("checking for update...")
         url = self.config["update_url"].strip()
         response = requests.get(url)
         response.raise_for_status()
         parsed = etree.fromstring(response.content)
         descriptions = []
         for file_desc in parsed:
             crc = file_desc.get("crc")
             if crc:
                 crc = crc.lower()
             descriptions.append(Skin(dict(
                 urls=[link.text for link in file_desc],
                 target=self.pod_path / file_desc.get("name"),
                 crc=crc,
             )))
         self._update_files(descriptions)
         (self.pod_path / "config").mkdir(parents=True, exist_ok=True)
         logger.debug("update done")
         self.ui.status.setText("done")
Beispiel #16
0
    def __init__(self, in_stats={}):
        """Create a new monster, setting stats, etc. as needed."""
        self.lvl = 0
        # self.awr might not even need to be a thing, remove this if it ends up not mattering
        self.awr = 0# awareness, this is a thing for conversations / progress through the game
        # it might make more sense to hold info for conversations flow in shared.state, but I'm not sure
        # depends on how this number interacts with monster stuff
        self.personality = Personality.random()
        self.name = Personality.generateName(self.personality)
        self.skin = Skin.random(self.personality)
        # access the SkinTone with self.skin[self.lvl]
        self.mood = Mood.Neutral# mood might only be changed by and do stuff during battles / convos? maybe

        self.stats = {x: 2 for x in self.__class__.main_stats}
        self.stats['drv'] = self.__class__.drv_max//2
        self._levelStats()
        self.stats.update(in_stats)
        self.setHealth()

        self.sprite_groups = tuple(random.choice(('A','B','C')) for x in range(5))
        self._setSpritePaths()
        self._setSprites()
Beispiel #17
0
from xonstat.models import *
from xonstat.util import datetime_seconds

from skin import Skin
from playerdata import PlayerData

# maximal number of query results (for testing, set to None to get all)
NUM_PLAYERS = None

# we look for players who have activity within the past DELTA hours
DELTA = 6

# classic skin WITHOUT NAME - writes PNGs into "output//###.png"
skin_classic = Skin(
    "",
    bg="broken_noise",
    overlay="overlay_classic",
)

# more fancy skin [** WIP **]- writes PNGs into "output/archer/###.png"
skin_archer = Skin(
    "archer",
    bg="background_archer-v1",
    overlay=None,
)

# minimal skin - writes PNGs into "output/minimal/###.png"
skin_minimal = Skin(
    "minimal",
    bg=None,
    bgcolor=(0.04, 0.04, 0.04, 1.0),
from context import Context
from skin import Skin, DictSkinConfig

DEFAULTS_DOMAIN = 'default_kwargs'
# Note that append as None means the user has not set the behaviour
# explicitly. It should be interpreted to true by the Context.
DEFAULTS_KW = dict(domain='functions', append=None, mapping=True)
DEFAULTS = DictSkinConfig(functions={}, default_kwargs=DEFAULTS_KW)

if Context._skin == None:
    Context.set_skin(Skin(config=DEFAULTS))
Beispiel #19
0
class Device(object):
    """
    A class representing an Android Virtual Device device.
    """
    
    def __init__(self, device_name, avd_root, avd_repo_root, android_sdk_root=os.getenv('ANDROID_SDK_ROOT')):
        self.AVD_ROOT = avd_root
        self.AVD_REPO_ROOT = avd_repo_root
        # don't catch any exceptions so that they bubble up
        device_file = os.path.abspath(os.path.join(self.AVD_ROOT, 'devices', device_name + '.json'))
        device_dict = json.load(open(device_file, 'r'))
        # the loops is more elegant but the manual way will uncover any missing fields
        # for key in device_dict:
        #     self[key] = device_dict[key]
        self.name = device_dict['name']
        self.supported_versions = device_dict['supported_versions']
        if 'skin' in device_dict:
            self.skin = Skin(device_dict['skin'], self.AVD_ROOT, android_sdk_root)
        # so people have to only test 'if myDevice.skin: ...' and not for its existence
        else:
            self.skin = None
        if 'sdcard' in device_dict:
            self.sdcard = device_dict['sdcard']
        # so people have to only test 'if myDevice.sdcard: ...' and not for its existence
        else:
            self.sdcard = None
        if 'options' in device_dict:
            self.options = device_dict['options']
        # so people have to only test 'if myDevice.options: ...' and not for its existence
        else:
            self.options = None
        
    def versioned_name(self, android_version):
        return self.name + '-' + android_version
    
    def is_installed(self, android_version):
        device_avd_dir = os.path.abspath(os.path.join(self.AVD_REPO_ROOT, self.versioned_name(android_version) + '.avd'))
        device_avd_ini = os.path.abspath(os.path.join(self.AVD_REPO_ROOT, self.versioned_name(android_version) + '.ini'))
        return (
            os.path.exists(device_avd_dir) and
            os.path.isdir(device_avd_dir) and
            os.path.exists(device_avd_ini) and
            os.path.isfile(device_avd_ini)
        )
    
    def installed_versions(self):
        return [t[0] for t in [(version, self.is_installed(version)) for version in self.supported_versions] if t[1]]
        
    def install(self, android_version):
        # first check the user isn't trying to install an unsupported version
        if (not android_version in self.supported_versions):
            return False
        device_avd_dir = os.path.abspath(os.path.join(self.AVD_REPO_ROOT, self.versioned_name(android_version) + '.avd'))
        device_avd_ini = os.path.abspath(os.path.join(self.AVD_REPO_ROOT, self.versioned_name(android_version) + '.ini'))
        # return False if it already exists
        if (os.path.isdir(device_avd_dir) and os.path.isfile(device_avd_ini)):
            return False
        command = ['android', 'create', 'avd']
        # force creation, since we've already checked that both files don't already exist
        command.append('-f')
        # add the name
        command.extend(['-n', self.versioned_name(android_version)])
        # add the target
        command.extend(['-t', android_version])
        if self.sdcard:
            if 'file' in self.sdcard:
                img_path = os.path.abspath(os.path.join(self.AVD_ROOT, 'devices', self.sdcard['file']))
                command.extend(['-c', img_path])
            elif 'size' in self.sdcard:
                command.extend(['-c', self.sdcard['size']])
        if self.skin:
            if (self.skin.is_installed(android_version) or self.skin.install(android_version)):
                command.extend(['-s', self.skin.name])
            else:
                return False
        retcode = call(command)
        if (os.path.isdir(device_avd_dir) and os.path.isfile(device_avd_ini)):
            # now add any additional options if specified
            if self.options:
                fp = open(device_avd_ini, 'a+')
                lines = ['{key}={value}\n'.format(key=option, value=self.options[option]) for option in self.options]
                fp.writelines(lines)
                fp.close()
            return True
        else:
            return False
        
    def uninstall(self, android_version):
        # first check the user isn't trying to uninstall an unsupported version
        if (not android_version in self.supported_versions):
            return False
        device_avd_dir = os.path.abspath(os.path.join(self.AVD_REPO_ROOT, self.versioned_name(android_version) + '.avd'))
        device_avd_ini = os.path.abspath(os.path.join(self.AVD_REPO_ROOT, self.versioned_name(android_version) + '.ini'))
        # return True if it already doesn't exist
        if (not os.path.isdir(device_avd_dir) and not os.path.isfile(device_avd_ini)):
            return True
        retcode = call(['android', 'delete', 'avd', '-n', self.versioned_name(android_version)])
        return not os.path.exists(device_avd_dir) and not os.path.exists(device_avd_ini)
Beispiel #20
0
class Trawler(object):
    def __init__(self, user_agent=False, proxy=False):
        self.skin = Skin()
        if user_agent and proxy:
            self.network = Motor(user_agent=True, proxy=True)
        elif user_agent:
            self.network = Motor(user_agent=True)
        elif proxy:
            self.network = Motor(proxy=True)
        else:
            self.network = Motor()

        if not os.path.exists('./{}'.format(__CONFIG__['download']['folder'])):
            os.mkdir('./{}'.format(__CONFIG__['download']['folder']))

    def trawl(self, url):
        # making sure url is formatted correctly (aka skinning)
        skinned_url = self.skin.url(url)
        return_dict = {}
        return_dict[skinned_url] = None
        # Determining if the site is up
        url_info = self.is_site_up(skinned_url)
        if url_info:

            # Generating a url list based on previously identified patterns with phish kits

            attempt_to_download_list = []
            # Trying our generated kit locations to see if files are present
            for url in Generator(skinned_url).url_list:
                print('generated item: %s' % url)
                generated_parsed_files = Parser(url, self.network).parsed_files
                if generated_parsed_files:
                    for item in generated_parsed_files:
                        attempt_to_download_list.append(item)
                attempt_to_download_list.append(url)

            for url in Parser(skinned_url, self.network).parsed_files:
                generated_files = Generator(url).url_list
                if generated_files:
                    for item in generated_files:
                        attempt_to_download_list.append(item)
                attempt_to_download_list.append(url)

        return_dict[skinned_url] = self._download_from_url_list(
            attempt_to_download_list)
        return return_dict

    def _download_from_url_list(self, url_list):
        return_list = []
        if isinstance(url_list, list):
            for url in url_list:
                try:
                    print('parsed item: %s' % url)
                    bin_trawl = BinaryTrawl(url, self.network)
                    bin_trawl.download()
                    return_list.append(bin_trawl.file_name)
                except:
                    print(
                        'Unable to access kit based on the following path: {}'.
                        format(url))
                    pass
            return return_list

    def is_site_up(self, value):
        url = value.replace(" ", "%20")
        response = self.network.get(url)
        return response
Beispiel #21
0
def test_skin_of_skin():
    s1 = Skin(dict(a=1))
    s2 = Skin(s1)
    assert s1.a is s2.a
    assert s1.a == s2.a == 1
Beispiel #22
0
from skin import Skin
from skin_analyst import SkinAnalyst
from momentum_indicators import *

if __name__ == '__main__':
    test_skin = Skin(name='Gamma 2 Case', app_id=730)
    analyst = SkinAnalyst(test_skin)
    analyst.get_graphs([RSI, ROC, STOCH])

Beispiel #23
0
def test_not_allowed():
    with pytest.raises(SkinValueError):
        Skin(dict(), allowed=(str,))
Beispiel #24
0
def test_no_getitem():
    with pytest.raises(SkinValueError):
        Skin(1)
Beispiel #25
0
def test_config_inheritance():
    s1 = Skin(forbidden=(set,))
    s2 = s1.foo.bar.baz
    assert super(Skin, s1).__getattribute__("forbidden") is super(Skin, s2).__getattribute__("forbidden")
Beispiel #26
0
def test_deepcopy():
    s = Skin()
    s.foo = []
    t = copy.deepcopy(s)
    assert s.foo.value is not t.foo.value
Beispiel #27
0
class Video(AlgoClass):
    """
    Reads frames from a video source and broadcast them to motion and skin

    Instance Variables:
        web_cam: bool - True when web camera is the source and is still on
                        False when video file is the source
        capture:       VideoCapture object - use to read frames
        has_frame:     bool - a frame exists       (necessary?)
        current_frame: image  - current video frame
        count_frame:   int  - total number of frames read from video source

    """
    def __init__(self, source):
        """
        Create a video instance from the given source
        :param source: either Device ID or video file name
        """
        AlgoClass.__init__(self)

        self.web_cam, self.capture = self.set_capture(source)
        self.TOTAL_FRAMES, self.NUM_FRAMES_SKIPPED = self.set_read()

        # all should be called img
        self.before_process = None

        # updated by read(), make sure a frame exists
        self.has_frame, self.current_frame = False, None
        self.read()
        #  use to skip frame
        self.count_frame = 1

        self.motion, self.motion_region = self.set_motion_tracker(), None
        self.skin, self.skin_regions = Skin(), None

        self.masked_frame = None
        self.hand_img = None

        self.hand = None

    def update(self):
        """
        Video control center. If there is a new non-skipped frame with
        sufficient changes based on main areas of concern
             - on motion (including background sub) and
             - skin color
        the existing hand is process for gesture recognition
        :return: bool
        """
        # TODO: rank among multiple hands
        if self.has_more_frames() and self.is_retrieved(
        ) and self.motion.detected():

            print "frame", self.count_frame

            self.masked_frame = self.create_masked_frame()
            hand_silhouette = self.find_hand_silhouette()
            if hand_silhouette is not None:
                self.process_hand(hand_silhouette)
                return True

            return False

    def create_masked_frame(self):
        """
        Create and return a masked version of the current frame
        The mask rejects non-skin colors and static parts by filtering for skin
        and motion regions
        :return: image
        """
        self.motion_region = self.motion.get_motion_region()
        self.skin_regions = self.skin.get_active_regions(self.current_frame)

        # main area of concern
        return cv2.bitwise_and(self.skin_regions,
                               self.skin_regions,
                               mask=self.motion_region)

    def find_hand_silhouette(self, frame=None):
        """
        Return Silhouette of the hand by processing the geometries of all the contours
        :param frame: image
        :return: Silhouette
        """
        if frame is None:
            frame = self.masked_frame

        contours = Silhouette.get_contours(frame, constants.CONTOURS_MIN_AREA)
        # onion geometries for all large contours (likely face and hand)
        silhouettes = Silhouette.create_geometries(frame, contours)

        if len(silhouettes) > 0:
            #for idx in range(len(sils)):
            #sils[idx].draw_all()

            return Silhouette.select_hand_like(silhouettes)

        return None

    def process_hand(self, hand_silhouette):
        """
        Process the hand silhouette to identify the thumb and fingers
        :param hand_silhouette: Silhouette
        :return:
        """
        hand_silhouette.log_all()
        self.hand = Hand(self.current_frame, hand_silhouette.onion_geometry,
                         hand_silhouette.shape_like)

        #  drawn after the Hand constructor call to track the refined poly_curve
        hand_silhouette.draw_all()
        self.hand.draw(self.current_frame)

    def read(self):
        """
        Update current frame with next read and some initial image processing
        :return: None
        """
        self.has_frame, self.current_frame = self.capture.read()
        self.before_process = self.current_frame.copy()
        self.current_frame = Tools.pre_process_image(self.current_frame)

    def is_running(self):
        """
        Return True if video source has more frames and user has not issued a quit command
        :return: bool
        """

        if self.has_more_frames() and not self.video_key_interrupt():
            return True
        else:
            self.capture.release()
            cv2.destroyAllWindows()
            return False

    def is_retrieved(self):
        """
        One frame out of NUM_FRAMES_SKIPPED is to be read
        For example out with FPS 30 and 3 FRAMES_USED_PER_SEC
                1 is read, meaning grabbed and retrieved (latter is a slow op)
                9 are skipped, VideoCapture.grab() applied to advance video
        :return: bool
        """
        self.count_frame += 1
        if (self.count_frame % self.NUM_FRAMES_SKIPPED) == 0:
            self.read()
            self.motion.update_frame(self.current_frame)
            return True
        else:
            self.has_frame = self.capture.grab()
            return False

    def has_more_frames(self):
        """
        Return True if the video source has more frames
        :return: bool
        """
        return self.web_cam or self.count_frame < self.TOTAL_FRAMES

    #
    #  constructor helpers

    def set_capture(self, source):
        """
        :param source: int/str ( live camera index/video file name)
        :return: VideoCapture
        """
        web_cam = False

        if source == constants.DEFAULT_DEVICE:
            self.log_text("Webcam " + source + " in use")
            web_cam = True

        capture = cv2.VideoCapture(source)

        if not capture.isOpened():
            self.log_text("Failed to open video source. Exiting...")
            exit()

        self.log_text(source)
        return web_cam, capture

    def set_read(self):
        """
        Set video statistics
        Return total number of frames in video source and
               frames to skip in between two reads
        :return: int, int
        """
        total_frames = self.capture.get(cv2.CAP_PROP_FRAME_COUNT)
        num_frames_skipped = int(
            self.capture.get(cv2.CAP_PROP_FPS) / constants.FRAMES_USED_PER_SEC)
        self.log_text("total frames %d" % total_frames)
        self.log_text("used frames %d" % constants.FRAMES_USED_PER_SEC)
        self.log_text("skip %d" % num_frames_skipped)
        return total_frames, num_frames_skipped

    def set_motion_tracker(self):
        """
        :return: Motion object
        """
        width, height = self.get_frame_size()
        return Motion(height, width, self.current_frame)

    def get_frame_size(self):
        """
        :return: int, int
        """
        return self.capture.get(cv2.CAP_PROP_FRAME_WIDTH), \
               self.capture.get(cv2.CAP_PROP_FRAME_HEIGHT)

    @staticmethod
    def video_key_interrupt():
        """
        Delay for keyboard interrupt callbacks.
        Return True if the predefined quit key was pressed
        :return: bool
        """
        """
        Note:
        & 0xff needed for 64-bit machine: see following link
        http://docs.opencv.org/3.0-beta/doc/py_tutorials/py_gui/py_image_display/
           ...py_image_display.html
        """
        k = cv2.waitKey(constants.VIDEO_KEY_EVENT_DELAY) & 0xff
        return k == ord(constants.PROGRAM_QUIT_KEY.lower())
Beispiel #28
0
def get_result(to_user_id):
    test_skin = Skin(name=skin_name, app_id=730)
    analyst = SkinAnalyst(test_skin)
    indicators_result = analyst.get_graphs(indicators)
    send_result_message(to_user_id, f'{skin_name}.png')
Beispiel #29
0
def test_forbidden():
    with pytest.raises(SkinValueError):
        Skin(dict(), forbidden=(dict,))
Beispiel #30
0
def s(d):
    return Skin(d)
Beispiel #31
0
def test_repr():
    s = Skin()
    assert repr(s) == "Skin({})"