Exemple #1
0
 def f(N):
     if N == 0:
         self.assertNotEqual(original, os_getenv("MYVAR"))
     else:
         with envcontext:
             f(N-1)
         self.assertEqual(original, os_getenv("MYVAR"))
Exemple #2
0
 def test_multiple_usage(self, N=10):
     original = os_getenv("MYVAR")
     envcontext = EnvContext(MYVAR="multiple_usage")
     for _ in range(N):
         with envcontext:
             self.assertNotEqual(original, os_getenv("MYVAR"))
         self.assertEqual(original, os_getenv("MYVAR"))
Exemple #3
0
 def test_combined_usage(self, N=10):
     original = os_getenv("MYVAR")
     with EnvContext(MYVAR="usage1"):
         with EnvContext(MYVAR="usage2"):
             self.assertEqual("usage2", os_getenv("MYVAR"))
         self.assertEqual("usage1", os_getenv("MYVAR"))
     self.assertEqual(original, os_getenv("MYVAR"))
Exemple #4
0
    def test_add_new_variable(self):
        uniqvar = ""
        while not uniqvar:
            candidate = str(uuid4()).upper()
            if candidate not in environ:
                uniqvar = candidate
                break

        params = {uniqvar: uniqvar}
        with EnvContext(**params):
            self.assertEqual(uniqvar, os_getenv(uniqvar))
        self.assertIsNone(os_getenv(uniqvar))
Exemple #5
0
def getenv(varname, default=None, help=None):
    value = os_getenv(varname, default)

    if value is None:
        raise RuntimeError('You must set the %s environment variable. %s' % (varname, help, ))

    return value
Exemple #6
0
    def do_POST(self):
        content_len = int(self.headers.get('content-length'))
        post_body = self.rfile.read(content_len)

        header_hash = self.headers.get('X-Hub-Signature')
        computed_hash = 'sha1=' + create_hex_hmac(os_getenv('SECRET', ''),
                                                  post_body.decode("utf-8"))

        if header_hash != computed_hash:
            print('Wrong hash')
            self.send_response(403)
            self.end_headers()
            return

        else:
            print('Wright hash')
            self.send_response(200)
            self.end_headers()
            data = json.loads(post_body.decode("utf-8"))
            if (data.get('ref', '') == 'refs/heads/master'):
                print('Updating noc42 website…')
                run_subp(['git', 'fetch', 'origin', 'master'])
                run_subp(['git', 'checkout', 'origin/master'])
                run_subp(['npm', 'install'])
                run_subp(['npm', 'run-script', 'build'])
            return
 def __init__(self):
     super(RealBrowserLocust, self).__init__()
     if self.screen_width is None:
         raise LocustError("You must specify a screen_width "
                           "for the browser")
     if self.screen_height is None:
         raise LocustError("You must specify a screen_height "
                           "for the browser")
     self.proxy_server = os_getenv("LOCUST_BROWSER_PROXY", None)
 def __init__(self, *args, **kwargs):
     super(RealBrowserLocust, self).__init__(*args, **kwargs)
     if self.screen_width is None:
         raise LocustError("You must specify a screen_width "
                           "for the browser")
     if self.screen_height is None:
         raise LocustError("You must specify a screen_height "
                           "for the browser")
     self.proxy_server = os_getenv("LOCUST_BROWSER_PROXY", None)
Exemple #9
0
	def _loop_process(self):
		username = os_getenv("ADAFRUIT_IO_USERNAME");
		key = os_getenv("ADAFRUIT_IO_KEY");
		print(f"AdafruitFeed::_loop_process::username, key: {username}, {key}");
		assert(username);
		assert(key);

		ssl.SSLContext.verify_mode = ssl.VerifyMode.CERT_OPTIONAL

		client = MQTTClient(username, key, secure=False);

		client.on_connect = self._connect;
		client.on_disconnect = self._disconnect;
		client.on_message = self._activate;
		client.on_subscribe  = self._null;
		
		print("Adafruit::_loop_process");

		client.connect();
		client.loop_blocking();
