Get path to the internationalization data.
    :return: path as a string
358536
def i18n_get_path():
    
    local_locale_path = client_get_path() / 'locale'
    if platform.system() == 'Linux':
        if local_locale_path.exists():
            return local_locale_path
        else:
            return Path('/usr/share/locale')
    else:
        return local_locale_path
960549
def data_path(self) -> DataPath:
        """"""
        dp = self.data_parent()
        return (dp.data_path() if dp else "") + "/" + self.iname()
1160758
def load_unicode(self, resource_path):
        
        resource_content = pkg_resources.resource_string(self.module_name, resource_path)
        return resource_content.decode('utf-8')
139824
def upath(path):
    
    if six.PY2 and not isinstance(path, six.text_type):
        return path.decode(fs_encoding)
    return path
472264
def get_root_path(self, language):
        
        path = None

        # Get path of the current project
        if self.main and self.main.projects:
            path = self.main.projects.get_active_project_path()

        # If there's no project, use the output of getcwd_or_home.
        if not path:
            # We can't use getcwd_or_home for Python because if it
            # returns home and you have a lot of Python files on it
            # then computing Rope completions takes a long time
            # and blocks the PyLS server.
            # Instead we use an empty directory inside our config one,
            # just like we did for Rope in Spyder 3.
            if language == 'python':
                path = get_conf_path('lsp_root_path')
                if not osp.exists(path):
                    os.mkdir(path)
            else:
                path = getcwd_or_home()

        return path
516385
def path(self) -> Path:
        """"""
        args = list(self._iter_translated_field_names(self.get_path_pattern_list()))
        args.append(self.get_name())
        return Path(*args)
771275
def _translate_config_path(location):
    
    # getting spec path
    package_name, filename = resolve_asset_spec(location.strip())
    if not package_name:
        path = filename
    else:
        package = __import__(package_name)
        path = os.path.join(package_path(package), filename)

    return path
670835
protected function getLangPath()
    {
        $lang_folder_path = $this->config('lang_folder_path') ?: base_path('resources/lang');

        // Check path
        if (file_exists($lang_folder_path)) {
            return $lang_folder_path;
        }

        $this->error("No lang folder found in your custom path: \"{$lang_folder_path}\"");
        $this->line('');

        die();
    }
843749
def po_file_path(self):
        
        # This was formerly referred to as 'rosetta_i18n_fn'
        idx = self.kwargs['idx']
        idx = int(idx)  # idx matched url re expression; calling int() is safe

        third_party_apps = self.po_filter in ('all', 'third-party')
        django_apps = self.po_filter in ('all', 'django')
        project_apps = self.po_filter in ('all', 'project')

        po_paths = find_pos(self.language_id,
                            project_apps=project_apps,
                            django_apps=django_apps,
                            third_party_apps=third_party_apps,
                            )
        po_paths.sort(key=get_app_name)

        try:
            path = po_paths[idx]
        except IndexError:
            raise Http404
        return path
1007317
def result_str(self):
        
        return '{}, {}, {}'.format(LocalOnlyCounter.plural_fmt('project', self.projects),
                                   LocalOnlyCounter.plural_fmt('folder', self.folders),
                                   LocalOnlyCounter.plural_fmt('file', self.files))
788499
@Override
    public String getPathTranslated() {
        final String info = getPathInfo();
        return (null == info) ? null : getServletContext().getRealPath(info);
    }
1302672
function (path) {
            var lang = UE.I18N[this.options.lang];
            if (!lang) {
                throw Error("not import language file");
            }
            path = (path || "").split(".");
            for (var i = 0, ci; ci = path[i++];) {
                lang = lang[ci];
                if (!lang)break;
            }
            return lang;
        }
650467
def load_locale_prefixdata(indir, separator=None):
    
    prefixdata = {}  # prefix => dict mapping locale to description
    for locale in os.listdir(indir):
        if not os.path.isdir(os.path.join(indir, locale)):
            continue
        for filename in glob.glob(os.path.join(indir, locale, "*%s" % PREFIXDATA_SUFFIX)):
            overall_prefix, ext = os.path.splitext(os.path.basename(filename))
            load_locale_prefixdata_file(prefixdata, filename, locale, overall_prefix, separator)
    return prefixdata
553803
def get_relative_path(self, domain, locale):
        
        return self.relative_path_template.format(
            domain=domain,
            locale=locale,
            extension=self.get_extension()
        )
245044
def enqueue_conversion_path(url_string, to_type, enqueue_convert):
    '''
    
    '''
    target_ts = TypeString(to_type)
    foreign_res = ForeignResource(url_string)

    # Determine the file type of the foreign resource
    typed_foreign_res = foreign_res.guess_typed()

    if not typed_foreign_res.cache_exists():
        # Symlink to new location that includes typed extension
        typed_foreign_res.symlink_from(foreign_res)

    # Now find path between types
    original_ts = typed_foreign_res.typestring
    path = singletons.converter_graph.find_path(original_ts, target_ts)

    # Loop through each step in graph path and convert
    is_first = True
    for converter_class, from_ts, to_ts in path:
        converter = converter_class()
        in_resource = TypedResource(url_string, from_ts)
        if is_first:  # Ensure first resource is just the source one
            in_resource = TypedForeignResource(url_string, from_ts)
        out_resource = TypedResource(url_string, to_ts)
        enqueue_convert(converter, in_resource, out_resource)
        is_first = False
237893
protected function getLangPath()
    {
        $sectionSegments = $this->sectionSegments;

        if ($this->langDir) {
            array_unshift($sectionSegments, $this->langDir);
        }

        return base_path('resources/lang/fr/'.implode('/', $sectionSegments).'.php');
    }
744032
def get_as_string(self, s3_path, encoding='utf-8'):
        
        content = self.get_as_bytes(s3_path)
        return content.decode(encoding)