def process_svg_image(
    ctx,
    source_image,
    dst_filename,
    width=None,
    height=None,
    mode=None,
):
    if width is None and height is None:
        raise ValueError("Must specify at least one of width or height.")

    # Because Lektor doesn't have a generic find program (only imagemagick),
    # only *nix is supported for simplicity. Imagemagick will be used as the
    # fallback on Windows, but it won't work well...
    if os.name == 'nt':
        return process_image(ctx, source_image, dst_filename, width, height,
                             mode, 85)

    inkscape = locate_executable('inkscape')

    cmdline = [inkscape, source_image]

    if width is not None:
        cmdline += ["-w", str(width)]
    if height is not None:
        cmdline += ["-h", str(height)]

    # FIXME: This will only work with inkscape 1.0+
    cmdline += ["--export-filename", dst_filename]

    reporter.report_debug_info("inkscape cmd line", cmdline)
    portable_popen(cmdline).wait()
Beispiel #2
0
def process_image(ctx,
                  source_image,
                  dst_filename,
                  width=None,
                  height=None,
                  mode=ThumbnailMode.DEFAULT,
                  quality=None,
                  offset=None,
                  zoom=None):
    """Build image from source image, optionally compressing and resizing.

    "source_image" is the absolute path of the source in the content directory,
    "dst_filename" is the absolute path of the target in the output directory.
    """
    if width is None and height is None:
        raise ValueError("Must specify at least one of width or height.")

    im = find_imagemagick(ctx.build_state.config["IMAGEMAGICK_EXECUTABLE"])

    if quality is None:
        quality = get_quality(source_image)

    resize_key = ''
    offset_key = ''
    gravity = 'Center'
    zoom_key = '100%'
    if width is not None:
        resize_key += str(width)
    if height is not None:
        resize_key += 'x' + str(height)
    if offset is not None and len(offset) == 2:
        offset_key = '%+d%+d' % ((offset[0] - width / 2),
                                 (offset[1] - height / 2))
        gravity = 'NorthWest'
    if zoom is not None:
        zoom_key = '%d' % zoom + '%'

    print(gravity, offset_key, zoom_key, dst_filename)

    if mode == ThumbnailMode.STRETCH:
        resize_key += "!"

    cmdline = [im, source_image, "-auto-orient"]
    if mode == ThumbnailMode.CROP:
        cmdline += [
            '-resize',
            zoom_key,
            '-gravity',
            gravity,
            '-extent',
            resize_key + offset_key,
        ]
    else:
        cmdline += ["-resize", resize_key]

    cmdline += ["-strip", "-colorspace", "sRGB"]
    cmdline += ["-quality", str(quality), dst_filename]

    reporter.report_debug_info("imagemagick cmd line", cmdline)
    portable_popen(cmdline).wait()
Beispiel #3
0
 def parse_templates(self, to_filename):
     pybabel=locate_executable('pybabel')
     if pybabel is None:
         pybabel="/usr/bin/pybabel"
     cmdline=[pybabel, 'extract', '-F', 'babel.cfg', "-o", to_filename, "./"]
     reporter.report_debug_info('pybabel cmd line', cmdline)
     portable_popen(cmdline).wait()
Beispiel #4
0
def process_image(ctx, source_image, dst_filename, width, height=None,
                  crop=False):
    """Build image from source image, optionally compressing and resizing.

    "source_image" is the absolute path of the source in the content directory,
    "dst_filename" is the absolute path of the target in the output directory.
    """
    im = find_imagemagick(
        ctx.build_state.config['IMAGEMAGICK_EXECUTABLE'])

    quality = get_quality(source_image)

    resize_key = str(width)
    if height is not None:
        resize_key += 'x' + str(height)

    cmdline = [im, source_image]
    if crop:
        cmdline += ['-resize', resize_key + '^',
                    '-gravity', 'Center',
                    '-extent', resize_key]
    else:
        cmdline += ['-resize', resize_key]

    cmdline += ['-auto-orient', '-quality', str(quality), dst_filename]

    reporter.report_debug_info('imagemagick cmd line', cmdline)
    portable_popen(cmdline).wait()