Exemple #10
0
    def test_nested_usage(self, N=10):
        original = os_getenv("MYVAR")
        envcontext = EnvContext(MYVAR="nested_usage")

        def f(N):
            if N == 0:
                self.assertNotEqual(original, os_getenv("MYVAR"))
            else:
                with envcontext:
                    f(N-1)
                self.assertEqual(original, os_getenv("MYVAR"))
        f(N)
class Config():
    server = os_getenv('THRUK_SERVER', THRUK_SERVER)
    protocol = os_getenv('THRUK_PROTOCOL', "https")
    valid_protocols = ["http", "https"]
    port = os_getenv("THRUK_PORT", "443")
    version = 0.1
    user = os_getenv("THRUK_USER", "admin")
    password = os_getenv("THRUK_PASSWORD", "admin")
    uri = os_getenv("THRUK_URI", "thruk/cgi-bin/status.cgi?")
    method = "GET"
    details = False
    host = MY_FQDN
    color = True
Exemple #12
0
    def get_all_configs(cls, section):
        '''Get All configurations'''
        try:
            confs = cls.configParrser.items(section)
        except ConfigParser.NoSectionError:
            if len(cls.loaded_config_file) == 0:
                raise ConfigParser.NoSectionError(
                    'No configuration file find.')
            else:
                msg = 'Load config file failed: No section [{}]\nConfig file: {}'.format(
                    section, cls.loaded_config_file)
                raise ConfigParser.NoSectionError(msg)
        except ConfigParser.InterpolationSyntaxError as e:
            raise ConfigParser.InterpolationSyntaxError(
                "Config file syntax error: {}".format(e))
        except Exception as e:
            raise Exception(e)

        # https://stackoverflow.com/questions/5466618/too-many-values-to-unpack-iterating-over-a-dict-key-string-value-list
        # 环境变量(大写)优先于配置文件
        return {key: os_getenv(key.upper(), val) for key, val in confs}
Exemple #13
0
    def __init__(self, logo, Parent=None):

        gtk.AboutDialog.__init__(self)

        page = ()

        if APP_AUTHORS:
            page = page + (_("Developers:"),) + APP_AUTHORS + ("",)

        if APP_CONTRIB:
            page = page + (_("Contributors:"),) + APP_CONTRIB

        if Parent:
            self.set_transient_for(Parent)

        self.set_name(_("OpenLanhouse"))
        self.set_version(APP_VERSION)

        self.set_website(APP_SITE)
        self.set_website_label(_("OpenLanhouse Website"))
        self.set_logo(logo)
        self.set_copyright(APP_COPYRIGHT)
        self.set_comments(APP_COMMENTS)
        self.set_authors(page)
        self.set_documenters(APP_DOCS)
        self.set_artists(APP_ARTISTS)
        self.set_license(APP_LICENCE)

        # TRANSLATORS
        lang = os_getenv("LANG", "en_US").split(".")[0]
        if lang in APP_TRANSLATORS:
            translator = APP_TRANSLATORS[lang]
            self.set_translator_credits(translator)
        else:
            self.set_translator_credits(_("translator-credits"))

        self.run()
        self.destroy()
Exemple #14
0
    def __init__(self, logo, Parent=None):

        gtk.AboutDialog.__init__(self)

        page = ()

        if APP_AUTHORS:
            page = page + (_("Developers:"), ) + APP_AUTHORS + ('', )

        if APP_CONTRIB:
            page = page + (_('Contributors:'), ) + APP_CONTRIB

        if Parent:
            self.set_transient_for(Parent)

        self.set_name(_("OpenLanhouse"))
        self.set_version(APP_VERSION)

        self.set_website(APP_SITE)
        self.set_website_label(_('OpenLanhouse Website'))
        self.set_logo(logo)
        self.set_copyright(APP_COPYRIGHT)
        self.set_comments(APP_COMMENTS)
        self.set_authors(page)
        self.set_documenters(APP_DOCS)
        self.set_artists(APP_ARTISTS)
        self.set_license(APP_LICENCE)

        # TRANSLATORS
        lang = os_getenv('LANG', 'en_US').split('.')[0]
        if lang in APP_TRANSLATORS:
            translator = APP_TRANSLATORS[lang]
            self.set_translator_credits(translator)
        else:
            self.set_translator_credits(_("translator-credits"))

        self.run()
        self.destroy()
