Andreas/evennia
1
0
Fork 0
mirror of https://github.com/evennia/evennia.git synced 2026-03-20 06:46:31 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
evennia/docs/5.x/_modules/posixpath.html
Griatch c5437c1273 Add 5.x documentation
2025-07-01 10:01:48 +02:00

675 lines
No EOL
75 KiB
HTML
Raw Blame History

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>posixpath &#8212; Evennia latest documentation</title>
<link rel="stylesheet" href="../_static/nature.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<link rel="stylesheet" type="text/css" href="../_static/pygments.css?v=d75fae25" />
<link rel="stylesheet" type="text/css" href="../_static/nature.css?v=245aff17" />
<script id="documentation_options" data-url_root="../" src="../_static/documentation_options.js"></script>
<script src="../_static/documentation_options.js?v=c6e86fd7"></script>
<script src="../_static/doctools.js?v=9bcbadda"></script>
<script src="../_static/sphinx_highlight.js?v=dc90522c"></script>
<link rel="index" title="Index" href="../genindex.html" />
<link rel="search" title="Search" href="../search.html" />
</head><body>
<div class="related" role="navigation" aria-label="related navigation">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="../py-modindex.html" title="Python Module Index"
>modules</a> |</li>
<li class="nav-item nav-item-0"><a href="../index.html">Evennia latest</a> &#187;</li>
<li class="nav-item nav-item-1"><a href="index.html" accesskey="U">Module code</a> &#187;</li>
<li class="nav-item nav-item-this"><a href="">posixpath</a></li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper">
<search id="searchbox" style="display: none" role="search">
<h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper">
<form class="search" action="../search.html" method="get">
<input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" />
</form>
</div>
</search>
<script>document.getElementById('searchbox').style.display = "block"</script><h3>Links</h3>
<ul>
<li><a href="https://www.evennia.com/docs/latest/index.html">Documentation Top</a> </li>
<li><a href="https://www.evennia.com">Evennia Home</a> </li>
<li><a href="https://github.com/evennia/evennia">Github</a> </li>
<li><a href="http://games.evennia.com">Game Index</a> </li>
<li>
<a href="https://discord.gg/AJJpcRUhtF">Discord</a> -
<a href="https://github.com/evennia/evennia/discussions">Discussions</a> -
<a href="https://evennia.blogspot.com/">Blog</a>
</li>
</ul>
</div>
</div>
<div class="bodywrapper">
<div class="body" role="main">
<h1>Source code for posixpath</h1><div class="highlight"><pre>
<span></span><span class="sd">&quot;&quot;&quot;Common operations on Posix pathnames.</span>
<span class="sd">Instead of importing this module directly, import os and refer to</span>
<span class="sd">this module as os.path. The &quot;os.path&quot; name is an alias for this</span>
<span class="sd">module on Posix systems; on other systems (e.g. Windows),</span>
<span class="sd">os.path provides the same operations in a manner specific to that</span>
<span class="sd">platform, and is an alias to another module (e.g. ntpath).</span>
<span class="sd">Some of this can actually be useful on non-Posix systems too, e.g.</span>
<span class="sd">for manipulation of the pathname component of URLs.</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="c1"># Strings representing various path-related bits and pieces.</span>
<span class="c1"># These are primarily for export; internally, they are hardcoded.</span>
<span class="c1"># Should be set before imports for resolving cyclic dependency.</span>
<span class="n">curdir</span> <span class="o">=</span> <span class="s1">&#39;.&#39;</span>
<span class="n">pardir</span> <span class="o">=</span> <span class="s1">&#39;..&#39;</span>
<span class="n">extsep</span> <span class="o">=</span> <span class="s1">&#39;.&#39;</span>
<span class="n">sep</span> <span class="o">=</span> <span class="s1">&#39;/&#39;</span>
<span class="n">pathsep</span> <span class="o">=</span> <span class="s1">&#39;:&#39;</span>
<span class="n">defpath</span> <span class="o">=</span> <span class="s1">&#39;/bin:/usr/bin&#39;</span>
<span class="n">altsep</span> <span class="o">=</span> <span class="kc">None</span>
<span class="n">devnull</span> <span class="o">=</span> <span class="s1">&#39;/dev/null&#39;</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">errno</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">os</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">sys</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">stat</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">genericpath</span>
<span class="kn">from</span><span class="w"> </span><span class="nn">genericpath</span><span class="w"> </span><span class="kn">import</span> <span class="o">*</span>
<span class="n">__all__</span> <span class="o">=</span> <span class="p">[</span><span class="s2">&quot;normcase&quot;</span><span class="p">,</span><span class="s2">&quot;isabs&quot;</span><span class="p">,</span><span class="s2">&quot;join&quot;</span><span class="p">,</span><span class="s2">&quot;splitdrive&quot;</span><span class="p">,</span><span class="s2">&quot;splitroot&quot;</span><span class="p">,</span><span class="s2">&quot;split&quot;</span><span class="p">,</span><span class="s2">&quot;splitext&quot;</span><span class="p">,</span>
<span class="s2">&quot;basename&quot;</span><span class="p">,</span><span class="s2">&quot;dirname&quot;</span><span class="p">,</span><span class="s2">&quot;commonprefix&quot;</span><span class="p">,</span><span class="s2">&quot;getsize&quot;</span><span class="p">,</span><span class="s2">&quot;getmtime&quot;</span><span class="p">,</span>
<span class="s2">&quot;getatime&quot;</span><span class="p">,</span><span class="s2">&quot;getctime&quot;</span><span class="p">,</span><span class="s2">&quot;islink&quot;</span><span class="p">,</span><span class="s2">&quot;exists&quot;</span><span class="p">,</span><span class="s2">&quot;lexists&quot;</span><span class="p">,</span><span class="s2">&quot;isdir&quot;</span><span class="p">,</span><span class="s2">&quot;isfile&quot;</span><span class="p">,</span>
<span class="s2">&quot;ismount&quot;</span><span class="p">,</span> <span class="s2">&quot;expanduser&quot;</span><span class="p">,</span><span class="s2">&quot;expandvars&quot;</span><span class="p">,</span><span class="s2">&quot;normpath&quot;</span><span class="p">,</span><span class="s2">&quot;abspath&quot;</span><span class="p">,</span>
<span class="s2">&quot;samefile&quot;</span><span class="p">,</span><span class="s2">&quot;sameopenfile&quot;</span><span class="p">,</span><span class="s2">&quot;samestat&quot;</span><span class="p">,</span>
<span class="s2">&quot;curdir&quot;</span><span class="p">,</span><span class="s2">&quot;pardir&quot;</span><span class="p">,</span><span class="s2">&quot;sep&quot;</span><span class="p">,</span><span class="s2">&quot;pathsep&quot;</span><span class="p">,</span><span class="s2">&quot;defpath&quot;</span><span class="p">,</span><span class="s2">&quot;altsep&quot;</span><span class="p">,</span><span class="s2">&quot;extsep&quot;</span><span class="p">,</span>
<span class="s2">&quot;devnull&quot;</span><span class="p">,</span><span class="s2">&quot;realpath&quot;</span><span class="p">,</span><span class="s2">&quot;supports_unicode_filenames&quot;</span><span class="p">,</span><span class="s2">&quot;relpath&quot;</span><span class="p">,</span>
<span class="s2">&quot;commonpath&quot;</span><span class="p">,</span> <span class="s2">&quot;isjunction&quot;</span><span class="p">,</span><span class="s2">&quot;isdevdrive&quot;</span><span class="p">]</span>
<span class="k">def</span><span class="w"> </span><span class="nf">_get_sep</span><span class="p">(</span><span class="n">path</span><span class="p">):</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">path</span><span class="p">,</span> <span class="nb">bytes</span><span class="p">):</span>
<span class="k">return</span> <span class="sa">b</span><span class="s1">&#39;/&#39;</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="s1">&#39;/&#39;</span>
<span class="c1"># Normalize the case of a pathname. Trivial in Posix, string.lower on Mac.</span>
<span class="c1"># On MS-DOS this may also turn slashes into backslashes; however, other</span>
<span class="c1"># normalizations (such as optimizing &#39;../&#39; away) are not allowed</span>
<span class="c1"># (another function should be defined to do that).</span>
<span class="k">def</span><span class="w"> </span><span class="nf">normcase</span><span class="p">(</span><span class="n">s</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Normalize case of pathname. Has no effect under Posix&quot;&quot;&quot;</span>
<span class="k">return</span> <span class="n">os</span><span class="o">.</span><span class="n">fspath</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
<span class="c1"># Return whether a path is absolute.</span>
<span class="c1"># Trivial in Posix, harder on the Mac or MS-DOS.</span>
<span class="k">def</span><span class="w"> </span><span class="nf">isabs</span><span class="p">(</span><span class="n">s</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Test whether a path is absolute&quot;&quot;&quot;</span>
<span class="n">s</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">fspath</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
<span class="n">sep</span> <span class="o">=</span> <span class="n">_get_sep</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
<span class="k">return</span> <span class="n">s</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="n">sep</span><span class="p">)</span>
<span class="c1"># Join pathnames.</span>
<span class="c1"># Ignore the previous parts if a part is absolute.</span>
<span class="c1"># Insert a &#39;/&#39; unless the first part is empty or already ends in &#39;/&#39;.</span>
<span class="k">def</span><span class="w"> </span><span class="nf">join</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Join two or more pathname components, inserting &#39;/&#39; as needed.</span>
<span class="sd"> If any component is an absolute path, all previous path components</span>
<span class="sd"> will be discarded. An empty last part will result in a path that</span>
<span class="sd"> ends with a separator.&quot;&quot;&quot;</span>
<span class="n">a</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">fspath</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="n">sep</span> <span class="o">=</span> <span class="n">_get_sep</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="n">path</span> <span class="o">=</span> <span class="n">a</span>
<span class="k">try</span><span class="p">:</span>
<span class="k">for</span> <span class="n">b</span> <span class="ow">in</span> <span class="n">p</span><span class="p">:</span>
<span class="n">b</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">fspath</span><span class="p">(</span><span class="n">b</span><span class="p">)</span>
<span class="k">if</span> <span class="n">b</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="n">sep</span><span class="p">)</span> <span class="ow">or</span> <span class="ow">not</span> <span class="n">path</span><span class="p">:</span>
<span class="n">path</span> <span class="o">=</span> <span class="n">b</span>
<span class="k">elif</span> <span class="n">path</span><span class="o">.</span><span class="n">endswith</span><span class="p">(</span><span class="n">sep</span><span class="p">):</span>
<span class="n">path</span> <span class="o">+=</span> <span class="n">b</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">path</span> <span class="o">+=</span> <span class="n">sep</span> <span class="o">+</span> <span class="n">b</span>
<span class="k">except</span> <span class="p">(</span><span class="ne">TypeError</span><span class="p">,</span> <span class="ne">AttributeError</span><span class="p">,</span> <span class="ne">BytesWarning</span><span class="p">):</span>
<span class="n">genericpath</span><span class="o">.</span><span class="n">_check_arg_types</span><span class="p">(</span><span class="s1">&#39;join&#39;</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">)</span>
<span class="k">raise</span>
<span class="k">return</span> <span class="n">path</span>
<span class="c1"># Split a path in head (everything up to the last &#39;/&#39;) and tail (the</span>
<span class="c1"># rest). If the path ends in &#39;/&#39;, tail will be empty. If there is no</span>
<span class="c1"># &#39;/&#39; in the path, head will be empty.</span>
<span class="c1"># Trailing &#39;/&#39;es are stripped from head unless it is the root.</span>
<span class="k">def</span><span class="w"> </span><span class="nf">split</span><span class="p">(</span><span class="n">p</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Split a pathname. Returns tuple &quot;(head, tail)&quot; where &quot;tail&quot; is</span>
<span class="sd"> everything after the final slash. Either part may be empty.&quot;&quot;&quot;</span>
<span class="n">p</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">fspath</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>
<span class="n">sep</span> <span class="o">=</span> <span class="n">_get_sep</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>
<span class="n">i</span> <span class="o">=</span> <span class="n">p</span><span class="o">.</span><span class="n">rfind</span><span class="p">(</span><span class="n">sep</span><span class="p">)</span> <span class="o">+</span> <span class="mi">1</span>
<span class="n">head</span><span class="p">,</span> <span class="n">tail</span> <span class="o">=</span> <span class="n">p</span><span class="p">[:</span><span class="n">i</span><span class="p">],</span> <span class="n">p</span><span class="p">[</span><span class="n">i</span><span class="p">:]</span>
<span class="k">if</span> <span class="n">head</span> <span class="ow">and</span> <span class="n">head</span> <span class="o">!=</span> <span class="n">sep</span><span class="o">*</span><span class="nb">len</span><span class="p">(</span><span class="n">head</span><span class="p">):</span>
<span class="n">head</span> <span class="o">=</span> <span class="n">head</span><span class="o">.</span><span class="n">rstrip</span><span class="p">(</span><span class="n">sep</span><span class="p">)</span>
<span class="k">return</span> <span class="n">head</span><span class="p">,</span> <span class="n">tail</span>
<span class="c1"># Split a path in root and extension.</span>
<span class="c1"># The extension is everything starting at the last dot in the last</span>
<span class="c1"># pathname component; the root is everything before that.</span>
<span class="c1"># It is always true that root + ext == p.</span>
<span class="k">def</span><span class="w"> </span><span class="nf">splitext</span><span class="p">(</span><span class="n">p</span><span class="p">):</span>
<span class="n">p</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">fspath</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">p</span><span class="p">,</span> <span class="nb">bytes</span><span class="p">):</span>
<span class="n">sep</span> <span class="o">=</span> <span class="sa">b</span><span class="s1">&#39;/&#39;</span>
<span class="n">extsep</span> <span class="o">=</span> <span class="sa">b</span><span class="s1">&#39;.&#39;</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">sep</span> <span class="o">=</span> <span class="s1">&#39;/&#39;</span>
<span class="n">extsep</span> <span class="o">=</span> <span class="s1">&#39;.&#39;</span>
<span class="k">return</span> <span class="n">genericpath</span><span class="o">.</span><span class="n">_splitext</span><span class="p">(</span><span class="n">p</span><span class="p">,</span> <span class="n">sep</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="n">extsep</span><span class="p">)</span>
<span class="n">splitext</span><span class="o">.</span><span class="vm">__doc__</span> <span class="o">=</span> <span class="n">genericpath</span><span class="o">.</span><span class="n">_splitext</span><span class="o">.</span><span class="vm">__doc__</span>
<span class="c1"># Split a pathname into a drive specification and the rest of the</span>
<span class="c1"># path. Useful on DOS/Windows/NT; on Unix, the drive is always empty.</span>
<span class="k">def</span><span class="w"> </span><span class="nf">splitdrive</span><span class="p">(</span><span class="n">p</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Split a pathname into drive and path. On Posix, drive is always</span>
<span class="sd"> empty.&quot;&quot;&quot;</span>
<span class="n">p</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">fspath</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>
<span class="k">return</span> <span class="n">p</span><span class="p">[:</span><span class="mi">0</span><span class="p">],</span> <span class="n">p</span>
<span class="k">try</span><span class="p">:</span>
<span class="kn">from</span><span class="w"> </span><span class="nn">posix</span><span class="w"> </span><span class="kn">import</span> <span class="n">_path_splitroot_ex</span> <span class="k">as</span> <span class="n">splitroot</span>
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
<span class="k">def</span><span class="w"> </span><span class="nf">splitroot</span><span class="p">(</span><span class="n">p</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Split a pathname into drive, root and tail.</span>
<span class="sd"> The tail contains anything after the root.&quot;&quot;&quot;</span>
<span class="n">p</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">fspath</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">p</span><span class="p">,</span> <span class="nb">bytes</span><span class="p">):</span>
<span class="n">sep</span> <span class="o">=</span> <span class="sa">b</span><span class="s1">&#39;/&#39;</span>
<span class="n">empty</span> <span class="o">=</span> <span class="sa">b</span><span class="s1">&#39;&#39;</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">sep</span> <span class="o">=</span> <span class="s1">&#39;/&#39;</span>
<span class="n">empty</span> <span class="o">=</span> <span class="s1">&#39;&#39;</span>
<span class="k">if</span> <span class="n">p</span><span class="p">[:</span><span class="mi">1</span><span class="p">]</span> <span class="o">!=</span> <span class="n">sep</span><span class="p">:</span>
<span class="c1"># Relative path, e.g.: &#39;foo&#39;</span>
<span class="k">return</span> <span class="n">empty</span><span class="p">,</span> <span class="n">empty</span><span class="p">,</span> <span class="n">p</span>
<span class="k">elif</span> <span class="n">p</span><span class="p">[</span><span class="mi">1</span><span class="p">:</span><span class="mi">2</span><span class="p">]</span> <span class="o">!=</span> <span class="n">sep</span> <span class="ow">or</span> <span class="n">p</span><span class="p">[</span><span class="mi">2</span><span class="p">:</span><span class="mi">3</span><span class="p">]</span> <span class="o">==</span> <span class="n">sep</span><span class="p">:</span>
<span class="c1"># Absolute path, e.g.: &#39;/foo&#39;, &#39;///foo&#39;, &#39;////foo&#39;, etc.</span>
<span class="k">return</span> <span class="n">empty</span><span class="p">,</span> <span class="n">sep</span><span class="p">,</span> <span class="n">p</span><span class="p">[</span><span class="mi">1</span><span class="p">:]</span>
<span class="k">else</span><span class="p">:</span>
<span class="c1"># Precisely two leading slashes, e.g.: &#39;//foo&#39;. Implementation defined per POSIX, see</span>
<span class="c1"># https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap04.html#tag_04_13</span>
<span class="k">return</span> <span class="n">empty</span><span class="p">,</span> <span class="n">p</span><span class="p">[:</span><span class="mi">2</span><span class="p">],</span> <span class="n">p</span><span class="p">[</span><span class="mi">2</span><span class="p">:]</span>
<span class="c1"># Return the tail (basename) part of a path, same as split(path)[1].</span>
<span class="k">def</span><span class="w"> </span><span class="nf">basename</span><span class="p">(</span><span class="n">p</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Returns the final component of a pathname&quot;&quot;&quot;</span>
<span class="n">p</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">fspath</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>
<span class="n">sep</span> <span class="o">=</span> <span class="n">_get_sep</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>
<span class="n">i</span> <span class="o">=</span> <span class="n">p</span><span class="o">.</span><span class="n">rfind</span><span class="p">(</span><span class="n">sep</span><span class="p">)</span> <span class="o">+</span> <span class="mi">1</span>
<span class="k">return</span> <span class="n">p</span><span class="p">[</span><span class="n">i</span><span class="p">:]</span>
<span class="c1"># Return the head (dirname) part of a path, same as split(path)[0].</span>
<div class="viewcode-block" id="dirname">
<a class="viewcode-back" href="../api/evennia.server.portal.service.html#evennia.server.portal.service.dirname">[docs]</a>
<span class="k">def</span><span class="w"> </span><span class="nf">dirname</span><span class="p">(</span><span class="n">p</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Returns the directory component of a pathname&quot;&quot;&quot;</span>
<span class="n">p</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">fspath</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>
<span class="n">sep</span> <span class="o">=</span> <span class="n">_get_sep</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>
<span class="n">i</span> <span class="o">=</span> <span class="n">p</span><span class="o">.</span><span class="n">rfind</span><span class="p">(</span><span class="n">sep</span><span class="p">)</span> <span class="o">+</span> <span class="mi">1</span>
<span class="n">head</span> <span class="o">=</span> <span class="n">p</span><span class="p">[:</span><span class="n">i</span><span class="p">]</span>
<span class="k">if</span> <span class="n">head</span> <span class="ow">and</span> <span class="n">head</span> <span class="o">!=</span> <span class="n">sep</span><span class="o">*</span><span class="nb">len</span><span class="p">(</span><span class="n">head</span><span class="p">):</span>
<span class="n">head</span> <span class="o">=</span> <span class="n">head</span><span class="o">.</span><span class="n">rstrip</span><span class="p">(</span><span class="n">sep</span><span class="p">)</span>
<span class="k">return</span> <span class="n">head</span></div>
<span class="c1"># Is a path a mount point?</span>
<span class="c1"># (Does this work for all UNIXes? Is it even guaranteed to work by Posix?)</span>
<span class="k">def</span><span class="w"> </span><span class="nf">ismount</span><span class="p">(</span><span class="n">path</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Test whether a path is a mount point&quot;&quot;&quot;</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">s1</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">lstat</span><span class="p">(</span><span class="n">path</span><span class="p">)</span>
<span class="k">except</span> <span class="p">(</span><span class="ne">OSError</span><span class="p">,</span> <span class="ne">ValueError</span><span class="p">):</span>
<span class="c1"># It doesn&#39;t exist -- so not a mount point. :-)</span>
<span class="k">return</span> <span class="kc">False</span>
<span class="k">else</span><span class="p">:</span>
<span class="c1"># A symlink can never be a mount point</span>
<span class="k">if</span> <span class="n">stat</span><span class="o">.</span><span class="n">S_ISLNK</span><span class="p">(</span><span class="n">s1</span><span class="o">.</span><span class="n">st_mode</span><span class="p">):</span>
<span class="k">return</span> <span class="kc">False</span>
<span class="n">path</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">fspath</span><span class="p">(</span><span class="n">path</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">path</span><span class="p">,</span> <span class="nb">bytes</span><span class="p">):</span>
<span class="n">parent</span> <span class="o">=</span> <span class="n">join</span><span class="p">(</span><span class="n">path</span><span class="p">,</span> <span class="sa">b</span><span class="s1">&#39;..&#39;</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">parent</span> <span class="o">=</span> <span class="n">join</span><span class="p">(</span><span class="n">path</span><span class="p">,</span> <span class="s1">&#39;..&#39;</span><span class="p">)</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">s2</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">lstat</span><span class="p">(</span><span class="n">parent</span><span class="p">)</span>
<span class="k">except</span> <span class="ne">OSError</span><span class="p">:</span>
<span class="n">parent</span> <span class="o">=</span> <span class="n">realpath</span><span class="p">(</span><span class="n">parent</span><span class="p">)</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">s2</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">lstat</span><span class="p">(</span><span class="n">parent</span><span class="p">)</span>
<span class="k">except</span> <span class="ne">OSError</span><span class="p">:</span>
<span class="k">return</span> <span class="kc">False</span>
<span class="c1"># path/.. on a different device as path or the same i-node as path</span>
<span class="k">return</span> <span class="n">s1</span><span class="o">.</span><span class="n">st_dev</span> <span class="o">!=</span> <span class="n">s2</span><span class="o">.</span><span class="n">st_dev</span> <span class="ow">or</span> <span class="n">s1</span><span class="o">.</span><span class="n">st_ino</span> <span class="o">==</span> <span class="n">s2</span><span class="o">.</span><span class="n">st_ino</span>
<span class="c1"># Expand paths beginning with &#39;~&#39; or &#39;~user&#39;.</span>
<span class="c1"># &#39;~&#39; means $HOME; &#39;~user&#39; means that user&#39;s home directory.</span>
<span class="c1"># If the path doesn&#39;t begin with &#39;~&#39;, or if the user or $HOME is unknown,</span>
<span class="c1"># the path is returned unchanged (leaving error reporting to whatever</span>
<span class="c1"># function is called with the expanded path as argument).</span>
<span class="c1"># See also module &#39;glob&#39; for expansion of *, ? and [...] in pathnames.</span>
<span class="c1"># (A function should also be defined to do full *sh-style environment</span>
<span class="c1"># variable expansion.)</span>
<span class="k">def</span><span class="w"> </span><span class="nf">expanduser</span><span class="p">(</span><span class="n">path</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Expand ~ and ~user constructions. If user or $HOME is unknown,</span>
<span class="sd"> do nothing.&quot;&quot;&quot;</span>
<span class="n">path</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">fspath</span><span class="p">(</span><span class="n">path</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">path</span><span class="p">,</span> <span class="nb">bytes</span><span class="p">):</span>
<span class="n">tilde</span> <span class="o">=</span> <span class="sa">b</span><span class="s1">&#39;~&#39;</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">tilde</span> <span class="o">=</span> <span class="s1">&#39;~&#39;</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">path</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="n">tilde</span><span class="p">):</span>
<span class="k">return</span> <span class="n">path</span>
<span class="n">sep</span> <span class="o">=</span> <span class="n">_get_sep</span><span class="p">(</span><span class="n">path</span><span class="p">)</span>
<span class="n">i</span> <span class="o">=</span> <span class="n">path</span><span class="o">.</span><span class="n">find</span><span class="p">(</span><span class="n">sep</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="k">if</span> <span class="n">i</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="n">i</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">path</span><span class="p">)</span>
<span class="k">if</span> <span class="n">i</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
<span class="k">if</span> <span class="s1">&#39;HOME&#39;</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">os</span><span class="o">.</span><span class="n">environ</span><span class="p">:</span>
<span class="k">try</span><span class="p">:</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">pwd</span>
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
<span class="c1"># pwd module unavailable, return path unchanged</span>
<span class="k">return</span> <span class="n">path</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">userhome</span> <span class="o">=</span> <span class="n">pwd</span><span class="o">.</span><span class="n">getpwuid</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">getuid</span><span class="p">())</span><span class="o">.</span><span class="n">pw_dir</span>
<span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
<span class="c1"># bpo-10496: if the current user identifier doesn&#39;t exist in the</span>
<span class="c1"># password database, return the path unchanged</span>
<span class="k">return</span> <span class="n">path</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">userhome</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">environ</span><span class="p">[</span><span class="s1">&#39;HOME&#39;</span><span class="p">]</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">try</span><span class="p">:</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">pwd</span>
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
<span class="c1"># pwd module unavailable, return path unchanged</span>
<span class="k">return</span> <span class="n">path</span>
<span class="n">name</span> <span class="o">=</span> <span class="n">path</span><span class="p">[</span><span class="mi">1</span><span class="p">:</span><span class="n">i</span><span class="p">]</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">name</span><span class="p">,</span> <span class="nb">bytes</span><span class="p">):</span>
<span class="n">name</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">fsdecode</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">pwent</span> <span class="o">=</span> <span class="n">pwd</span><span class="o">.</span><span class="n">getpwnam</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
<span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
<span class="c1"># bpo-10496: if the user name from the path doesn&#39;t exist in the</span>
<span class="c1"># password database, return the path unchanged</span>
<span class="k">return</span> <span class="n">path</span>
<span class="n">userhome</span> <span class="o">=</span> <span class="n">pwent</span><span class="o">.</span><span class="n">pw_dir</span>
<span class="c1"># if no user home, return the path unchanged on VxWorks</span>
<span class="k">if</span> <span class="n">userhome</span> <span class="ow">is</span> <span class="kc">None</span> <span class="ow">and</span> <span class="n">sys</span><span class="o">.</span><span class="n">platform</span> <span class="o">==</span> <span class="s2">&quot;vxworks&quot;</span><span class="p">:</span>
<span class="k">return</span> <span class="n">path</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">path</span><span class="p">,</span> <span class="nb">bytes</span><span class="p">):</span>
<span class="n">userhome</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">fsencode</span><span class="p">(</span><span class="n">userhome</span><span class="p">)</span>
<span class="n">userhome</span> <span class="o">=</span> <span class="n">userhome</span><span class="o">.</span><span class="n">rstrip</span><span class="p">(</span><span class="n">sep</span><span class="p">)</span>
<span class="k">return</span> <span class="p">(</span><span class="n">userhome</span> <span class="o">+</span> <span class="n">path</span><span class="p">[</span><span class="n">i</span><span class="p">:])</span> <span class="ow">or</span> <span class="n">sep</span>
<span class="c1"># Expand paths containing shell variable substitutions.</span>
<span class="c1"># This expands the forms $variable and ${variable} only.</span>
<span class="c1"># Non-existent variables are left unchanged.</span>
<span class="n">_varprog</span> <span class="o">=</span> <span class="kc">None</span>
<span class="n">_varprogb</span> <span class="o">=</span> <span class="kc">None</span>
<span class="k">def</span><span class="w"> </span><span class="nf">expandvars</span><span class="p">(</span><span class="n">path</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Expand shell variables of form $var and ${var}. Unknown variables</span>
<span class="sd"> are left unchanged.&quot;&quot;&quot;</span>
<span class="n">path</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">fspath</span><span class="p">(</span><span class="n">path</span><span class="p">)</span>
<span class="k">global</span> <span class="n">_varprog</span><span class="p">,</span> <span class="n">_varprogb</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">path</span><span class="p">,</span> <span class="nb">bytes</span><span class="p">):</span>
<span class="k">if</span> <span class="sa">b</span><span class="s1">&#39;$&#39;</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">path</span><span class="p">:</span>
<span class="k">return</span> <span class="n">path</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">_varprogb</span><span class="p">:</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">re</span>
<span class="n">_varprogb</span> <span class="o">=</span> <span class="n">re</span><span class="o">.</span><span class="n">compile</span><span class="p">(</span><span class="sa">br</span><span class="s1">&#39;\$(\w+|\{[^}]*\})&#39;</span><span class="p">,</span> <span class="n">re</span><span class="o">.</span><span class="n">ASCII</span><span class="p">)</span>
<span class="n">search</span> <span class="o">=</span> <span class="n">_varprogb</span><span class="o">.</span><span class="n">search</span>
<span class="n">start</span> <span class="o">=</span> <span class="sa">b</span><span class="s1">&#39;{&#39;</span>
<span class="n">end</span> <span class="o">=</span> <span class="sa">b</span><span class="s1">&#39;}&#39;</span>
<span class="n">environ</span> <span class="o">=</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">os</span><span class="p">,</span> <span class="s1">&#39;environb&#39;</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">if</span> <span class="s1">&#39;$&#39;</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">path</span><span class="p">:</span>
<span class="k">return</span> <span class="n">path</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">_varprog</span><span class="p">:</span>
<span class="kn">import</span><span class="w"> </span><span class="nn">re</span>
<span class="n">_varprog</span> <span class="o">=</span> <span class="n">re</span><span class="o">.</span><span class="n">compile</span><span class="p">(</span><span class="sa">r</span><span class="s1">&#39;\$(\w+|\{[^}]*\})&#39;</span><span class="p">,</span> <span class="n">re</span><span class="o">.</span><span class="n">ASCII</span><span class="p">)</span>
<span class="n">search</span> <span class="o">=</span> <span class="n">_varprog</span><span class="o">.</span><span class="n">search</span>
<span class="n">start</span> <span class="o">=</span> <span class="s1">&#39;{&#39;</span>
<span class="n">end</span> <span class="o">=</span> <span class="s1">&#39;}&#39;</span>
<span class="n">environ</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">environ</span>
<span class="n">i</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
<span class="n">m</span> <span class="o">=</span> <span class="n">search</span><span class="p">(</span><span class="n">path</span><span class="p">,</span> <span class="n">i</span><span class="p">)</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">m</span><span class="p">:</span>
<span class="k">break</span>
<span class="n">i</span><span class="p">,</span> <span class="n">j</span> <span class="o">=</span> <span class="n">m</span><span class="o">.</span><span class="n">span</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="n">name</span> <span class="o">=</span> <span class="n">m</span><span class="o">.</span><span class="n">group</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="k">if</span> <span class="n">name</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="n">start</span><span class="p">)</span> <span class="ow">and</span> <span class="n">name</span><span class="o">.</span><span class="n">endswith</span><span class="p">(</span><span class="n">end</span><span class="p">):</span>
<span class="n">name</span> <span class="o">=</span> <span class="n">name</span><span class="p">[</span><span class="mi">1</span><span class="p">:</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
<span class="k">try</span><span class="p">:</span>
<span class="k">if</span> <span class="n">environ</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">value</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">fsencode</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">environ</span><span class="p">[</span><span class="n">os</span><span class="o">.</span><span class="n">fsdecode</span><span class="p">(</span><span class="n">name</span><span class="p">)])</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">value</span> <span class="o">=</span> <span class="n">environ</span><span class="p">[</span><span class="n">name</span><span class="p">]</span>
<span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
<span class="n">i</span> <span class="o">=</span> <span class="n">j</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">tail</span> <span class="o">=</span> <span class="n">path</span><span class="p">[</span><span class="n">j</span><span class="p">:]</span>
<span class="n">path</span> <span class="o">=</span> <span class="n">path</span><span class="p">[:</span><span class="n">i</span><span class="p">]</span> <span class="o">+</span> <span class="n">value</span>
<span class="n">i</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">path</span><span class="p">)</span>
<span class="n">path</span> <span class="o">+=</span> <span class="n">tail</span>
<span class="k">return</span> <span class="n">path</span>
<span class="c1"># Normalize a path, e.g. A//B, A/./B and A/foo/../B all become A/B.</span>
<span class="c1"># It should be understood that this may change the meaning of the path</span>
<span class="c1"># if it contains symbolic links!</span>
<span class="k">try</span><span class="p">:</span>
<span class="kn">from</span><span class="w"> </span><span class="nn">posix</span><span class="w"> </span><span class="kn">import</span> <span class="n">_path_normpath</span> <span class="k">as</span> <span class="n">normpath</span>
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
<span class="k">def</span><span class="w"> </span><span class="nf">normpath</span><span class="p">(</span><span class="n">path</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Normalize path, eliminating double slashes, etc.&quot;&quot;&quot;</span>
<span class="n">path</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">fspath</span><span class="p">(</span><span class="n">path</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">path</span><span class="p">,</span> <span class="nb">bytes</span><span class="p">):</span>
<span class="n">sep</span> <span class="o">=</span> <span class="sa">b</span><span class="s1">&#39;/&#39;</span>
<span class="n">dot</span> <span class="o">=</span> <span class="sa">b</span><span class="s1">&#39;.&#39;</span>
<span class="n">dotdot</span> <span class="o">=</span> <span class="sa">b</span><span class="s1">&#39;..&#39;</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">sep</span> <span class="o">=</span> <span class="s1">&#39;/&#39;</span>
<span class="n">dot</span> <span class="o">=</span> <span class="s1">&#39;.&#39;</span>
<span class="n">dotdot</span> <span class="o">=</span> <span class="s1">&#39;..&#39;</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">path</span><span class="p">:</span>
<span class="k">return</span> <span class="n">dot</span>
<span class="n">_</span><span class="p">,</span> <span class="n">initial_slashes</span><span class="p">,</span> <span class="n">path</span> <span class="o">=</span> <span class="n">splitroot</span><span class="p">(</span><span class="n">path</span><span class="p">)</span>
<span class="n">comps</span> <span class="o">=</span> <span class="n">path</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="n">sep</span><span class="p">)</span>
<span class="n">new_comps</span> <span class="o">=</span> <span class="p">[]</span>
<span class="k">for</span> <span class="n">comp</span> <span class="ow">in</span> <span class="n">comps</span><span class="p">:</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">comp</span> <span class="ow">or</span> <span class="n">comp</span> <span class="o">==</span> <span class="n">dot</span><span class="p">:</span>
<span class="k">continue</span>
<span class="k">if</span> <span class="p">(</span><span class="n">comp</span> <span class="o">!=</span> <span class="n">dotdot</span> <span class="ow">or</span> <span class="p">(</span><span class="ow">not</span> <span class="n">initial_slashes</span> <span class="ow">and</span> <span class="ow">not</span> <span class="n">new_comps</span><span class="p">)</span> <span class="ow">or</span>
<span class="p">(</span><span class="n">new_comps</span> <span class="ow">and</span> <span class="n">new_comps</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span> <span class="o">==</span> <span class="n">dotdot</span><span class="p">)):</span>
<span class="n">new_comps</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">comp</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">new_comps</span><span class="p">:</span>
<span class="n">new_comps</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span>
<span class="n">comps</span> <span class="o">=</span> <span class="n">new_comps</span>
<span class="n">path</span> <span class="o">=</span> <span class="n">initial_slashes</span> <span class="o">+</span> <span class="n">sep</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">comps</span><span class="p">)</span>
<span class="k">return</span> <span class="n">path</span> <span class="ow">or</span> <span class="n">dot</span>
<div class="viewcode-block" id="abspath">
<a class="viewcode-back" href="../api/evennia.server.portal.service.html#evennia.server.portal.service.abspath">[docs]</a>
<span class="k">def</span><span class="w"> </span><span class="nf">abspath</span><span class="p">(</span><span class="n">path</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Return an absolute path.&quot;&quot;&quot;</span>
<span class="n">path</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">fspath</span><span class="p">(</span><span class="n">path</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">path</span><span class="p">,</span> <span class="nb">bytes</span><span class="p">):</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">path</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="sa">b</span><span class="s1">&#39;/&#39;</span><span class="p">):</span>
<span class="n">path</span> <span class="o">=</span> <span class="n">join</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">getcwdb</span><span class="p">(),</span> <span class="n">path</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">path</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s1">&#39;/&#39;</span><span class="p">):</span>
<span class="n">path</span> <span class="o">=</span> <span class="n">join</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">getcwd</span><span class="p">(),</span> <span class="n">path</span><span class="p">)</span>
<span class="k">return</span> <span class="n">normpath</span><span class="p">(</span><span class="n">path</span><span class="p">)</span></div>
<span class="c1"># Return a canonical path (i.e. the absolute location of a file on the</span>
<span class="c1"># filesystem).</span>
<span class="k">def</span><span class="w"> </span><span class="nf">realpath</span><span class="p">(</span><span class="n">filename</span><span class="p">,</span> <span class="o">*</span><span class="p">,</span> <span class="n">strict</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Return the canonical path of the specified filename, eliminating any</span>
<span class="sd">symbolic links encountered in the path.&quot;&quot;&quot;</span>
<span class="n">filename</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">fspath</span><span class="p">(</span><span class="n">filename</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">filename</span><span class="p">,</span> <span class="nb">bytes</span><span class="p">):</span>
<span class="n">sep</span> <span class="o">=</span> <span class="sa">b</span><span class="s1">&#39;/&#39;</span>
<span class="n">curdir</span> <span class="o">=</span> <span class="sa">b</span><span class="s1">&#39;.&#39;</span>
<span class="n">pardir</span> <span class="o">=</span> <span class="sa">b</span><span class="s1">&#39;..&#39;</span>
<span class="n">getcwd</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">getcwdb</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">sep</span> <span class="o">=</span> <span class="s1">&#39;/&#39;</span>
<span class="n">curdir</span> <span class="o">=</span> <span class="s1">&#39;.&#39;</span>
<span class="n">pardir</span> <span class="o">=</span> <span class="s1">&#39;..&#39;</span>
<span class="n">getcwd</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">getcwd</span>
<span class="c1"># The stack of unresolved path parts. When popped, a special value of None</span>
<span class="c1"># indicates that a symlink target has been resolved, and that the original</span>
<span class="c1"># symlink path can be retrieved by popping again. The [::-1] slice is a</span>
<span class="c1"># very fast way of spelling list(reversed(...)).</span>
<span class="n">rest</span> <span class="o">=</span> <span class="n">filename</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="n">sep</span><span class="p">)[::</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
<span class="c1"># Number of unprocessed parts in &#39;rest&#39;. This can differ from len(rest)</span>
<span class="c1"># later, because &#39;rest&#39; might contain markers for unresolved symlinks.</span>
<span class="n">part_count</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">rest</span><span class="p">)</span>
<span class="c1"># The resolved path, which is absolute throughout this function.</span>
<span class="c1"># Note: getcwd() returns a normalized and symlink-free path.</span>
<span class="n">path</span> <span class="o">=</span> <span class="n">sep</span> <span class="k">if</span> <span class="n">filename</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="n">sep</span><span class="p">)</span> <span class="k">else</span> <span class="n">getcwd</span><span class="p">()</span>
<span class="c1"># Mapping from symlink paths to *fully resolved* symlink targets. If a</span>
<span class="c1"># symlink is encountered but not yet resolved, the value is None. This is</span>
<span class="c1"># used both to detect symlink loops and to speed up repeated traversals of</span>
<span class="c1"># the same links.</span>
<span class="n">seen</span> <span class="o">=</span> <span class="p">{}</span>
<span class="k">while</span> <span class="n">part_count</span><span class="p">:</span>
<span class="n">name</span> <span class="o">=</span> <span class="n">rest</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span>
<span class="k">if</span> <span class="n">name</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="c1"># resolved symlink target</span>
<span class="n">seen</span><span class="p">[</span><span class="n">rest</span><span class="o">.</span><span class="n">pop</span><span class="p">()]</span> <span class="o">=</span> <span class="n">path</span>
<span class="k">continue</span>
<span class="n">part_count</span> <span class="o">-=</span> <span class="mi">1</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">name</span> <span class="ow">or</span> <span class="n">name</span> <span class="o">==</span> <span class="n">curdir</span><span class="p">:</span>
<span class="c1"># current dir</span>
<span class="k">continue</span>
<span class="k">if</span> <span class="n">name</span> <span class="o">==</span> <span class="n">pardir</span><span class="p">:</span>
<span class="c1"># parent dir</span>
<span class="n">path</span> <span class="o">=</span> <span class="n">path</span><span class="p">[:</span><span class="n">path</span><span class="o">.</span><span class="n">rindex</span><span class="p">(</span><span class="n">sep</span><span class="p">)]</span> <span class="ow">or</span> <span class="n">sep</span>
<span class="k">continue</span>
<span class="k">if</span> <span class="n">path</span> <span class="o">==</span> <span class="n">sep</span><span class="p">:</span>
<span class="n">newpath</span> <span class="o">=</span> <span class="n">path</span> <span class="o">+</span> <span class="n">name</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">newpath</span> <span class="o">=</span> <span class="n">path</span> <span class="o">+</span> <span class="n">sep</span> <span class="o">+</span> <span class="n">name</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">st_mode</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">lstat</span><span class="p">(</span><span class="n">newpath</span><span class="p">)</span><span class="o">.</span><span class="n">st_mode</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">stat</span><span class="o">.</span><span class="n">S_ISLNK</span><span class="p">(</span><span class="n">st_mode</span><span class="p">):</span>
<span class="k">if</span> <span class="n">strict</span> <span class="ow">and</span> <span class="n">part_count</span> <span class="ow">and</span> <span class="ow">not</span> <span class="n">stat</span><span class="o">.</span><span class="n">S_ISDIR</span><span class="p">(</span><span class="n">st_mode</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">OSError</span><span class="p">(</span><span class="n">errno</span><span class="o">.</span><span class="n">ENOTDIR</span><span class="p">,</span> <span class="n">os</span><span class="o">.</span><span class="n">strerror</span><span class="p">(</span><span class="n">errno</span><span class="o">.</span><span class="n">ENOTDIR</span><span class="p">),</span>
<span class="n">newpath</span><span class="p">)</span>
<span class="n">path</span> <span class="o">=</span> <span class="n">newpath</span>
<span class="k">continue</span>
<span class="k">if</span> <span class="n">newpath</span> <span class="ow">in</span> <span class="n">seen</span><span class="p">:</span>
<span class="c1"># Already seen this path</span>
<span class="n">path</span> <span class="o">=</span> <span class="n">seen</span><span class="p">[</span><span class="n">newpath</span><span class="p">]</span>
<span class="k">if</span> <span class="n">path</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
<span class="c1"># use cached value</span>
<span class="k">continue</span>
<span class="c1"># The symlink is not resolved, so we must have a symlink loop.</span>
<span class="k">if</span> <span class="n">strict</span><span class="p">:</span>
<span class="c1"># Raise OSError(errno.ELOOP)</span>
<span class="n">os</span><span class="o">.</span><span class="n">stat</span><span class="p">(</span><span class="n">newpath</span><span class="p">)</span>
<span class="n">path</span> <span class="o">=</span> <span class="n">newpath</span>
<span class="k">continue</span>
<span class="n">target</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">readlink</span><span class="p">(</span><span class="n">newpath</span><span class="p">)</span>
<span class="k">except</span> <span class="ne">OSError</span><span class="p">:</span>
<span class="k">if</span> <span class="n">strict</span><span class="p">:</span>
<span class="k">raise</span>
<span class="n">path</span> <span class="o">=</span> <span class="n">newpath</span>
<span class="k">continue</span>
<span class="c1"># Resolve the symbolic link</span>
<span class="n">seen</span><span class="p">[</span><span class="n">newpath</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span> <span class="c1"># not resolved symlink</span>
<span class="k">if</span> <span class="n">target</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="n">sep</span><span class="p">):</span>
<span class="c1"># Symlink target is absolute; reset resolved path.</span>
<span class="n">path</span> <span class="o">=</span> <span class="n">sep</span>
<span class="c1"># Push the symlink path onto the stack, and signal its specialness by</span>
<span class="c1"># also pushing None. When these entries are popped, we&#39;ll record the</span>
<span class="c1"># fully-resolved symlink target in the &#39;seen&#39; mapping.</span>
<span class="n">rest</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">newpath</span><span class="p">)</span>
<span class="n">rest</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="kc">None</span><span class="p">)</span>
<span class="c1"># Push the unresolved symlink target parts onto the stack.</span>
<span class="n">target_parts</span> <span class="o">=</span> <span class="n">target</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="n">sep</span><span class="p">)[::</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span>
<span class="n">rest</span><span class="o">.</span><span class="n">extend</span><span class="p">(</span><span class="n">target_parts</span><span class="p">)</span>
<span class="n">part_count</span> <span class="o">+=</span> <span class="nb">len</span><span class="p">(</span><span class="n">target_parts</span><span class="p">)</span>
<span class="k">return</span> <span class="n">path</span>
<span class="n">supports_unicode_filenames</span> <span class="o">=</span> <span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">platform</span> <span class="o">==</span> <span class="s1">&#39;darwin&#39;</span><span class="p">)</span>
<span class="k">def</span><span class="w"> </span><span class="nf">relpath</span><span class="p">(</span><span class="n">path</span><span class="p">,</span> <span class="n">start</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Return a relative version of a path&quot;&quot;&quot;</span>
<span class="n">path</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">fspath</span><span class="p">(</span><span class="n">path</span><span class="p">)</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">path</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;no path specified&quot;</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">path</span><span class="p">,</span> <span class="nb">bytes</span><span class="p">):</span>
<span class="n">curdir</span> <span class="o">=</span> <span class="sa">b</span><span class="s1">&#39;.&#39;</span>
<span class="n">sep</span> <span class="o">=</span> <span class="sa">b</span><span class="s1">&#39;/&#39;</span>
<span class="n">pardir</span> <span class="o">=</span> <span class="sa">b</span><span class="s1">&#39;..&#39;</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">curdir</span> <span class="o">=</span> <span class="s1">&#39;.&#39;</span>
<span class="n">sep</span> <span class="o">=</span> <span class="s1">&#39;/&#39;</span>
<span class="n">pardir</span> <span class="o">=</span> <span class="s1">&#39;..&#39;</span>
<span class="k">if</span> <span class="n">start</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">start</span> <span class="o">=</span> <span class="n">curdir</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">start</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">fspath</span><span class="p">(</span><span class="n">start</span><span class="p">)</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">start_tail</span> <span class="o">=</span> <span class="n">abspath</span><span class="p">(</span><span class="n">start</span><span class="p">)</span><span class="o">.</span><span class="n">lstrip</span><span class="p">(</span><span class="n">sep</span><span class="p">)</span>
<span class="n">path_tail</span> <span class="o">=</span> <span class="n">abspath</span><span class="p">(</span><span class="n">path</span><span class="p">)</span><span class="o">.</span><span class="n">lstrip</span><span class="p">(</span><span class="n">sep</span><span class="p">)</span>
<span class="n">start_list</span> <span class="o">=</span> <span class="n">start_tail</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="n">sep</span><span class="p">)</span> <span class="k">if</span> <span class="n">start_tail</span> <span class="k">else</span> <span class="p">[]</span>
<span class="n">path_list</span> <span class="o">=</span> <span class="n">path_tail</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="n">sep</span><span class="p">)</span> <span class="k">if</span> <span class="n">path_tail</span> <span class="k">else</span> <span class="p">[]</span>
<span class="c1"># Work out how much of the filepath is shared by start and path.</span>
<span class="n">i</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">commonprefix</span><span class="p">([</span><span class="n">start_list</span><span class="p">,</span> <span class="n">path_list</span><span class="p">]))</span>
<span class="n">rel_list</span> <span class="o">=</span> <span class="p">[</span><span class="n">pardir</span><span class="p">]</span> <span class="o">*</span> <span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">start_list</span><span class="p">)</span><span class="o">-</span><span class="n">i</span><span class="p">)</span> <span class="o">+</span> <span class="n">path_list</span><span class="p">[</span><span class="n">i</span><span class="p">:]</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">rel_list</span><span class="p">:</span>
<span class="k">return</span> <span class="n">curdir</span>
<span class="k">return</span> <span class="n">sep</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">rel_list</span><span class="p">)</span>
<span class="k">except</span> <span class="p">(</span><span class="ne">TypeError</span><span class="p">,</span> <span class="ne">AttributeError</span><span class="p">,</span> <span class="ne">BytesWarning</span><span class="p">,</span> <span class="ne">DeprecationWarning</span><span class="p">):</span>
<span class="n">genericpath</span><span class="o">.</span><span class="n">_check_arg_types</span><span class="p">(</span><span class="s1">&#39;relpath&#39;</span><span class="p">,</span> <span class="n">path</span><span class="p">,</span> <span class="n">start</span><span class="p">)</span>
<span class="k">raise</span>
<span class="c1"># Return the longest common sub-path of the sequence of paths given as input.</span>
<span class="c1"># The paths are not normalized before comparing them (this is the</span>
<span class="c1"># responsibility of the caller). Any trailing separator is stripped from the</span>
<span class="c1"># returned path.</span>
<span class="k">def</span><span class="w"> </span><span class="nf">commonpath</span><span class="p">(</span><span class="n">paths</span><span class="p">):</span>
<span class="w"> </span><span class="sd">&quot;&quot;&quot;Given a sequence of path names, returns the longest common sub-path.&quot;&quot;&quot;</span>
<span class="n">paths</span> <span class="o">=</span> <span class="nb">tuple</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">fspath</span><span class="p">,</span> <span class="n">paths</span><span class="p">))</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">paths</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">&#39;commonpath() arg is an empty sequence&#39;</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">paths</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="nb">bytes</span><span class="p">):</span>
<span class="n">sep</span> <span class="o">=</span> <span class="sa">b</span><span class="s1">&#39;/&#39;</span>
<span class="n">curdir</span> <span class="o">=</span> <span class="sa">b</span><span class="s1">&#39;.&#39;</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">sep</span> <span class="o">=</span> <span class="s1">&#39;/&#39;</span>
<span class="n">curdir</span> <span class="o">=</span> <span class="s1">&#39;.&#39;</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">split_paths</span> <span class="o">=</span> <span class="p">[</span><span class="n">path</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="n">sep</span><span class="p">)</span> <span class="k">for</span> <span class="n">path</span> <span class="ow">in</span> <span class="n">paths</span><span class="p">]</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">isabs</span><span class="p">,</span> <span class="o">=</span> <span class="p">{</span><span class="n">p</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="n">sep</span><span class="p">)</span> <span class="k">for</span> <span class="n">p</span> <span class="ow">in</span> <span class="n">paths</span><span class="p">}</span>
<span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">&quot;Can&#39;t mix absolute and relative paths&quot;</span><span class="p">)</span> <span class="kn">from</span><span class="w"> </span><span class="kc">None</span>
<span class="n">split_paths</span> <span class="o">=</span> <span class="p">[[</span><span class="n">c</span> <span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="n">s</span> <span class="k">if</span> <span class="n">c</span> <span class="ow">and</span> <span class="n">c</span> <span class="o">!=</span> <span class="n">curdir</span><span class="p">]</span> <span class="k">for</span> <span class="n">s</span> <span class="ow">in</span> <span class="n">split_paths</span><span class="p">]</span>
<span class="n">s1</span> <span class="o">=</span> <span class="nb">min</span><span class="p">(</span><span class="n">split_paths</span><span class="p">)</span>
<span class="n">s2</span> <span class="o">=</span> <span class="nb">max</span><span class="p">(</span><span class="n">split_paths</span><span class="p">)</span>
<span class="n">common</span> <span class="o">=</span> <span class="n">s1</span>
<span class="k">for</span> <span class="n">i</span><span class="p">,</span> <span class="n">c</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="n">s1</span><span class="p">):</span>
<span class="k">if</span> <span class="n">c</span> <span class="o">!=</span> <span class="n">s2</span><span class="p">[</span><span class="n">i</span><span class="p">]:</span>
<span class="n">common</span> <span class="o">=</span> <span class="n">s1</span><span class="p">[:</span><span class="n">i</span><span class="p">]</span>
<span class="k">break</span>
<span class="n">prefix</span> <span class="o">=</span> <span class="n">sep</span> <span class="k">if</span> <span class="n">isabs</span> <span class="k">else</span> <span class="n">sep</span><span class="p">[:</span><span class="mi">0</span><span class="p">]</span>
<span class="k">return</span> <span class="n">prefix</span> <span class="o">+</span> <span class="n">sep</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">common</span><span class="p">)</span>
<span class="k">except</span> <span class="p">(</span><span class="ne">TypeError</span><span class="p">,</span> <span class="ne">AttributeError</span><span class="p">):</span>
<span class="n">genericpath</span><span class="o">.</span><span class="n">_check_arg_types</span><span class="p">(</span><span class="s1">&#39;commonpath&#39;</span><span class="p">,</span> <span class="o">*</span><span class="n">paths</span><span class="p">)</span>
<span class="k">raise</span>
</pre></div>
</div>
</div>
</div>
</div>
<div class="related" role="navigation" aria-label="related navigation">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="../py-modindex.html" title="Python Module Index"
>modules</a> |</li>
<li class="nav-item nav-item-0"><a href="../index.html">Evennia latest</a> &#187;</li>
<li class="nav-item nav-item-1"><a href="index.html" >Module code</a> &#187;</li>
<li class="nav-item nav-item-this"><a href="">posixpath</a></li>
</ul>
</div>
<div class="footer" role="contentinfo">
&#169; Copyright 2024, The Evennia developer community.
Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 8.2.3.
</div>
</body>
</html>
Reference in a new issue View git blame Copy permalink