Setter for file_system_path attribute of state

        :param str file_system_path:
        :return:
495617
def file_system_path(self, file_system_path):
        
        if not isinstance(file_system_path, string_types):
            raise TypeError("file_system_path must be a string")
        self._file_system_path = file_system_path
606850
def set_src_filepath(self, src_dir_path):
        
        log.debug("set_src_filepath() with: '%s'", src_dir_path)
        self.abs_src_filepath = src_dir_path.resolved_path
        log.debug(" * abs_src_filepath: %s" % self.abs_src_filepath)

        if self.abs_src_filepath is None:
            log.info("Can't resolve source path: %s", src_dir_path)
            return

        self.sub_filepath = self.abs_src_filepath.relative_to(self.abs_src_root)
        log.debug(" * sub_filepath: %s" % self.sub_filepath)

        self.sub_path = self.sub_filepath.parent
        log.debug(" * sub_path: %s" % self.sub_path)

        self.filename = self.sub_filepath.name
        log.debug(" * filename: %s" % self.filename)

        self.abs_dst_path = Path2(self.abs_dst_root, self.sub_path)
        log.debug(" * abs_dst_path: %s" % self.abs_dst_path)

        self.abs_dst_filepath = Path2(self.abs_dst_root, self.sub_filepath)
        log.debug(" * abs_dst_filepath: %s" % self.abs_dst_filepath)

        self.abs_dst_hash_filepath = Path2("%s%s%s" % (self.abs_dst_filepath, os.extsep, phlb_config.hash_name))
        log.debug(" * abs_dst_hash_filepath: %s" % self.abs_dst_hash_filepath)
1037855
def read_state_file(self, file_path=None):
        

        working_dir = self.working_dir or ''

        file_path = file_path or self.state or ''

        if not file_path:
            backend_path = os.path.join(file_path, '.terraform',
                                        'terraform.tfstate')

            if os.path.exists(os.path.join(working_dir, backend_path)):
                file_path = backend_path
            else:
                file_path = os.path.join(file_path, 'terraform.tfstate')

        file_path = os.path.join(working_dir, file_path)

        self.tfstate = Tfstate.load_file(file_path)
1126178
async def SetFilesystemAttachmentInfo(self, filesystem_attachments):
        '''
        
        '''
        # map input types to rpc msg
        _params = dict()
        msg = dict(type='StorageProvisioner',
                   request='SetFilesystemAttachmentInfo',
                   version=3,
                   params=_params)
        _params['filesystem-attachments'] = filesystem_attachments
        reply = await self.rpc(msg)
        return reply
894812
def register_file(self, file):
        

        not self.__engine.file_system_events_manager.is_path_registered(file) and \
        self.__engine.file_system_events_manager.register_path(file)
        return True
1367070
def feature_path(self, gff_path):
        
        if not gff_path:
            self.feature_dir = None
            self.feature_file = None

        else:
            if not op.exists(gff_path):
                raise OSError('{}: file does not exist!'.format(gff_path))

            if not op.dirname(gff_path):
                self.feature_dir = '.'
            else:
                self.feature_dir = op.dirname(gff_path)
            self.feature_file = op.basename(gff_path)
597686
def set_path(self, path):
        ''''''
        self._path = path
        return self._listitem.setPath(path)
119125
def set_path_ownership(path, uid, gid):
    
    os.chown(path, uid, gid)
    for root, dirs, files in os.walk(path):
        for d in dirs:
            if not(os.path.islink(os.path.join(root, d))):
                os.chown(os.path.join(root, d), uid, gid)
        for f in files:
            if not(os.path.islink(os.path.join(root, f))):
                os.chown(os.path.join(root, f), uid, gid)
1109141
def set_path(self, path, is_user=False):
        
        self.clear_buttons()
        pathlist = util.rec_split_path(path)
        for (abspath, name) in pathlist:
            self.append_button(abspath, name)

        if is_user:
            self.add_view_history(path)

        self.back_button.set_sensitive(self.can_back())
        self.forward_button.set_sensitive(self.can_forward())

        self.show_all()
269395
def make_file_system_tree(root_folder, _parent=None):
    
    root_node = Node(os.path.basename(root_folder), _parent)
    root_node.path = root_folder
    for item in os.listdir(root_folder):
        item_path = os.path.join(root_folder, item)
        if os.path.isfile(item_path):
            file_node = Node(os.path.basename(item), root_node)
            file_node.path = item_path
        elif os.path.isdir(item_path):
            #folder_path = os.path.join(root_folder, item)
            make_file_system_tree(item_path, _parent=root_node)
    return root_node
300080
def choose_path():
    
    dirs = webview.create_file_dialog(webview.FOLDER_DIALOG)
    if dirs and len(dirs) > 0:
        directory = dirs[0]
        if isinstance(directory, bytes):
            directory = directory.decode("utf-8")

        response = {"status": "ok", "directory": directory}
    else:
        response = {"status": "cancel"}

    return jsonify(response)
1303446
def load_state(self, in_path):
        

        with open(in_path, "r") as infile:
            state = json.load(infile)

        self.restore_state(state)
553066
def pathconf(path,
             os_name=os.name,
             isdir_fnc=os.path.isdir,
             pathconf_fnc=getattr(os, 'pathconf', None),
             pathconf_names=getattr(os, 'pathconf_names', ())):
    '''
    
    '''

    if pathconf_fnc and pathconf_names:
        return {key: pathconf_fnc(path, key) for key in pathconf_names}
    if os_name == 'nt':
        maxpath = 246 if isdir_fnc(path) else 259  # 260 minus <END>
    else:
        maxpath = 255  # conservative sane default
    return {
        'PC_PATH_MAX': maxpath,
        'PC_NAME_MAX': maxpath - len(path),
        }
824353
public void setAttributes(String path, SftpFileAttributes attrs)
			throws SftpStatusException, SshException {
		try {
			UnsignedInteger32 requestId = nextRequestId();

			Packet msg = createPacket();
			msg.write(SSH_FXP_SETSTAT);
			msg.writeInt(requestId.longValue());
			msg.writeString(path, CHARSET_ENCODING);
			msg.write(attrs.toByteArray());

			sendMessage(msg);

			getOKRequestStatus(requestId);
		} catch (SshIOException ex) {
			throw ex.getRealException();
		} catch (IOException ex) {
			throw new SshException(ex, SshException.INTERNAL_ERROR);
		}
	}
1190829
def reload_system_path(self):
        # type: () -> None
        

        if self._system_path is not None:
            self._system_path.clear_caches()
        self._system_path = None
        six.moves.reload_module(pyfinder_path)
        self._system_path = self.create_system_path()
1250139
def set_file_path(self, path):
        """"""
        self.file_path.delete(0, END)
        self.file_path.insert(0, path)
1162875
def set_path(self, path, val):
        
        path = tuple(path.split('.')) if isinstance(path , str) else tuple(path)

        disallowed = [p for p in path if not type(self)._sanitizer.allowable(p)]
        if any(disallowed):
            raise Exception("Attribute strings in path elements cannot be "
                            "correctly escaped : %s" % ','.join(repr(el) for el in disallowed))
        if len(path) > 1:
            attrtree = self.__getattr__(path[0])
            attrtree.set_path(path[1:], val)
        else:
            self.__setattr__(path[0], val)