Exemple #15
0
def main():

    log_dir = str(os_getenv('SYSTEM_LOG'))
    log_dir += '/DL197'
    if not isdir(log_dir):
        makedirs(log_dir)
    # log file
    log_global = os_join(log_dir, 'global_ingestion.log')
    log_zip_chk = os_join(log_dir, 'check_zip_content.log')

    args = process_args(log_global, default_arg)
    product_id = args.product_id
    proc_id += '_' + str(product_id)
    if args.format is None:
        metadata_fromat = 'xml'
    else:
        metadata_fromat = args.format
    if args.pattern is None:
        metadata_pattern = '/*/*.metadata'
    else:
        metadata_pattern = args.pattern

    #--- check processing directories
    pid = str(getpid())
    processing_dir = '{}/{}'.format(os_getenv('PROCESSING_DIR'), pid)
    processing_dir = '{}/{}'.format('/tmp', getpid())
    if not isdir(processing_dir):
        try:
            makedirs(processing_dir)
        except:
            msg = 'Unable to create the directory {}'.format(processing_dir)
            check_error(proc_id,
                        500,
                        'create-processing-dir',
                        log_global,
                        exit_on_error=True,
                        arg_err=msg)

    dir_lst = [pid, 'testzipdir', 'testzipdir2']
    for d in dir_lst:
        dTmp = '{}/{}'.format(processing_dir, d)
        if not isdir(dTmp):
            try:
                makedirs(dTmp)
            except:
                msg = 'Unable to create the directory {}'.format(dTmp)
                check_error(proc_id,
                            500,
                            'create-processing-dir',
                            log_global,
                            exit_on_error=True,
                            arg_err=msg)
    #--- go to local working directory
    chdir(processing_dir)

    #-- db connection
    conn, cursor, err = db_connect()
    check_error(proc_id,
                err['code'],
                'db-connect',
                log_global,
                exit_on_error=True)

    #--- Getting the product status
    query = db_query.get_product_status(product_id)
    err = submit_query(query, cursor, conn=conn)
    check_error(proc_id,
                err['code'],
                'get-product-status',
                log_global,
                exit_on_error=True,
                arg_err=err['msg'])
    check_query_res(cursor,
                    'get-product-status',
                    log_global,
                    conn=conn,
                    exit_on_error=True)

    product_status = cursor.fetchone()[0]

    # check if this is a new attempt to ingest a previously ARCHIVED product
    print('PRODUCT_STATUS : ' + product_status)
    if product_status != 'NEW':
        conn.close()
        check_error(proc_id,
                    800,
                    'get-product-status',
                    log_global,
                    exit_on_error=True,
                    arg_err=product_id)

    # update the product status to ACTIVE
    query = db_query.update_product_status(product_id, 'ACTIVE')
    err = submit_query(query, cursor, conn=conn, commit=True)
    check_error(proc_id,
                err['code'],
                'upd-product-status',
                log_global,
                exit_on_error=True,
                arg_err=err['msg'])

    # retrieve the ingestion parameters
    query = db_query.get_product_info(product_id)
    err = submit_query(query, cursor, conn=conn)
    check_error(proc_id,
                err['code'],
                'get-product-info',
                log_global,
                exit_on_error=True,
                arg_err=err['msg'])

    check_query_res(cursor,
                    'get-product-info',
                    log_global,
                    conn=conn,
                    exit_on_error=True)
    dTmp = cursor.fetchone()
    product_name = dTmp[0]
    product_type = dTmp[1]
    print 'Product Name: {}'.format(product_name)
    print 'Product Type: {}'.format(product_type)

    query = db_query.get_initial_path(product_id)
    err = submit_query(query, cursor, conn=conn)
    check_error(proc_id,
                err['code'],
                'get-product-info',
                log_global,
                exit_on_error=True,
                arg_err=err['msg'])

    check_query_res(cursor,
                    'get-product-info',
                    log_global,
                    conn=conn,
                    exit_on_error=True)

    query = db_query.get_duplicated_prod(product_id)
    err = submit_query(query, cursor, conn=conn)
    check_error(proc_id,
                err['code'],
                'get-product-info',
                log_global,
                exit_on_error=True,
                arg_err=err['msg'])
    def __init__(self, args, build_path):
        exe = ''
        system_name = system()
        if system_name == 'Linux':
            if 'x86_64' == machine():
                turbulenz_os = 'linux64'
            else:
                turbulenz_os = 'linux32'
        elif system_name == 'Windows':
            turbulenz_os = 'win32'
            # if 'x86' == machine():
            #     turbulenz_os = 'win32'
            # else:
            #     turbulenz_os = 'win64'
            exe = '.exe'
        elif system_name == 'Darwin':
            turbulenz_os = 'macosx'

        root = args.root
        verbose = args.verbose

        if args.imagemagick_convert:
            imagemagick_convert_path = args.imagemagick_convert
        else:
            if system_name == 'Windows':
                default_convert_path = path_join(root, 'external',
                                                 'ImageMagick', 'bin', 'win32',
                                                 'convert.exe')
            else:
                default_convert_path = 'convert'
            imagemagick_convert_path = os_getenv(
                'TURBULENZ_IMAGEMAGICK_CONVERT', default_convert_path)

        nvtristrip = path_join(root, 'tools', 'bin', turbulenz_os,
                               'NvTriStripper' + exe)

        copy = CopyTool()
        tga2png = Tga2Json('tga2png', imagemagick_convert_path)
        dae2json = Dae2Json('dae2json',
                            module_name='turbulenz_tools.tools.dae2json',
                            nvtristrip=nvtristrip)
        obj2json = PythonTool('obj2json',
                              module_name='turbulenz_tools.tools.obj2json')
        material2json = PythonTool(
            'material2json', module_name='turbulenz_tools.tools.material2json')
        bmfont2json = PythonTool(
            'bmfont2json', module_name='turbulenz_tools.tools.bmfont2json')

        cgfx2json = Cgfx2JsonTool( \
            'cgfx2json',
            path_join(root, 'tools', 'bin', turbulenz_os, 'cgfx2json' + exe),
            args.cgfx_flag
        )

        copy.check_version(build_path, verbose)
        tga2png.check_version(build_path, verbose)
        dae2json.check_version(build_path, verbose)
        obj2json.check_version(build_path, verbose)
        material2json.check_version(build_path, verbose)
        bmfont2json.check_version(build_path, verbose)
        cgfx2json.check_version(build_path, verbose)

        self.asset_tool_map = {
            '.png': copy,
            '.dds': copy,
            '.jpg': copy,
            '.ogg': copy,
            '.wav': copy,
            '.mp3': copy,
            '.m4a': copy,
            '.aac': copy,
            '.mp4': copy,
            '.m4v': copy,
            '.webm': copy,
            '.json': copy,
            '.tar': copy,
            '.tga': tga2png,
            '.dae': dae2json,
            '.obj': obj2json,
            '.material': material2json,
            '.bmfont': bmfont2json,
            '.fnt': bmfont2json,
            '.cgfx': cgfx2json
        }

        self.asset_dst_ext = {
            '.dae': '.dae.json',
            '.obj': '.obj.json',
            '.material': '.material.json',
            '.fnt': '.fnt.json',
            '.cgfx': '.cgfx.json',
            '.tga': '.tga.png'
        }
    def __init__(self, args, build_path):
        exe = ""
        system_name = system()
        if system_name == "Linux":
            if "x86_64" == machine():
                turbulenz_os = "linux64"
            else:
                turbulenz_os = "linux32"
        elif system_name == "Windows":
            turbulenz_os = "win32"
            # if 'x86' == machine():
            #     turbulenz_os = 'win32'
            # else:
            #     turbulenz_os = 'win64'
            exe = ".exe"
        elif system_name == "Darwin":
            turbulenz_os = "macosx"

        root = args.root
        verbose = args.verbose

        if args.imagemagick_convert:
            imagemagick_convert_path = args.imagemagick_convert
        else:
            if system_name == "Windows":
                default_convert_path = path_join(root, "external", "ImageMagick", "bin", "win32", "convert.exe")
            else:
                default_convert_path = "convert"
            imagemagick_convert_path = os_getenv("TURBULENZ_IMAGEMAGICK_CONVERT", default_convert_path)

        nvtristrip = path_join(root, "tools", "bin", turbulenz_os, "NvTriStripper" + exe)

        copy = CopyTool()
        tga2png = Tga2Json("tga2png", imagemagick_convert_path)
        dae2json = Dae2Json("dae2json", module_name="turbulenz_tools.tools.dae2json", nvtristrip=nvtristrip)
        obj2json = PythonTool("obj2json", module_name="turbulenz_tools.tools.obj2json")
        material2json = PythonTool("material2json", module_name="turbulenz_tools.tools.material2json")
        bmfont2json = PythonTool("bmfont2json", module_name="turbulenz_tools.tools.bmfont2json")
        cgfx2json = Cgfx2JsonTool("cgfx2json", path_join(root, "tools", "bin", turbulenz_os, "cgfx2json" + exe))

        copy.check_version(build_path, verbose)
        tga2png.check_version(build_path, verbose)
        dae2json.check_version(build_path, verbose)
        obj2json.check_version(build_path, verbose)
        material2json.check_version(build_path, verbose)
        bmfont2json.check_version(build_path, verbose)
        cgfx2json.check_version(build_path, verbose)

        self.asset_tool_map = {
            ".png": copy,
            ".dds": copy,
            ".jpg": copy,
            ".ogg": copy,
            ".wav": copy,
            ".mp3": copy,
            ".mp4": copy,
            ".webm": copy,
            ".tga": tga2png,
            ".dae": dae2json,
            ".obj": obj2json,
            ".material": material2json,
            ".bmfont": bmfont2json,
            ".fnt": bmfont2json,
            ".cgfx": cgfx2json,
        }

        self.asset_dst_ext = {
            ".dae": ".dae.json",
            ".obj": ".obj.json",
            ".material": ".material.json",
            ".fnt": ".fnt.json",
            ".cgfx": ".cgfx.json",
            ".tga": ".tga.png",
        }
