Create the laboratory directories.
490859
def initialize(self):
        """"""
        mkdir_p(self.archive_path)
        mkdir_p(self.bin_path)
        mkdir_p(self.codebase_path)
        mkdir_p(self.input_basepath)
1237973
def create_fpath_dir(self, fpath: str):
        """"""
        os.makedirs(os.path.dirname(fpath), exist_ok=True)
787367
def install(cls):
        """"""
        [os.makedirs('{}/{}'.format(cls.home, cls.dirs[d])) for d in cls.dirs]
233043
def createWorkDir(baseDir,
                  projName,
                  expUUID,
                  expNames = [],
                  nanos    = True,
                  utc      = False):
	""""""
	
	#
	# First, ensure the project's top-level hierarchy, especially by-uuid/,
	# exists, so that the only possible failure is due to the creation of
	# one additional directory.
	#
	projDir    = os.path.join(baseDir, projName)
	byuuidDir  = os.path.join(projDir, "by-uuid")
	bytimeDir  = os.path.join(projDir, "by-time")
	bynameDir  = os.path.join(projDir, "by-name", *expNames)
	byuuidPath = os.path.join(byuuidDir, expUUID)
	os.makedirs(byuuidDir, mode=0o755, exist_ok=True)
	os.makedirs(bytimeDir, mode=0o755, exist_ok=True)
	os.makedirs(bynameDir, mode=0o755, exist_ok=True)
	
	#
	# Attempt the creation of the experiment workDir by its UUID. Record
	# whether we were the original creators.
	#
	try:
		preexisting = False
		os.makedirs(byuuidPath,
		            mode     = 0o755,
		            exist_ok = False)
	except FileExistsError:
		preexisting = True
	
	#
	# If we were the first to create this working directory, additionally
	# make symlinks pointing to it from the auxiliary directories.
	#
	if not preexisting:
		expTime     = iso8601timestamp(nanos=nanos, utc=utc)
		expTimeUUID = expTime+"-"+expUUID
		bytimePath  = os.path.join(bytimeDir, expTimeUUID)
		bynamePath  = os.path.join(bynameDir, expUUID)
		os.symlink(os.path.relpath(byuuidPath, bytimeDir), bytimePath, True)
		os.symlink(os.path.relpath(byuuidPath, bynameDir), bynamePath, True)
	
	#
	# Create handy .rsync-filter files.
	#
	with contextlib.suppress(OSError):
		with open(os.path.join(baseDir, ".rsync-filter"), "x") as f:
			f.write("#\n"
			        "# rsync filter rules.\n"
			        "#\n"
			        "# When the argument -F is given to rsync, the rules within will be obeyed.\n"
			        "#\n")
	
	with contextlib.suppress(OSError):
		with open(os.path.join(projDir, ".rsync-filter"), "x") as f:
			f.write("#\n"
			        "# rsync filter rules.\n"
			        "#\n"
			        "# When the argument -F is given to rsync, the rules within will be obeyed.\n"
			        "#\n")
	
	#
	# Return the constructed workDir.
	#
	return byuuidPath
605279
def mkdir_and_cd(dirname):
    """"""
    if not os.path.exists(dirname):
        os.makedirs(dirname)
        os.chdir(dirname)
    else:
        os.chdir(dirname)
137354
def _setup_directories(self):
        
        dirs = [self._data_dir]
        dirs += [os.path.join(self._data_dir, name) for name
                 in self.DATA_SUBDIRS]

        for path in dirs:
            if not os.path.isdir(path):
                try:
                    os.makedirs(path)  # recursive mkdir
                    os.chmod(path, 0755)  # rwxr-xr-x

                except OSError:
                    raise errors.DirectorySetupFail()

        return True
1036687
function createDirectories(done) {
		debug('createDirectories()');
		var paths = [ options.output ];
		function iterator(dirpath, next) { mkdirp(dirpath, '0755', next); };
		async.forEach(paths, iterator, done);
	}
1087616
def create(self):
        """"""
        self.buffer = []
        self.buf_count = 0
        if not self.directory.exists: self.directory.create()
        self.open('w')
        return self
1130867
def _create_training_directories():
    
    logger.info('Creating a new training folder under %s .' % base_dir)

    os.makedirs(model_dir)
    os.makedirs(input_config_dir)
    os.makedirs(output_data_dir)

    _write_json({}, hyperparameters_file_dir)
    _write_json({}, input_data_config_file_dir)

    host_name = socket.gethostname()

    resources_dict = {
        "current_host": host_name,
        "hosts": [host_name]
    }
    _write_json(resources_dict, resource_config_file_dir)
9052
def _create(self):
    """"""
    from .tools import makedirs_safe

    # create directory for sql database
    makedirs_safe(os.path.dirname(self._database))

    # create all the tables
    Base.metadata.create_all(self._engine)
    logger.debug("Created new empty database '%s'" % self._database)
1132401
def create_dir(dirpath):
    

    if not os.path.isdir(dirpath):
        os.mkdir(dirpath)

        print("We create a directory for you and your Ding0 data: {}".format(
            dirpath))
205173
def makedirs(path, mode=0o777, exist_ok=False):
    """"""
    os.makedirs(path, mode, exist_ok)
609214
def create_results_dir(self):
    """"""
    self._current_results_dir = self._cache_manager._results_dir_path(self.cache_key, stable=False)
    self._results_dir = self._cache_manager._results_dir_path(self.cache_key, stable=True)

    if not self.valid:
      # Clean the workspace for invalid vts.
      safe_mkdir(self._current_results_dir, clean=True)

    relative_symlink(self._current_results_dir, self._results_dir)
    self.ensure_legal()
313116
def _create_structure(self):
        """"""

        # Ensure that the specified path does not exist and create it.
        if _path_exists(self._abspath):
            raise(StorageBrokerOSError(
                "Path already exists: {}".format(self._abspath)
            ))

        # Make sure the parent collection exists.
        parent, _ = os.path.split(self._abspath)
        if not _path_exists(parent):
            raise(StorageBrokerOSError(
                "No such iRODS collection: {}".format(parent)))

        _mkdir(self._abspath)

        # Create more essential subdirectories.
        essential_subdirectories = [
            self._dtool_abspath,
            self._data_abspath,
            self._overlays_abspath
        ]
        for abspath in essential_subdirectories:
            _mkdir_if_missing(abspath)
1165293
protected function createFolders()
    {
        foreach ($this->getFolderStructure() as $folder) {
            $newFolder = $this->twigStringRenderer->renderToString($folder, $this->data);
            $this->fs->mkdir($this->targetPath.DIRECTORY_SEPARATOR.$newFolder, self::DIRECTORY_MODE);

            $msg = '[mkdir] '.$this->targetPath.DIRECTORY_SEPARATOR.$newFolder;
            if ($this->reportingEnabled) {
                $this->report[] =$msg;
            }
        }
    }
461125
def makedir(self):
        
        try:
            os.makedirs(self.model_dir)
        except OSError as exception:
            if exception.errno != errno.EEXIST:
                raise
1336684
def make_subdirs(self):
        """"""
        # Pull off everything below the root.
        subpath = self.full_path[len(self.context.root):]
        log.debug("make_subdirs: subpath is %s", subpath)
        # Split on directory separators, but drop the last one, as it should
        # be the filename.
        dirs = subpath.split(os.sep)[:-1]
        log.debug("dirs is %s", dirs)
        current = self.context.root
        for dir in dirs:
            if dir:
                current = os.path.join(current, dir)
                if os.path.isdir(current):
                    log.debug("%s is already an existing directory", current)
                else:
                    os.mkdir(current, 0o700)