예제 #1
0
def GenerateMission(filename):

    # Create XML parser
    parser = make_parser()
    generator = MissionGenerator()
    parser.setContentHandler(generator)

    # Parse KMZ file
    kmz = PyZipFile(filename, 'r')
    kml = kmz.open('doc.kml', 'r')
    parser.parse(kml)

    kmz.close()

    # Arrange the XML items into useful variables
    items = {}
    items['base_location'] = ParseCoordinates(generator.mapping, 'Base')
    items['landing_site'] = ParseCoordinates(generator.mapping, 'Fake reported location')
    items['path'] = ParseCoordinates(generator.mapping, 'Sample Nominal Path')
    items['return_path']= items['path'].reverse()

    items['base_geofence'] = GenerateGeofences(ParseCoordinates(generator.mapping, 'Base geofence'))
    items['landing_site_geofence'] = GenerateGeofences(ParseCoordinates(generator.mapping, 'Sample remote landing site'))
    items['mission_geofence'] = GenerateGeofences(ParseCoordinates(generator.mapping, 'Sample full geofence'))
    
    return items
def compile_src(creator_name: str,
                src_dir: str,
                build_dir: str,
                mods_dir: str,
                mod_name: str = "Untitled") -> None:
    """
    Packages your mod into a proper mod file. It creates 2 mod files, a full mod file which contains all the files
    in the source folder unchanged along with the compiled python versions next to uncompiled ones and a slim mod-file
    which contains only the compiled versions.

    Modified from andrew's code.
    https://sims4studio.com/thread/15145/started-python-scripting

    :param creator_name: The creators name
    :param src_dir: Source dir for the mod files
    :param build_dir: Place to put the mod files
    :param mods_dir: Place to an extra copy of the slim mod file for testing
    :param mod_name: Name to call the mod
    :return: Nothing
    """

    # Prepend creator name to mod name
    mod_name = creator_name + '_' + mod_name
    mods_sub_dir = os.path.join(mods_dir, mod_name)

    # Create ts4script paths
    ts4script_full_build_path = os.path.join(build_dir,
                                             mod_name + '.ts4script')
    ts4script_mod_path = os.path.join(mods_sub_dir, mod_name + '.ts4script')

    print("Clearing out old builds...")

    # Delete and re-create build and sub-folder in Mods
    is_devmode = symlink_exists_win("", mods_dir, mod_name)
    symlink_remove_win("", mods_dir, mod_name)

    if is_devmode:
        print("Exiting Dev Mode...")

    remove_dir(build_dir)

    ensure_path_created(build_dir)
    ensure_path_created(mods_sub_dir)

    print("Re-building mod...")

    # Compile the mod
    zf = PyZipFile(ts4script_full_build_path,
                   mode='w',
                   compression=ZIP_STORED,
                   allowZip64=True,
                   optimize=2)
    compile_full(src_dir, zf)
    zf.close()

    # Copy it over to the mods folder
    shutil.copyfile(ts4script_full_build_path, ts4script_mod_path)

    print("----------")
    print("Complete")
예제 #3
0
def get_module_as_zip_from_module_directory(module_directory, b64enc=True, src=True):
    """Compress a module directory

    @param module_directory: The module directory
    @param base64enc: if True the function will encode the zip file with base64
    @param src: Integrate the source files

    @return: a stream to store in a file-like object
    """

    RE_exclude = re.compile('(?:^\..+\.swp$)|(?:\.py[oc]$)|(?:\.bak$)|(?:\.~.~$)', re.I)

    def _zippy(archive, path, src=True):
        path = os.path.abspath(path)
        base = os.path.basename(path)
        for f in tools.osutil.listdir(path, True):
            bf = os.path.basename(f)
            if not RE_exclude.search(bf) and (src or bf == '__terp__.py' or not bf.endswith('.py')):
                archive.write(os.path.join(path, f), os.path.join(base, f))

    archname = StringIO()
    archive = PyZipFile(archname, "w", ZIP_DEFLATED)
    archive.writepy(module_directory)
    _zippy(archive, module_directory, src=src)
    archive.close()
    val = archname.getvalue()
    archname.close()

    if b64enc:
        val = base64.encodestring(val)

    return val