Beispiel #5
0
def process_image(ctx,
                  source_image,
                  dst_filename,
                  width,
                  height=None,
                  crop=False):
    """Build image from source image, optionally compressing and resizing.

    "source_image" is the absolute path of the source in the content directory,
    "dst_filename" is the absolute path of the target in the output directory.
    """
    im = find_imagemagick(ctx.build_state.config['IMAGEMAGICK_EXECUTABLE'])

    quality = get_quality(source_image)

    resize_key = str(width)
    if height is not None:
        resize_key += 'x' + str(height)

    cmdline = [im, source_image]
    if crop:
        cmdline += [
            '-resize', resize_key + '^', '-gravity', 'Center', '-extent',
            resize_key
        ]
    else:
        cmdline += ['-resize', resize_key]

    cmdline += ['-auto-orient', '-quality', str(quality), dst_filename]

    reporter.report_debug_info('imagemagick cmd line', cmdline)
    portable_popen(cmdline).wait()
 def merge_pot(self, from_filenames, to_filename):
     msgcat=locate_executable('msgcat')
     cmdline=[msgcat, "--use-first"]
     cmdline.extend(from_filenames)
     cmdline.extend(("-o", to_filename))
     reporter.report_debug_info('msgcat cmd line', cmdline)
     portable_popen(cmdline).wait()
Beispiel #7
0
 def merge_pot(self, from_filenames, to_filename):
     msgcat = locate_executable('msgcat')
     cmdline = [msgcat, "--use-first"]
     cmdline.extend(from_filenames)
     cmdline.extend(("-o", to_filename))
     reporter.report_debug_info('msgcat cmd line', cmdline)
     portable_popen(cmdline).wait()
Beispiel #8
0
 def _msg_init(self):
     """Generates the first <language>.po file"""
     msginit = locate_executable('msginit')
     cmdline = [
         msginit, "-i", "contents.pot", "-l", self.language, "-o",
         self.FILENAME_PATTERN % self.language, "--no-translator"
     ]
     reporter.report_debug_info('msginit cmd line', cmdline)
     portable_popen(cmdline, cwd=self.i18npath).wait()
Beispiel #9
0
 def _msg_merge(self):
     """Merges an existing <language>.po file with .pot file"""
     msgmerge = locate_executable('msgmerge')
     cmdline = [
         msgmerge, self.FILENAME_PATTERN % self.language, "contents.pot",
         "-U", "-N", "--backup=simple"
     ]
     reporter.report_debug_info('msgmerge cmd line', cmdline)
     portable_popen(cmdline, cwd=self.i18npath).wait()
Beispiel #10
0
 def _msg_fmt(self, locale_dirname):
     """Compile an existing <language>.po file into a .mo file"""
     msgfmt = locate_executable('msgfmt')
     cmdline = [
         msgfmt, self.FILENAME_PATTERN % self.language, "-o",
         join(locale_dirname, "contents.mo")
     ]
     reporter.report_debug_info('msgfmt cmd line', cmdline)
     portable_popen(cmdline, cwd=self.i18npath).wait()
Beispiel #11
0
 def start(self):
     if self.watcher is not None:
         return
     from lektor import admin
     admin = os.path.dirname(admin.__file__)
     portable_popen(['npm', 'install', '.'], cwd=admin).wait()
     self.watcher = portable_popen(
         ['../node_modules/.bin/webpack', '--watch'],
         cwd=os.path.join(admin, 'static'))
Beispiel #12
0
 def start(self):
     if self.watcher is not None:
         return
     from lektor import admin
     admin = os.path.dirname(admin.__file__)
     portable_popen(['npm', 'install', '.'], cwd=admin).wait()
     self.watcher = portable_popen(['../node_modules/.bin/webpack',
                                    '--watch'],
                                   cwd=os.path.join(admin, 'static'))
 def parse_templates(self, to_filename):
     pybabel = locate_executable('pybabel')
     cmdline = [
         pybabel, 'extract', '-F', 'babel.cfg', "-o", to_filename, "./"
     ]
     reporter.report_debug_info('pybabel cmd line', cmdline)
     try:
         portable_popen(cmdline).wait()
     except TypeError as err:
         traceback.print_exc(file=sys.stderr)
         print(err)
Beispiel #14
0
    def build_thumbnail_artifact(artifact):
        resize_key = str(width)
        if height is not None:
            resize_key += 'x' + str(height)
        artifact.ensure_dir()

        cmdline = [im, source_image, '-resize', resize_key,
                   '-auto-orient', '-quality', str(quality),
                   artifact.dst_filename]

        reporter.report_debug_info('imagemagick cmd line', cmdline)
        portable_popen(cmdline).wait()