Exemple #18
0
    def _get_mpg123_tags(self):
        """ Use mpg123 to get the id3tags.

        """

        id3v1 = _mpg123.POINTER(_mpg123.mpg123_id3v1)()
        id3v2 = _mpg123.POINTER(_mpg123.mpg123_id3v2)()
        _check(
            _mpg123.mpg123_id3(self._mpg123_handle, _mpg123.byref(id3v1),
                               _mpg123.byref(id3v2)))

        id3_dict = self._info_dict
        for i in [
                'tag', 'title', 'artist', 'album', 'year', 'comment', 'genre'
        ]:
            id3_dict[i] = ''
            try:
                id3_dict[i] = getattr(id3v2.contents, i).contents.p
            except:
                pass
            try:
                temp = getattr(id3v1.contents, i)
                current_i = id3_dict.get(i, b'')
                id3_dict[i] = temp if len(temp) > len(current_i) else current_i
            except:
                pass

        try:
            id3_dict['version'] = id3v2.contents.version
        except:
            pass

        try:
            if id3v2.contents.extras > 0:
                tag_type = id3v2.contents.extra.contents.description.p.decode()
                tag_type = tag_type.decode('utf8', 'replace')
                id3_dict[tag_type] = id3v2.contents.extra.contents.text.p
        except:
            pass

        try:
            if id3v2.contents.texts > 0:
                id3_dict['texts'] = id3v2.contents.text.contents.text.p
        except:
            pass

        # from encodings import aliases
        # encodings = aliases.aliases.values()
        encodings = ['utf8', 'euc-jp']
        magic = Magic()
        for key, value in dict(id3_dict.items()).items():
            if type(value) is not int:
                if not value.strip():
                    id3_dict.pop(key)
                elif type(value) is bytes:
                    id3_dict.pop(key)
                    enc = magic.check(value).decode()
                    enc = os_getenv('MUSIO_LANG', enc)
                    try:
                        id3_dict[key.lower()] = value.decode(enc, 'ignore')
                    except LookupError:
                        id3_dict[key.lower()] = value.decode('utf8', 'ignore')

            else:
                id3_dict.pop(key)
                id3_dict[key.lower()] = value

        return id3_dict