def debug_install_mod(mod_src: str, mods_dir: str, mod_name: str,
                      mod_folder_name: str) -> None:
    """
    Compiles and installs the mod which adds a cheat code so the user can setup the debugger in-game

    :param mod_src: Path to the script which does this
    :param mods_dir: Path to the users mod folder
    :param mod_name: Name of the mod
    :param mod_folder_name: Name of mod Subfolder
    :return: Nothing
    """

    print("Compiling and installing the cheatcode mod...")

    # Get destination file path
    mods_sub_dir = os.path.join(mods_dir, mod_folder_name)
    mod_path = os.path.join(mods_sub_dir, mod_name + '.ts4script')

    ensure_path_created(mods_sub_dir)

    # Get compiled path and compile mod
    mod_src_pyc = replace_extension(mod_src, "pyc")
    py_compile.compile(mod_src, mod_src_pyc)

    # Create mod at destination and add compiled file to it
    zf = PyZipFile(mod_path,
                   mode='w',
                   compression=ZIP_STORED,
                   allowZip64=True,
                   optimize=2)
    zf.write(mod_src_pyc, mod_name + ".pyc")
    zf.close()
예제 #5
0
def build_zip(dest):
    print "Writing", dest
    from zipfile import PyZipFile

    f = PyZipFile(dest, "w")
    f.writepy("src/singleshot")
    f.writepy("lib")
    f.writepy("lib/simpletal")
    f.close()
예제 #6
0
def compile_module(mod_creator_name=None, root=None, mod_scripts_folder=None, mod_name=None, ignore_folders=None, include_folders=None):
    if not mod_creator_name:
        mod_creator_name = creator_name
    if not mod_name:
        mod_name = os.path.join('..', '..', os.path.basename(os.path.normpath(os.path.dirname(os.path.realpath('__file__')))))
        print('No mod name found, setting the path name to \'{}\'.'.format(mod_name))
    print('The current working directory {}.'.format(os.getcwd()))

    if mod_creator_name:
        print('Mod creator name found, appending mod creator name to file name.')
        mod_name = '{}_{}'.format(mod_creator_name, mod_name)
    script_zip_name = '{}.ts4script'.format(mod_name)
    if not root:
        ts4script = script_zip_name
    else:
        ts4script = os.path.join(root, script_zip_name)

    try:
        if os.path.exists(ts4script):
            print('Script archive found, removing found archive.')
            os.remove(ts4script)
            print('Script archive removed.')
        zf = PyZipFile(ts4script, mode='w', allowZip64=True, optimize=2)
        child_directories = get_child_directories(mod_scripts_folder)
        previous_working_directory = os.getcwd()
        print('Changing the working directory to \'{}\''.format(mod_scripts_folder))
        os.chdir(mod_scripts_folder)
        print('Changed the current working directory \'{}\'.'.format(os.getcwd()))
        # print('Found child directories {}'.format(pformat(tuple(child_directories))))
        for folder in child_directories:
            # print('Attempting to compile {}'.format(folder))
            if ignore_folders is not None and os.path.basename(folder) in ignore_folders:
                # print('Folder is set to be ignored. Continuing to the next folder.')
                continue
            if include_folders is not None and os.path.basename(folder) not in include_folders:
                # print('Folder is not set to be included. Continuing to the next folder.')
                continue
            try:
                print('Compiling folder \'{}\''.format(folder))
                zf.writepy(folder)
                print('\'{}\' compiled successfully.'.format(folder))
            except Exception as ex:
                print('Failed to write {}. {}'.format(folder, ex.args[1]))
                continue
        print('Done compiling files.')
        zf.close()
        print('Changing working directory to previous working directory.')
        os.chdir(previous_working_directory)
        print('Changed the current working directory to \'{}\''.format(os.getcwd()))
    except Exception as ex:
        print('Failed to create {}. {}'.format(ts4script, ex.args[1]))
        return
예제 #7
0
 def build_zip(module_dir):
     # This can fail at writepy if there is something wrong with the files
     #  in xframes.  Go ahead anyway, but things will probably fail if this job is
     #  distributed
     try:
         tf = NamedTemporaryFile(suffix=".zip", delete=False)
         z = PyZipFile(tf, "w")
         z.writepy(module_dir)
         z.close()
         return tf.name
     except:
         logging.warn("Zip file distribution failed -- workers will not get xframes code.")
         logging.warn("Check for unexpected files in xframes directory.")
         return None