Beispiel #15
0
    def install_node_dependencies(self):
        webpack_root = os.path.join(self.env.root_path, 'webpack')

        # Use yarn over npm if it's availabe and there is a yarn lockfile
        has_yarn_lockfile = os.path.exists(
            os.path.join(webpack_root, 'yarn.lock'))
        pkg_manager = 'npm'
        if locate_executable('yarn') is not None and has_yarn_lockfile:
            pkg_manager = 'yarn'

        reporter.report_generic('Running {} install'.format(pkg_manager))
        portable_popen([pkg_manager, 'install'], cwd=webpack_root).wait()
Beispiel #16
0
    def start(self):
        if self.watcher is not None:
            return
        from lektor import admin

        admin = os.path.dirname(admin.__file__)
        portable_popen(["npm", "install", "."], cwd=admin).wait()

        self.watcher = portable_popen(
            [os.path.join(admin, "node_modules/.bin/webpack"), "--watch"],
            cwd=os.path.join(admin, "static"),
        )
Beispiel #17
0
 def run_uncss(self, sources, output):
     npm_root = os.path.join(self.env.root_path, ".")
     args = [os.path.join(npm_root, "node_modules", ".bin", "uncss")]
     args.extend(sources)
     args.append("-n")
     args.append("-o")
     args.append(output)
     ignore = self.options.get("uncss.ignore", "")
     if len(ignore) > 0:
         args.append("-i")
         args.append(ignore)
     portable_popen(args, cwd=npm_root).wait()
Beispiel #18
0
 def on_setup_env(self, **extra):
     # add all functions which should be visible from the jinja2 templates
     self.env.jinja_env.globals.update(
         get_year=get_year,
         generate_download_section=generate_download_section,
         generate_maintainer_overview=generate_maintainer_overview,
         generate_news_section=news.generate_news_section,
         # for the slug generation
         slugify=slugify)
     # craft temporary POT file with languages
     now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M')
     now += '+%s' % (time.tzname[0])
     pot = [
         re.sub(
             '\n\\s+', '\n', """msgid ""\nmsgstr ""\n
             "Project-Id-Version: 0.0.0\\n"
             "Report-Msgid-Bugs-To: [email protected]\\n"
             "POT-Creation-Date: {}s\\n"\n "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\\n"
             "Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"
             "Language-Team: FreeDict <*****@*****.**>\\n"
             "Language: LANGUAGE\\n"
             "MIME-Version: 1.0\\n"\n"Content-Type: text/plain; charset=UTF-8\\n"
             "Content-Transfer-Encoding: 8bit\\n"\n""".format(now))
     ]
     for lang in sorted(self.get_used_languages()):
         pot.append('\n#: iso-639-3.tab (no:lineno)\n')
         pot.append('msgid "{}"\nmsgstr ""\n'.format(lang))
     if not os.path.exists("i18n"):
         os.mkdir("i18n")
     lang_pot = tempfile.NamedTemporaryFile(suffix='pot')
     lang_pot.write(''.join(pot).encode('UTF-8'))
     lang_pot.flush()
     plugin_pot = tempfile.NamedTemporaryFile(suffix='pot')
     # retrieve relative path from lektor project root
     directory = os.path.dirname(os.path.abspath(__file__))
     directory = directory.replace(os.getcwd() + os.sep, '')
     pyfiles = [
         os.path.join(directory, f) for f in os.listdir(directory)
         if f.endswith('.py')
     ]
     xgettext = portable_popen([
         'xgettext', '-L', 'Python', '--from-code=UTF-8', '-o',
         plugin_pot.name
     ] + pyfiles)
     ret = xgettext.wait()
     if ret:
         raise OSError('xgettext exited with %d' % ret)
     with open(os.path.join('i18n', 'plugins.pot'), 'wb') as f:
         portable_popen([
             'msgcat', "--use-first", lang_pot.name, '-t', 'UTF-8',
             plugin_pot.name
         ],
                        stdout=f).wait()
Beispiel #19
0
    def start(self):
        if self.watcher is not None:
            return
        self.signal_state = self.env.plugin_controller.emit('devtools_start')

        from lektor import admin
        admin = os.path.dirname(admin.__file__)
        portable_popen(['npm', 'install', '.'], cwd=admin).wait()

        self.watcher = portable_popen([os.path.join(
            admin, 'node_modules/.bin/webpack'), '--watch'],
            cwd=os.path.join(admin, 'static'))