Exemple #19
0
#!/usr/bin/python3

import discord
import asyncio

from random import randrange
from datetime import datetime
from humanize import intcomma
from os import getenv as os_getenv

from lib.Globals import discord_server
from lib.Globals import global_headers
from lib.Functions import fetch_corona_infection
from lib.Functions import fetch_pulls, percentage

stonedbot_token = os_getenv('STONEDBOT_ACCESS_TOKEN')
if not stonedbot_token:
    print("Token not found")
    exit()


class BotClient(discord.Client):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.loop.create_task(self.publish_corona())
        self.loop.create_task(self.publish_personal())

    async def on_ready(self):
        #server = discord.utils.find(lambda g: g.name == discord_server, client.guilds)
        #print(f"My Server: {server.name}({server.id})")
        print(f'Logged in as: {self.user.name}({self.user.id})')
    def __init__(self, args, build_path):
        exe = ''
        system_name = system()
        if system_name == 'Linux':
            if 'x86_64' == machine():
                turbulenz_os = 'linux64'
            else:
                turbulenz_os = 'linux32'
        elif system_name == 'Windows':
            turbulenz_os = 'win32'
            # if 'x86' == machine():
            #     turbulenz_os = 'win32'
            # else:
            #     turbulenz_os = 'win64'
            exe = '.exe'
        elif system_name == 'Darwin':
            turbulenz_os = 'macosx'

        root = args.root
        verbose = args.verbose

        if args.imagemagick_convert:
            imagemagick_convert_path = args.imagemagick_convert
        else:
            if system_name == 'Windows':
                default_convert_path = path_join(root, 'external', 'ImageMagick', 'bin', 'win32', 'convert.exe')
            else:
                default_convert_path = 'convert'
            imagemagick_convert_path = os_getenv('TURBULENZ_IMAGEMAGICK_CONVERT', default_convert_path)

        nvtristrip = path_join(root, 'tools', 'bin', turbulenz_os, 'NvTriStripper' + exe)

        copy = CopyTool()
        tga2png = Tga2Json('tga2png', imagemagick_convert_path)
        dae2json = Dae2Json('dae2json', module_name='turbulenz_tools.tools.dae2json', nvtristrip=nvtristrip)
        obj2json = PythonTool('obj2json', module_name='turbulenz_tools.tools.obj2json')
        material2json = PythonTool('material2json', module_name='turbulenz_tools.tools.material2json')
        bmfont2json = PythonTool('bmfont2json', module_name='turbulenz_tools.tools.bmfont2json')
        cgfx2json = Cgfx2JsonTool('cgfx2json', path_join(root, 'tools', 'bin', turbulenz_os, 'cgfx2json' + exe))

        copy.check_version(build_path, verbose)
        tga2png.check_version(build_path, verbose)
        dae2json.check_version(build_path, verbose)
        obj2json.check_version(build_path, verbose)
        material2json.check_version(build_path, verbose)
        bmfont2json.check_version(build_path, verbose)
        cgfx2json.check_version(build_path, verbose)

        self.asset_tool_map = {
            '.png': copy,
            '.dds': copy,
            '.jpg': copy,
            '.ogg': copy,
            '.wav': copy,
            '.mp3': copy,
            '.mp4': copy,
            '.webm': copy,
            '.json': copy,
            '.tar': copy,
            '.tga': tga2png,
            '.dae': dae2json,
            '.obj': obj2json,
            '.material': material2json,
            '.bmfont': bmfont2json,
            '.fnt': bmfont2json,
            '.cgfx': cgfx2json
        }

        self.asset_dst_ext = {
            '.dae': '.dae.json',
            '.obj': '.obj.json',
            '.material': '.material.json',
            '.fnt': '.fnt.json',
            '.cgfx': '.cgfx.json',
            '.tga': '.tga.png'
        }