예제 #8
0
def compile_module(creator_name, root, mods_folder,mod_name=None):
    src = os.path.join(root, 'Scripts')
    if not mod_name:
        mod_name=os.path.basename(os.path.normpath(os.path.dirname(os.path.realpath('__file__'))))

    mod_name = creator_name + '_' + mod_name
    ts4script = os.path.join(root, mod_name + '.ts4script')

    ts4script_mods = os.path.join(os.path.join(mods_folder), mod_name + '.ts4script')

    zf = PyZipFile(ts4script, mode='w', compression=ZIP_STORED, allowZip64=True, optimize=2)
    for folder, subs, files in os.walk(src):
        zf.writepy(folder)
    zf.close()
    shutil.copyfile(ts4script, ts4script_mods)
 def build_zip(module_dir):
     # This can fail at writepy if there is something wrong with the files
     #  in xframes.  Go ahead anyway, but things will probably fail if this job is
     #  distributed
     try:
         tf = NamedTemporaryFile(suffix='.zip', delete=False)
         z = PyZipFile(tf, 'w')
         z.writepy(module_dir)
         z.close()
         return tf.name
     except:
         logging.warn(
             'Zip file distribution failed -- workers will not get xframes code.'
         )
         logging.warn('Check for unexpected files in xframes directory.')
         return None
예제 #10
0
 def build_zip():
     if 'XPATTERNS_HOME' not in os.environ:
         return None
     # This can fail at writepy if there is something wrong with the files
     #  in xpatterns.  Go ahead anyway, but things will probably fail of this job is
     #  distributed
     try:
         tf = NamedTemporaryFile(suffix='.zip', delete=False)
         z = PyZipFile(tf, 'w')
         z.writepy(os.path.join(os.environ['XPATTERNS_HOME'], 'xpatterns'))
         z.close()
         return tf.name
     except:
         print 'Zip file distribution failed -- workers will not get xpatterns code.'
         print 'Check for unexpected files in XPATTERNS_HOME/xpatterns.'
         return None
예제 #11
0
def collect_python_modules():
    """Collect Eskapade Python modules."""
    import pathlib
    from pkg_resources import resource_filename
    from zipfile import PyZipFile

    import escore

    package_dir = resource_filename(escore.__name__, '')
    lib_path = pathlib.Path(package_dir).joinpath('lib')
    lib_path.mkdir(exist_ok=True)
    archive_path = str(lib_path.joinpath(ARCHIVE_FILE))

    archive_file = PyZipFile(archive_path, 'w')
    logger.info('Adding Python modules to egg archive {path}.'.format(path=archive_path))
    archive_file.writepy(package_dir)
    archive_file.close()
    return archive_path
    def get_zip_from_directory(self, directory, b64enc=True):
        def _zippy(archive, path):
            path = os.path.abspath(path)
            base = os.path.basename(path)
            for f in tools.osutil.listdir(path, True):
                archive.write(os.path.join(path, f), os.path.join(base, f))

        archname = StringIO()
        archive = PyZipFile(archname, "w", ZIP_DEFLATED)
        archive.writepy(directory)
        _zippy(archive, directory)
        archive.close()
        val = archname.getvalue()
        archname.close()

        if b64enc:
            val = base64.encodestring(val)

        return val