Beispiel #20
0
    def build_thumbnail_artifact(artifact):
        resize_key = str(width)
        if height is not None:
            resize_key += 'x' + str(height)
        artifact.ensure_dir()

        cmdline = [
            im, source_image, '-resize', resize_key, '-quality',
            str(quality), artifact.dst_filename
        ]

        reporter.report_debug_info('imagemagick cmd line', cmdline)
        portable_popen(cmdline).wait()
Beispiel #21
0
def install_local_package(package_root, path):
    """This installs a local dependency of a package."""
    # XXX: windows
    env = dict(os.environ)
    env["PYTHONPATH"] = package_root

    # Step 1: generate egg info and link us into the target folder.
    rv = portable_popen(
        [
            sys.executable,
            "-m",
            "pip",
            "install",
            "--editable",
            path,
            "--install-option=--install-dir=%s" % package_root,
            "--no-deps",
        ],
        env=env,
    ).wait()
    if rv != 0:
        raise RuntimeError("Failed to install local package")

    # Step 2: generate the egg info into a temp folder to find the
    # requirements.
    tmp = tempfile.mkdtemp()
    try:
        rv = portable_popen(
            [
                sys.executable,
                "setup.py",
                "--quiet",
                "egg_info",
                "--quiet",
                "--egg-base",
                tmp,
            ],
            cwd=path,
        ).wait()
        dirs = os.listdir(tmp)
        if rv != 0 or len(dirs) != 1:
            raise RuntimeError("Failed to create egg info for local package.")
        requires = os.path.join(tmp, dirs[0], "requires.txt")

        # We have dependencies, install them!
        if os.path.isfile(requires):
            download_and_install_package(package_root,
                                         requirements_file=requires)
    finally:
        shutil.rmtree(tmp)
Beispiel #22
0
def process_image(
    ctx,
    source_image,
    dst_filename,
    width=None,
    height=None,
    mode=ThumbnailMode.DEFAULT,
    quality=None,
):
    """Build image from source image, optionally compressing and resizing.

    "source_image" is the absolute path of the source in the content directory,
    "dst_filename" is the absolute path of the target in the output directory.
    """
    if width is None and height is None:
        raise ValueError("Must specify at least one of width or height.")

    im = find_imagemagick(ctx.build_state.config["IMAGEMAGICK_EXECUTABLE"])

    if quality is None:
        quality = get_quality(source_image)

    resize_key = ""
    if width is not None:
        resize_key += str(width)
    if height is not None:
        resize_key += "x" + str(height)

    if mode == ThumbnailMode.STRETCH:
        resize_key += "!"

    cmdline = [im, source_image, "-auto-orient"]
    if mode == ThumbnailMode.CROP:
        cmdline += [
            "-resize",
            resize_key + "^",
            "-gravity",
            "Center",
            "-extent",
            resize_key,
        ]
    else:
        cmdline += ["-resize", resize_key]

    cmdline += ["-strip", "-colorspace", "sRGB"]
    cmdline += ["-quality", str(quality), dst_filename]

    reporter.report_debug_info("imagemagick cmd line", cmdline)
    portable_popen(cmdline).wait()
Beispiel #23
0
def requirements_from_unfinished_editable_install_at_path(path):
    # Step 2: generate the egg info into a temp folder to find the
    # requirements.
    tmp = tempfile.mkdtemp()
    try:
        rv = portable_popen(
            [
                sys.executable,
                "setup.py",
                "--quiet",
                "egg_info",
                "--quiet",
                "--egg-base",
                tmp,
            ],
            cwd=path,
        ).wait()
        dirs = os.listdir(tmp)
        if rv != 0 or len(dirs) != 1:
            raise RuntimeError("Failed to create egg info for local package.")
        requires_path = os.path.join(tmp, dirs[0], "requires.txt")

        if os.path.isfile(requires_path):
            # We have dependencies, install them!
            return requirements_from_requires_file(requires_path)
    finally:
        shutil.rmtree(tmp)

    # no dependencies to install
    return None
Beispiel #24
0
    def build_artifact(self, artifact):
        ctx = get_ctx()
        source_out = self.build_state.make_named_temporary('less')
        map_out = self.build_state.make_named_temporary('less-sourcemap')
        here = os.path.dirname(self.source.source_filename)

        exe = self.build_state.config['LESSC_EXECUTABLE']
        if exe is None:
            exe = 'lessc'

        cmdline = [exe, '--no-js', '--include-path=%s' % here,
                   '--source-map=%s' % map_out,
                   self.source.source_filename,
                   source_out]

        reporter.report_debug_info('lessc cmd line', cmdline)

        proc = portable_popen(cmdline)
        if proc.wait() != 0:
            raise RuntimeError('lessc failed')

        with open(map_out) as f:
            for dep in json.load(f).get('sources') or ():
                ctx.record_dependency(os.path.join(here, dep))

        artifact.replace_with_file(source_out)

        @ctx.sub_artifact(artifact_name=artifact.artifact_name + '.map',
                          sources=[self.source.source_filename])
        def build_less_sourcemap_artifact(artifact):
            artifact.replace_with_file(map_out)