Exemple #21
0
    def _get_mpg123_tags(self):
        """ Use mpg123 to get the id3tags.

        """

        id3v1 = _mpg123.POINTER(_mpg123.mpg123_id3v1)()
        id3v2 = _mpg123.POINTER(_mpg123.mpg123_id3v2)()
        _check(_mpg123.mpg123_id3(self._mpg123_handle,
                                  _mpg123.byref(id3v1),
                                  _mpg123.byref(id3v2)))

        id3_dict = self._info_dict
        for i in ['tag', 'title', 'artist', 'album', 'year', 'comment',
                  'genre']:
            id3_dict[i] = ''
            try:
                id3_dict[i] = getattr(id3v2.contents, i).contents.p
            except:
                pass
            try:
                temp = getattr(id3v1.contents, i)
                current_i = id3_dict.get(i, b'')
                id3_dict[i] = temp if len(temp) > len(current_i) else current_i
            except:
                pass

        try:
            id3_dict['version'] = id3v2.contents.version
        except:
            pass

        try:
            if id3v2.contents.extras > 0:
                tag_type = id3v2.contents.extra.contents.description.p.decode()
                tag_type = tag_type.decode('utf8', 'replace')
                id3_dict[tag_type] = id3v2.contents.extra.contents.text.p
        except:
            pass

        try:
            if id3v2.contents.texts > 0:
                id3_dict['texts'] = id3v2.contents.text.contents.text.p
        except:
            pass

        # from encodings import aliases
        # encodings = aliases.aliases.values()
        encodings = ['utf8', 'euc-jp']
        magic = Magic()
        for key, value in dict(id3_dict.items()).items():
            if type(value) is not int:
                if not value.strip():
                    id3_dict.pop(key)
                elif type(value) is bytes:
                    id3_dict.pop(key)
                    enc = magic.check(value).decode()
                    enc = os_getenv('MUSIO_LANG', enc)
                    try:
                        id3_dict[key.lower()] = value.decode(enc, 'ignore')
                    except LookupError:
                        id3_dict[key.lower()] = value.decode('utf8', 'ignore')

            else:
                id3_dict.pop(key)
                id3_dict[key.lower()] = value

        return id3_dict