예제 #13
0
def zip_directory(directory, b64enc=True, src=True):
    """Compress a directory

    @param directory: The directory to compress
    @param base64enc: if True the function will encode the zip file with base64
    @param src: Integrate the source files

    @return: a string containing the zip file
    """

    RE_exclude = re.compile(
        '(?:^\..+\.swp$)|(?:\.py[oc]$)|(?:\.bak$)|(?:\.~.~$)', re.I)

    def _zippy(archive, path, src=True):
        path = os.path.abspath(path)
        base = os.path.basename(path)
        for f in osutil.listdir(path, True):
            bf = os.path.basename(f)
            if not RE_exclude.search(bf) and (src or bf in ('__openerp__.py',
                                                            '__terp__.py')
                                              or not bf.endswith('.py')):
                archive.write(os.path.join(path, f), os.path.join(base, f))

    archname = StringIO()
    archive = PyZipFile(archname, "w", ZIP_DEFLATED)

    # for Python 2.5, ZipFile.write() still expects 8-bit strings (2.6 converts to utf-8)
    directory = tools.ustr(directory).encode('utf-8')

    archive.writepy(directory)
    _zippy(archive, directory, src=src)
    archive.close()
    archive_data = archname.getvalue()
    archname.close()

    if b64enc:
        return base64.encodestring(archive_data)

    return archive_data
예제 #14
0
def get_zip_from_directory(directory, b64enc=True):
    RE_exclude = re.compile('(?:^\..+\.swp$)|(?:\.py[oc]$)|(?:\.bak$)|(?:\.~.~$)', re.I)

    def _zippy(archive, path):
        path = os.path.abspath(path)
        base = os.path.basename(path)
        for f in tools.osutil.listdir(path, True):
            bf = os.path.basename(f)
            if not RE_exclude.search(bf):
                archive.write(os.path.join(path, f), os.path.join(base, f))

    archname = StringIO()
    archive = PyZipFile(archname, "w", ZIP_DEFLATED)
    archive.writepy(directory)
    _zippy(archive, directory)
    archive.close()
    val = archname.getvalue()
    archname.close()

    if b64enc:
        val = base64.encodestring(val)

    return val
예제 #15
0
def get_module_as_zip_from_module_directory(module_directory,
                                            b64enc=True,
                                            src=True):
    """Compress a module directory

    @param module_directory: The module directory
    @param base64enc: if True the function will encode the zip file with base64
    @param src: Integrate the source files

    @return: a stream to store in a file-like object
    """

    RE_exclude = re.compile(
        '(?:^\..+\.swp$)|(?:\.py[oc]$)|(?:\.bak$)|(?:\.~.~$)', re.I)

    def _zippy(archive, path, src=True):
        path = os.path.abspath(path)
        base = os.path.basename(path)
        for f in tools.osutil.listdir(path, True):
            bf = os.path.basename(f)
            if not RE_exclude.search(bf) and (src or bf in ('__openerp__.py',
                                                            '__terp__.py')
                                              or not bf.endswith('.py')):
                archive.write(os.path.join(path, f), os.path.join(base, f))

    archname = StringIO()
    archive = PyZipFile(archname, "w", ZIP_DEFLATED)
    archive.writepy(module_directory)
    _zippy(archive, module_directory, src=src)
    archive.close()
    val = archname.getvalue()
    archname.close()

    if b64enc:
        val = base64.encodestring(val)

    return val
예제 #16
0
def zip_directory(directory, b64enc=True, src=True):
    """Compress a directory

    @param directory: The directory to compress
    @param base64enc: if True the function will encode the zip file with base64
    @param src: Integrate the source files

    @return: a string containing the zip file
    """

    RE_exclude = re.compile('(?:^\..+\.swp$)|(?:\.py[oc]$)|(?:\.bak$)|(?:\.~.~$)', re.I)

    def _zippy(archive, path, src=True):
        path = os.path.abspath(path)
        base = os.path.basename(path)
        for f in tools.osutil.listdir(path, True):
            bf = os.path.basename(f)
            if not RE_exclude.search(bf) and (src or bf in ('__openerp__.py', '__terp__.py') or not bf.endswith('.py')):
                archive.write(os.path.join(path, f), os.path.join(base, f))

    archname = StringIO()
    archive = PyZipFile(archname, "w", ZIP_DEFLATED)

    # for Python 2.5, ZipFile.write() still expects 8-bit strings (2.6 converts to utf-8)
    directory = tools.ustr(directory).encode('utf-8')

    archive.writepy(directory)
    _zippy(archive, directory, src=src)
    archive.close()
    archive_data = archname.getvalue()
    archname.close()

    if b64enc:
        return base64.encodestring(archive_data)

    return archive_data
예제 #17
0
from zipfile import PyZipFile, ZIP_STORED
from settings import *

root = os.path.dirname(os.path.realpath('__file__'))
mod_name = None