Beispiel #25
0
    def build_artifact(self, artifact):
        ctx = get_ctx()
        source_out = self.build_state.make_named_temporary('less')
        map_out = self.build_state.make_named_temporary('less-sourcemap')
        here = os.path.dirname(self.source.source_filename)

        exe = self.build_state.config['LESSC_EXECUTABLE']
        if exe is None:
            exe = 'lessc'

        cmdline = [
            exe, '--no-js',
            '--include-path=%s' % here,
            '--source-map=%s' % map_out, self.source.source_filename,
            source_out
        ]

        reporter.report_debug_info('lessc cmd line', cmdline)

        proc = portable_popen(cmdline)
        if proc.wait() != 0:
            raise RuntimeError('lessc failed')

        with open(map_out) as f:
            for dep in json.load(f).get('sources') or ():
                ctx.record_dependency(os.path.join(here, dep))

        artifact.replace_with_file(source_out)

        @ctx.sub_artifact(artifact_name=artifact.artifact_name + '.map',
                          sources=[self.source.source_filename])
        def build_less_sourcemap_artifact(artifact):
            artifact.replace_with_file(map_out)
    def build_thumbnail_artifact(artifact):
        artifact.ensure_dir()

        vfilter = 'thumbnail,scale={rw}:{rh},crop={tw}:{th}'.format(
            rw=resize_dim.width,
            rh=resize_dim.height,
            tw=crop_dim.width,
            th=crop_dim.height,
        )

        cmdline = [
            ffmpeg,
            '-loglevel', '-8',
            '-ss', get_timecode(seek),  # Input seeking since it's faster
            '-i', source_video,
            '-vf', vfilter,
            '-frames:v', '1',
            '-qscale:v', str(get_ffmpeg_quality(quality)),
            artifact.dst_filename,
        ]

        reporter.report_debug_info('ffmpeg cmd line', cmdline)
        proc = portable_popen(cmdline)
        if proc.wait() != 0:
            raise RuntimeError(
                'ffmpeg exited with code {}'.format(proc.returncode))

        if not os.path.exists(artifact.dst_filename):
            msg = ('Unable to create video thumbnail for {!r}. Maybe the seek '
                   'is outside of the video duration?')
            raise RuntimeError(msg.format(source_video))
Beispiel #27
0
    def build_artifact(self, artifact):
        ctx = get_ctx()
        source_out = self.build_state.make_named_temporary("less")
        map_out = self.build_state.make_named_temporary("less-sourcemap")
        here = os.path.dirname(self.source.source_filename)

        cmdline = [
            "lessc",
            "--no-js",
            "--include-path=%s" % here,
            "--source-map=%s" % map_out,
            self.source.source_filename,
            source_out,
        ]

        reporter.report_debug_info("lessc cmd line", cmdline)

        proc = portable_popen(cmdline)
        if proc.wait() != 0:
            raise RuntimeError("lessc failed")

        with open(map_out) as f:
            dep_base = os.path.dirname(map_out)
            for dep in json.load(f).get("sources") or ():
                ctx.record_dependency(os.path.join(dep_base, dep))

        artifact.replace_with_file(source_out)
Beispiel #28
0
def get_package_info(path):
    """Returns the name of a package at a path."""
    rv = (portable_popen(
        [
            sys.executable,
            "setup.py",
            "--quiet",
            "--name",
            "--author",
            "--author-email",
            "--license",
            "--url",
        ],
        cwd=path,
        stdout=PIPE,
    ).communicate()[0].splitlines())

    def _process(value):
        value = value.strip()
        if value == "UNKNOWN":
            return None
        return value.decode("utf-8", "replace")

    return {
        "name": _process(rv[0]),
        "author": _process(rv[1]),
        "author_email": _process(rv[2]),
        "license": _process(rv[3]),
        "url": _process(rv[4]),
        "path": path,
    }