def load_env(env_name):
    ret = os_getenv(env_name)
    if not ret:
        logger.error('%s environment variable is unset!' % env_name)
        exit(1)
    return ret
from locust import TaskSet
from locust import task
from locust import events
import json
from datetime import datetime
import socket
from pprint import pprint
import logging
import os
from os import getenv as os_getenv
import time
import sys
import rsa
import base64

enable_encryption = os_getenv("ENABLE_ENCRYPTION", False)
if enable_encryption == "1":
    enable_encryption = True
else:
    enable_encryption = False

with open('public_P1.pem', mode='rb') as public_P1:
    keydata1 = public_P1.read()
pubkeyp1 = rsa.PublicKey.load_pkcs1(keydata1)
with open('public_P2.pem', mode='rb') as public_P2:
    keydata2 = public_P2.read()
pubkeyp2 = rsa.PublicKey.load_pkcs1(keydata2)

sys.path.append(os.getcwd())

import common.movielens
import json
from datetime import datetime
import socket
from pprint import pprint
import logging
import os
import time
from os import getenv as os_getenv
import rsa
import pandas as pd
import base64
import random
import traceback
from Crypto.Cipher import AES

enable_encryption = os_getenv("ENABLE_ENCRYPTION", False)
if enable_encryption == "1":
    enable_encryption = True
else:
    enable_encryption = False

USER_KEY_LEN = 16