if __name__ == "__main__":
    mod_name = input(
        "Type the name of your mod and hit enter or just hit enter to skip naming: "
    )
    src = os.path.join(root, 'Scripts')
    if not mod_name:
        mod_name = os.path.basename(
            os.path.normpath(os.path.dirname(os.path.realpath('__file__'))))

    mod_name = creator_name + '_' + mod_name
    ts4script = os.path.join(root, mod_name + '.ts4script')

    ts4script_mods = os.path.join(os.path.join(mods_folder),
                                  mod_name + '.ts4script')

    zf = PyZipFile(ts4script,
                   mode='w',
                   compression=ZIP_STORED,
                   allowZip64=True,
                   optimize=2)
    for folder, subs, files in os.walk(src):
        zf.writepy(folder)
    zf.close()
    shutil.copyfile(ts4script, ts4script_mods)
def debug_install_egg(egg_path: str, mods_dir, dest_name: str,
                      mod_folder_name: str) -> None:
    """
    Copies the debug egg provided by Pycharm Pro which adds the capability to make debugging happen inside of
    PyCharm Pro. A bit of work goes into this so it'll be much slower.

    :param egg_path: Path to the debug egg
    :param mods_dir: Path to the mods folder
    :param dest_name: Name of the mod
    :param mod_folder_name: Name of mod Subfolder
    :return:
    """

    print("Re-packaging and installing the debugging capability mod...")
    # Get egg filename and path
    filename = Path(egg_path).name
    mods_sub_dir = os.path.join(mods_dir, mod_folder_name)
    mod_path = os.path.join(mods_sub_dir, dest_name + ".ts4script")

    ensure_path_created(mods_sub_dir)

    # Get python ctypes folder
    sys_ctypes_folder = os.path.join(get_sys_folder(), "Lib", "ctypes")

    # Create temp directory
    tmp_dir = tempfile.TemporaryDirectory()
    tmp_egg = tmp_dir.name + os.sep + filename

    # Remove old mod in mods folder there, if it exists
    remove_file(mod_path)

    # Copy egg to temp path
    shutil.copyfile(egg_path, tmp_egg)

    # Extract egg
    # This step is a bit redundant but I need to copy over everything but one folder into the zip file and I don't
    # know how to do that in python so I copy over the zip, extract it, copy in the whole folder, delete the one
    # sub-folder, then re-zip everything up. It's a pain but it's what I know hwo to do now and Google's not much help
    zip = PyZipFile(tmp_egg)
    zip.extractall(tmp_dir.name)
    zip.close()

    # Remove archive
    remove_file(tmp_egg)

    # Copy ctype folder to extracted archive
    shutil.copytree(sys_ctypes_folder, tmp_dir.name + os.sep + "ctypes")

    # Remove that one folder
    remove_dir(tmp_dir.name + os.sep + "ctypes" + os.sep + "__pycache__")

    # Grab a handle on the egg
    zf = PyZipFile(mod_path,
                   mode='w',
                   compression=ZIP_STORED,
                   allowZip64=True,
                   optimize=2)

    # Add all the files in the tmp directory to the zip file
    for folder, subs, files in os.walk(tmp_dir.name):
        for file in files:
            archive_path = get_rel_path(folder + os.sep + file, tmp_dir.name)
            zf.write(folder + os.sep + file, archive_path)

    zf.close()

    # There's a temporary directory bug that causes auto-cleanup to sometimes fail
    # We're preventing crash messages from flooding the screen to keep things tidy
    try:
        tmp_dir.cleanup()
    except:
        pass
예제 #19
0
#!/usr/bin/env python
#
# Packs Python standard library into zip file python$(ver).zip
#

import os, os.path, shutil, sys
from zipfile import PyZipFile

name = "python%i%i.zip" % (sys.version_info[0], sys.version_info[1])
print "creating %s..." % name

# delete tests, we don't need them:
for root, dirs, files in os.walk("Lib", topdown=False):
    if "test" in dirs:
        shutil.rmtree(os.path.join(root, "test"))

# pack Lib to a zipfile:
zip = PyZipFile(name, mode="w")