Beispiel #29
0
def download_and_install_package(package_root,
                                 package=None,
                                 version=None,
                                 requirements_file=None):
    """This downloads and installs a specific version of a package."""
    # XXX: windows
    env = dict(os.environ)

    args = [
        sys.executable,
        "-m",
        "pip",
        "install",
        "--target",
        package_root,
    ]

    if package is not None:
        args.append("%s%s%s" %
                    (package, version and "==" or "", version or ""))
    if requirements_file is not None:
        args.extend(("-r", requirements_file))

    rv = portable_popen(args, env=env).wait()
    if rv != 0:
        raise RuntimeError("Failed to install dependency package.")
Beispiel #30
0
 def __init__(self,
              argline,
              cwd=None,
              env=None,
              capture=True,
              silent=False):
     environ = dict(os.environ)
     if env:
         environ.update(env)
     kwargs = {"cwd": cwd, "env": environ}
     if silent:
         kwargs["stdout"] = subprocess.DEVNULL
         kwargs["stderr"] = subprocess.DEVNULL
         capture = False
     if capture:
         kwargs["stdout"] = subprocess.PIPE
         kwargs["stderr"] = subprocess.STDOUT
         if sys.version_info >= (3, 7):
             # Python >= 3.7 has sane encoding defaults in the case that the system is
             # (likely mis-)configured to use ASCII as the default encoding (PEP538).
             # It also provides a way for the user to force the use of UTF-8 (PEP540).
             kwargs["text"] = True
         else:
             kwargs["encoding"] = "utf-8"
         kwargs["errors"] = "replace"
     self.capture = capture
     self._cmd = portable_popen(argline, **kwargs)
 def run_brunch(self, build_flags, watch=False):
     brunch_root = os.path.join(self.env.root_path, 'brunch')
     args = [os.path.join(brunch_root, 'node_modules', '.bin', 'brunch')]
     if watch:
         args.append('watch')
     else:
         args.append('build')
     if self.is_production(build_flags):
         args.append('--production')
     return portable_popen(args, cwd=brunch_root)
 def __init__(self, argline, cwd=None, env=None, capture=True):
     environ = dict(os.environ)
     if env:
         environ.update(env)
     kwargs = {'cwd': cwd, 'env': env}
     if capture:
         kwargs['stdout'] = subprocess.PIPE
         kwargs['stderr'] = subprocess.PIPE
     self.capture = capture
     self._cmd = portable_popen(argline, **kwargs)
Beispiel #33
0
def process_image(ctx,
                  source_image,
                  dst_filename,
                  width=None,
                  height=None,
                  mode=ThumbnailMode.DEFAULT,
                  quality=None):
    """Build image from source image, optionally compressing and resizing.

    "source_image" is the absolute path of the source in the content directory,
    "dst_filename" is the absolute path of the target in the output directory.
    """
    if width is None and height is None:
        raise ValueError("Must specify at least one of width or height.")

    im = find_imagemagick(ctx.build_state.config['IMAGEMAGICK_EXECUTABLE'])

    if quality is None:
        quality = get_quality(source_image)

    resize_key = ''
    if width is not None:
        resize_key += str(width)
    if height is not None:
        resize_key += 'x' + str(height)

    if mode == ThumbnailMode.STRETCH:
        resize_key += '!'

    cmdline = [im, source_image, '-auto-orient']
    if mode == ThumbnailMode.CROP:
        cmdline += [
            '-resize', resize_key + '^', '-gravity', 'Center', '-extent',
            resize_key
        ]
    else:
        cmdline += ['-resize', resize_key]

    cmdline += ['-quality', str(quality), dst_filename]

    reporter.report_debug_info('imagemagick cmd line', cmdline)
    portable_popen(cmdline).wait()
Beispiel #34
0
 def publish(self, target_url):
     argline = self.get_command_line(target_url)
     cmd = portable_popen(argline, stdout=subprocess.PIPE)
     try:
         while 1:
             line = cmd.stdout.readline()
             if not line:
                 break
             yield line.rstrip().decode('utf-8', 'replace')
     finally:
         cmd.wait()
Beispiel #35
0
 def run_package_manager(self, *args):
     # Use yarn over npm if it's availabe and there is a yarn lockfile
     has_yarn_lockfile = os.path.exists(
         self.get_webpack_folder('yarn.lock'))
     pkg_manager = 'npm'
     if locate_executable('yarn') is not None and has_yarn_lockfile:
         pkg_manager = 'yarn'
     reporter.report_generic('Running {} {}'.format(pkg_manager,
                                                    " ".join(args)))
     return portable_popen([pkg_manager] + list(args),
                           cwd=self.get_webpack_folder())