ASYNC_FLUENTD = os_getenv("ASYNC_FLUENTD", "false")
if ASYNC_FLUENTD == "true":
    from fluent import asyncsender as fluentd_sender
else:
    from fluent import sender as fluentd_sender

TIMEOUT_REQUEST = os_getenv("TIMEOUT_REQUEST", 800)
PERIOD_REQUEST = os_getenv("PERIOD_REQUEST", 1000)
from locust import HttpLocust
from locust import TaskSet
from locust import task
from locust import events
import json
from datetime import datetime
import socket
from pprint import pprint
import logging
import os
import time
from os import getenv as os_getenv
#from fluent import asyncsender as sender
from fluent import sender

RANDOM_SEED = os_getenv("RANDOM_SEED", 0)
HOSTNAME = os_getenv("HOSTNAME", "host")
logger = logging.getLogger(__name__)
logger.setLevel(os.getenv("LOCUST_LOG_LEVEL", "INFO").upper())
fmt_pattern = '{"time":"%(asctime)s.%(msecs)03dZ", ' \
              '"loglevel":"%(levelname)s", "hostname":"' \
              + HOSTNAME + '", "message":%(message)s}'
datefmt_pattern = '%Y-%m-%dT%H:%M:%S'                       # date format
fluentd_host = os.getenv("LOCUST_FLUENTD_HOST", None)
xp_name = os.getenv("XP_NAME", "test")
xp_name = "{}.{}".format(
    "private-recsys",
    xp_name
)
print ("Starting experiment " + xp_name)
if fluentd_host:
Exemple #26
0
 def __read_environment_variable(self, value):
     if value.startswith('$'):
         return os_getenv(value[1:])
     return value
Exemple #27
0
 def test_add_empty_variable(self):
     original = os_getenv("MYVAR")
     envcontext = EnvContext(MYVAR="")
     with envcontext:
         self.assertNotEqual(original, os_getenv("MYVAR"))
     self.assertEqual(original, os_getenv("MYVAR"))
Exemple #28
0
def force_getenv(var_name):
    var_value = os_getenv(var_name)
    if var_value == None:
        raise Exception("Environ variable $%s not set" % var_name)
    return var_value
Exemple #29
0
from os import path as os_path
from os import getenv as os_getenv
from settings import SETTINGS

###############################################################################
### Constants ###

# Actual constants.py full path directory name
SCRIPT_PATH = os_path.dirname(os_path.realpath(__file__))

# General Bots Parameters
CONST = {

    # Bot Public or Private
    "BOT_PRIVATE": \
        bool(int(os_getenv("CAPTCHABOT_PRIVATE", \
            SETTINGS["CAPTCHABOT_PRIVATE"]))),

    # Bot Token (get it from @BotFather)
    "TOKEN": \
        os_getenv("CAPTCHABOT_TOKEN", SETTINGS["CAPTCHABOT_TOKEN"]),

    # Bot Owner (i.e. "@JoseTLG" or "123456789")
    "BOT_OWNER": \
        os_getenv("CAPTCHABOT_OWNER", SETTINGS["CAPTCHABOT_OWNER"]),

    # Bot Webhook Host addres (keep in None for Polling or set to a
    # valid address for Webhook)
    "WEBHOOK_HOST": \
        os_getenv("CAPTCHABOT_WEBHOOK_HOST", \
            SETTINGS["CAPTCHABOT_WEBHOOK_HOST"]),
Exemple #30
0
from os import getenv as os_getenv
from os import path as os_path
from sys import path as sys_path

sys_path.append(os_path.abspath(os_path.join(os_path.dirname(__file__), '..')))


from flask_script import Manager, Server
from application import create_app


from common import SERVER_PORT, SERVER_IP


app = create_app()
manager = Manager(app)


manager.add_command("runserver", Server(
    use_debugger=True,
    use_reloader=True,
    host=os_getenv('IP', SERVER_IP),
    port=int(os_getenv('PORT', SERVER_PORT)))
)


if __name__ == "__main__":
    manager.run()