for f in os.listdir("Lib"):
    fn = os.path.join("Lib", f)
    if os.path.isdir(fn) or fn.endswith(".py"):
        zip.writepy(fn)
    else:
        print "warning: ignoring file %s" % f

zip.close()
    def compile_mod(cls,
                    names_of_modules_include: Iterator[str],
                    folder_path_to_output_ts4script_to: str,
                    output_ts4script_name: str,
                    names_of_modules_to_exclude: str = None,
                    mod_creator_name: str = None,
                    folder_path_to_gather_script_modules_from: str = '..'):
        """compile_mod(\
            names_of_modules_include,\
            folder_path_to_output_ts4script_to,\
            output_ts4script_name,\
            names_of_modules_to_exclude=None,\
            mod_creator_name=None,\
            folder_path_to_gather_script_packages_from=None\
        )

        Compile a mod using unpyc3.

        """
        os.makedirs(folder_path_to_output_ts4script_to, exist_ok=True)
        from compile_utils import _remove_files_conflicting_with_decompile, _replace_renamed_files
        _remove_files_conflicting_with_decompile(decompile_ea_scripts=False)
        names_of_modules_include = tuple(names_of_modules_include)
        if not mod_creator_name:
            mod_creator_name = creator_name
        if not output_ts4script_name:
            output_ts4script_name = os.path.join(
                '..', '..',
                os.path.basename(
                    os.path.normpath(
                        os.path.dirname(os.path.realpath('__file__')))))
            print('No mod name found, setting the path name to \'{}\'.'.format(
                output_ts4script_name))
        print(f'The current working directory {os.getcwd()}.')

        if mod_creator_name:
            print(
                'Mod creator name found, appending mod creator name to file name.'
            )
            output_ts4script_name = '{}_{}'.format(mod_creator_name,
                                                   output_ts4script_name)
        output_script_zip_name = '{}.ts4script'.format(output_ts4script_name)
        if not folder_path_to_output_ts4script_to:
            ts4script = output_script_zip_name
        else:
            ts4script = os.path.join(folder_path_to_output_ts4script_to,
                                     output_script_zip_name)

        # noinspection PyBroadException
        try:
            if os.path.exists(ts4script):
                print('Script archive found, removing found archive.')
                os.remove(ts4script)
                print('Script archive removed.')

            output_zip = PyZipFile(ts4script,
                                   mode='w',
                                   allowZip64=True,
                                   optimize=2)
            previous_working_directory = os.getcwd()

            if folder_path_to_gather_script_modules_from is not None:
                print(
                    f'Changing the working directory to \'{folder_path_to_gather_script_modules_from}\''
                )
                os.chdir(folder_path_to_gather_script_modules_from)
            else:
                folder_path_to_gather_script_modules_from = '..'
                os.chdir(folder_path_to_gather_script_modules_from)
            print(f'Changed the current working directory \'{os.getcwd()}\'.')
            # print('Found child directories {}'.format(pformat(tuple(child_directories))))
            for folder_path in cls._child_directories_gen(os.getcwd()):
                # print(f'Attempting to compile {folder_path}')
                if names_of_modules_to_exclude is not None and os.path.basename(
                        folder_path) in names_of_modules_to_exclude:
                    # print(f'Folder is set to be ignored {folder_path}. Continuing to the next folder.')
                    continue
                if names_of_modules_include is not None and os.path.basename(
                        folder_path) not in names_of_modules_include:
                    # print(f'Folder is not set to be included {folder_path}. Continuing to the next folder.')
                    continue
                # noinspection PyBroadException
                try:
                    print(f'Compiling folder \'{folder_path}\'')
                    output_zip.writepy(folder_path)
                    print(f'\'{folder_path}\' compiled successfully.')
                except Exception as ex:
                    print(f'Failed to write {folder_path}. {ex}')
                    traceback.print_exc()
                    continue

            print('Done compiling modules.')
            output_zip.close()
            print('Changing working directory to previous working directory.')
            os.chdir(previous_working_directory)
            print(
                f'Changed the current working directory to \'{os.getcwd()}\'')
        except Exception as ex:
            print(f'Failed to create {ts4script}. {ex}')
            return
        finally:
            _replace_renamed_files(decompile_ea_scripts=False)