Beispiel #36
0
 def publish(self, target_url):
     argline = self.get_command_line(target_url)
     cmd = portable_popen(argline, stdout=subprocess.PIPE)
     try:
         while 1:
             line = cmd.stdout.readline()
             if not line:
                 break
             yield line.rstrip().decode('utf-8', 'replace')
     finally:
         cmd.wait()
Beispiel #37
0
def get_video_info(filename):
    """Read video information using ffprobe if available.

    Returns a dict with: width, height and duration.
    """
    ffprobe = locate_executable("ffprobe")
    if ffprobe is None:
        raise RuntimeError("Failed to locate ffprobe")

    proc = portable_popen(
        [
            ffprobe,
            "-v",
            "quiet",
            "-print_format",
            "json",
            "-show_format",
            "-show_streams",
            filename,
        ],
        stdout=subprocess.PIPE,
    )
    stdout, _ = proc.communicate()

    if proc.returncode != 0:
        raise RuntimeError("ffprobe exited with code %d" % proc.returncode)

    ffprobe_data = json.loads(stdout.decode("utf8"))
    info = {
        "width": None,
        "height": None,
        "duration": None,
    }

    # Try to extract total video duration
    try:
        info["duration"] = timedelta(
            seconds=float(ffprobe_data["format"]["duration"]))
    except (KeyError, TypeError, ValueError):
        pass

    # Try to extract width and height from the first found video stream
    for stream in ffprobe_data["streams"]:
        if stream["codec_type"] != "video":
            continue

        info["width"] = int(stream["width"])
        info["height"] = int(stream["height"])

        # We currently don't bother with multiple video streams
        break

    return info
def process_image(
    ctx,
    source_image,
    dst_filename,
    width=None,
    height=None,
    mode=None,
    quality=None,
    extra_params=None,
):
    """Build image from source image, optionally compressing and resizing.
    "source_image" is the absolute path of the source in the content directory,
    "dst_filename" is the absolute path of the target in the output directory.
    """
    if width is None and height is None:
        raise ValueError("Must specify at least one of width or height.")

    im = find_imagemagick(ctx.build_state.config["IMAGEMAGICK_EXECUTABLE"])

    if quality is None:
        quality = get_quality(source_image)

    resize_key = ""
    if width is not None:
        resize_key += str(width)
    if height is not None:
        resize_key += "x" + str(height)

    cmdline = [im, source_image, "-auto-orient"]
    cmdline += ["-resize", resize_key]

    if extra_params:
        cmdline.extend(extra_params)

    cmdline += ["-quality", str(quality), dst_filename]

    reporter.report_debug_info("imagemagick cmd line", cmdline)
    portable_popen(cmdline).wait()
Beispiel #39
0
 def __init__(self, argline, cwd=None, env=None, capture=True, silent=False):
     environ = dict(os.environ)
     if env:
         environ.update(env)
     kwargs = {"cwd": cwd, "env": environ}
     if silent:
         kwargs["stdout"] = devnull
         kwargs["stderr"] = devnull
         capture = False
     if capture:
         kwargs["stdout"] = subprocess.PIPE
         kwargs["stderr"] = subprocess.PIPE
     self.capture = capture
     self._cmd = portable_popen(argline, **kwargs)
Beispiel #40
0
def install_local_package(package_root, path):
    """This installs a local dependency of a package."""
    # XXX: windows
    env = dict(os.environ)
    env['PYTHONPATH'] = package_root

    # Step 1: generate egg info and link us into the target folder.
    rv = portable_popen([
        sys.executable,
        '-m', 'pip',
        'install', '--editable', path,
        '--install-option=--install-dir=%s' % package_root,
        '--no-deps'
    ], env=env).wait()
    if rv != 0:
        raise RuntimeError('Failed to install local package')

    # Step 2: generate the egg info into a temp folder to find the
    # requirements.
    tmp = tempfile.mkdtemp()
    try:
        rv = portable_popen([
            sys.executable,
            'setup.py', '--quiet', 'egg_info', '--quiet',
            '--egg-base', tmp
        ], cwd=path).wait()
        dirs = os.listdir(tmp)
        if rv != 0 or len(dirs) != 1:
            raise RuntimeError('Failed to create egg info for local package.')
        requires = os.path.join(tmp, dirs[0], 'requires.txt')

        # We have dependencies, install them!
        if os.path.isfile(requires):
            download_and_install_package(package_root,
                                         requirements_file=requires)
    finally:
        shutil.rmtree(tmp)
Beispiel #41
0
 def __init__(self, argline, cwd=None, env=None, capture=True,
              silent=False):
     environ = dict(os.environ)
     if env:
         environ.update(env)
     kwargs = {'cwd': cwd, 'env': environ}
     if silent:
         self.devnull = open(os.devnull, 'rb+')
         kwargs['stdout'] = self.devnull
         kwargs['stderr'] = self.devnull
         capture = False
     if capture:
         kwargs['stdout'] = subprocess.PIPE
         kwargs['stderr'] = subprocess.PIPE
     self.capture = capture
     self._cmd = portable_popen(argline, **kwargs)
Beispiel #42
0
def download_and_install_package(package_root, package=None, version=None,
                                 requirements_file=None):
    """This downloads and installs a specific version of a package."""
    # XXX: windows
    env = dict(os.environ)

    args = [
        sys.executable,
        '-m', 'pip', 'install', '--target', package_root,
    ]

    if package is not None:
        args.append('%s%s%s' % (package, version and '==' or '',
                                version or ''))
    if requirements_file is not None:
        args.extend(('-r', requirements_file))

    rv = portable_popen(args, env=env).wait()
    if rv != 0:
        raise RuntimeError('Failed to install dependency package.')
Beispiel #43
0
def get_package_info(path):
    """Returns the name of a package at a path."""
    rv = portable_popen([
        sys.executable,
        'setup.py', '--quiet', '--name', '--author', '--author-email',
        '--license', '--url',
    ], cwd=path, stdout=PIPE).communicate()[0].splitlines()
    def _process(value):
        value = value.strip()
        if value == 'UNKNOWN':
            return None
        return value.decode('utf-8', 'replace')
    return {
        'name': _process(rv[0]),
        'author': _process(rv[1]),
        'author_email': _process(rv[2]),
        'license': _process(rv[3]),
        'url': _process(rv[4]),
        'path': path,
    }
 def parse_templates(self, to_filename):
     pybabel=locate_executable('pybabel')
     cmdline=[pybabel, 'extract', '-F', 'babel.cfg', "-o", to_filename, "./"]
     reporter.report_debug_info('pybabel cmd line', cmdline)
     portable_popen(cmdline).wait()
 def _msg_init(self):
     """Generates the first <language>.po file"""
     msginit=locate_executable('msginit')
     cmdline=[msginit, "-i", "contents.pot", "-l", self.language, "-o", self.FILENAME_PATTERN%self.language, "--no-translator"]
     reporter.report_debug_info('msginit cmd line', cmdline)
     portable_popen(cmdline, cwd=self.i18npath).wait()
 def _msg_merge(self):
     """Merges an existing <language>.po file with .pot file"""
     msgmerge=locate_executable('msgmerge')
     cmdline=[msgmerge, self.FILENAME_PATTERN%self.language, "contents.pot", "-U", "-N", "--backup=simple"]
     reporter.report_debug_info('msgmerge cmd line', cmdline)
     portable_popen(cmdline, cwd=self.i18npath).wait()
 def _msg_fmt(self, locale_dirname):
     """Compile an existing <language>.po file into a .mo file"""
     msgfmt=locate_executable('msgfmt')
     cmdline=[msgfmt, self.FILENAME_PATTERN%self.language, "-o", join(locale_dirname,"contents.mo")]
     reporter.report_debug_info('msgfmt cmd line', cmdline)
     portable_popen(cmdline, cwd=self.i18npath).wait()
Beispiel #48
0
def publish_package(path):
    """Registers the plugin at the given path."""
    portable_popen([
        sys.executable,
        'setup.py', 'sdist', 'bdist_wheel', 'upload'
    ], cwd=path).wait()
Beispiel #49
0
def register_package(path):
    """Registers the plugin at the given path."""
    portable_popen([
        sys.executable,
        'setup.py', 'register'
    ], cwd=path).wait()
 def run_webpack(self, watch=False):
     webpack_root = os.path.join(self.env.root_path, 'webpack')
     args = [os.path.join(webpack_root, 'node_modules', '.bin', 'webpack')]
     if watch:
         args.append('--watch')
     return portable_popen(args, cwd=webpack_root)
 def npm_install(self):
     reporter.report_generic('Running npm install')
     webpack_root = os.path.join(self.env.root_path, 'webpack')
     portable_popen(['npm', 'install'], cwd=webpack_root).wait()